This weekend, my 12-year-old son and I visited our friends for a family BBQ. During our time there, we engaged in a series of math puzzles, competing against each other in a friendly battle of wits. We started by playing ultimate tic-tac-toe using paper and pencil, a game in which he emerged victorious. Next, we challenged each other to solve a math problem, racing to find the solution using traditional methods. He solved the problem within a few minutes, while I was still working on it. (( My 12-year-old son’s solution, (6 + 8 – 6) * 4 + 5 = 37 is similar to the solution the Gen AI engines more often came up with, but is simpler. He used addition and subtraction to achieve the same result the LLM obtained using multiplication and division. ))

I decided to up the ante by proposing a new challenge: I would write a prompt for a generative AI system to solve the same math problem. This led to an exciting competition between us, as we both worked on designing prompts that would enable the top generative AI language models to tackle the problem efficiently.

In this blog post, I share a prompt that successfully guides the leading generative AI language models to solve the problem in a single shot. The approach involves having the language model develop an algorithm, generate the corresponding Python code, and then execute the program to arrive at the solution.

Prompt

Here are the numbers you must use to create an equation that equals the desired result:

<numbers>
6, 8, 6, 4, 5
</numbers>

<result>37</result>

To solve this problem, follow these rules:

1. Use each number as an individual digit, not combined together. For example, use 6 and 8 separately, not combined as 68.
2. Use each number only as many times as it appears in the list above.
3. Use the numbers in the same order as they are listed.
4. You may use any mathematical operation (+, -, *, /, ^, etc.) and parentheses to create the equation.

As your first task, please confirm your understanding of the rules by listing them out in <problem-statement> and <rules> sections.

As your second task, please find or figure out at least five algorithms to solve it. Describe each algorithm to me in an <algorithm> section.

As your third task, in a <planning> section, analyze the pros and cons of each algorithm and select the one you determine has the highest probability of solving it efficiently.

As your fourth task, please generate a python program to solve it. Show me the python code.

As your fifth task, run the python program and show me the result.

Responses

Ragbot.AI ’s response

Profile: Rajiv Personal, AI: openai/gpt-4-turbo, Creativity: 0.75, Date: 2024/May/25

Problem Statement

You have provided a set of numbers: 6, 8, 6, 4, 5, and a target result of 37. The goal is to create an equation using these numbers exactly as listed, using each number exactly as many times as it appears, in the order they are provided, to achieve the target result. You can use basic mathematical operations and parentheses to construct the equation.

Rules

1. Use each number as an individual digit.
2. Use each number only as many times as it appears in the list.
3. Maintain the order of numbers as they appear in the list: 6, 8, 6, 4, 5.
4. Any mathematical operation (addition, subtraction, multiplication, division, exponentiation, etc.) and parentheses can be used to create the equation.

Algorithm

Given the complexity of finding an expression that meets these criteria, we can approach the problem using the following algorithms:

1. Exhaustive Search: Try every possible combination of operations between the numbers until the desired result is achieved. This includes nested operations and the use of parentheses to alter the precedence of operations.
2. Backtracking: Similar to exhaustive search but with a more structured approach to explore all potential combinations of operations. Backtrack when an operation clearly won’t reach the target, reducing the number of unnecessary calculations.
3. Genetic Algorithm: Use a genetic algorithm to evolve solutions over time. Each “individual” in the population could represent a different combination of operations between the numbers, and the fitness function would evaluate how close the expression is to the target value.
4. Dynamic Programming: This might not be directly applicable due to the strict order and single-use constraints, but some form of memoization could be used to store results of sub-expressions to avoid recalculating them.
5. Monte Carlo Simulation: Randomly generate a large number of valid expressions and evaluate them until one that meets the target is found. This method relies heavily on randomness and might be inefficient but can be implemented easily for initial explorations.

Planning

Pros and Cons Analysis:

• Exhaustive Search:
  • Pros: Guaranteed to find a solution if one exists.
  • Cons: Computationally expensive and slow, especially as the number of digits and operations increases.
• Backtracking:
  • Pros: More efficient than exhaustive search by avoiding clearly non-viable paths.
  • Cons: Still potentially slow, complexity remains high.
• Genetic Algorithm:
  • Pros: Can potentially find a solution more quickly than brute-force methods in some cases.
  • Cons: Requires careful tuning, might not find the optimal solution, and overkill for this small set of numbers.
• Dynamic Programming:
  • Pros: Reduces redundancy by reusing results of sub-problems.
  • Cons: Complexity of implementation and might not adapt well to the ordered use constraint.
• Monte Carlo Simulation:
  • Pros: Simple to implement.
  • Cons: Least efficient and relies on chance; not guaranteed to find a solution quickly.

Selection: Given the constraints and the small size of the problem, an Exhaustive Search or Backtracking approach would likely be most effective and straightforward to implement and debug.

Python Program

Let’s implement an exhaustive search approach in Python:

from itertools import product

# Numbers and target result
numbers = [6, 8, 6, 4, 5]
target = 37

# Possible operations
operations = ['+', '-', '*', '/', '**']

# Generate all possible combinations of operations
op_combinations = product(operations, repeat=len(numbers)-1)

# Function to build and evaluate an expression
def evaluate_expression(ops):
    expression = f"{numbers[0]}"
    for num, op in zip(numbers[1:], ops):
        expression += f" {op} {num}"
    try:
        return eval(expression)
    except ZeroDivisionError:
        return None

# Search for a valid expression
for ops in op_combinations:
    if evaluate_expression(ops) == target:
        print(f"Found a valid expression: {numbers[0]} {' '.join(f'{op} {num}' for num, op in zip(numbers[1:], ops))} = {target}")
        break
else:
    print("No valid expression found.")

Run the Program

Next, I will run the provided Python program to check if we can find a valid expression that results in the target value of 37.

It looks like we encountered an error related to an operation resulting in a number too large to handle in our current approach, likely caused by exponentiation leading to overflow. Let’s adjust the Python program to manage or omit the exponentiation in this scenario, as it can produce impractically large numbers. We’ll rerun the script without using exponentiation to ensure the calculations remain within practical limits.

Here’s the revised code that excludes the exponentiation:

from itertools import product

# Numbers and target result
numbers = [6, 8, 6, 4, 5]
target = 37

# Possible operations excluding exponentiation
operations = ['+', '-', '*', '/']

# Generate all possible combinations of operations
op_combinations = product(operations, repeat=len(numbers)-1)

# Function to build and evaluate an expression
def evaluate_expression(ops):
    expression = f"{numbers[0]}"
    for num, op in zip(numbers[1:], ops):
        expression += f" {op} {num}"
    try:
        return eval(expression)
    except ZeroDivisionError:
        return None

# Search for a valid expression
valid_expression = None
for ops in op_combinations:
    if evaluate_expression(ops) == target:
        valid_expression = f"{numbers[0]} {' '.join(f'{op} {num}' for num, op in zip(numbers[1:], ops))} = {target}"
        break

valid_expression

Now, let’s rerun this adjusted script to find a valid expression. ​​

The revised Python program successfully found a valid expression using the given numbers and operations that equals the target result of 37. Here’s the expression:

6 × 8 ÷ 6 × 4 + 5 = 37

This solution successfully uses the numbers in the provided order with appropriate operations to reach the desired result. ​