Codestin Search App

24 Game - Problem

Imagine you're a mathematician with four number cards in your hand, each showing a digit from 1 to 9. Your challenge? Combine these numbers using basic arithmetic operations (+, -, *, /) and parentheses to create an expression that equals exactly 24!

This is the classic 24 Game - a popular mathematical puzzle that tests your ability to think creatively with numbers. You have complete freedom to:

📝 Rearrange the numbers in any order
🧮 Use any combination of the four basic operations
🔗 Group operations with parentheses however you like

Rules to remember:

Division represents real division, not integer division (so 4 ÷ 3 = 1.333...)
Every operation must be between two numbers - no unary minus allowed
You cannot concatenate digits (no combining 1 and 2 to make 12)
You must use all four cards exactly once

Return true if you can create a valid expression that equals 24, false otherwise.

Input & Output

example_1.py — Basic Success Case

$ Input: [4, 1, 8, 7]

› Output: true

💡 Note: We can create (8-4) × (7-1) = 4 × 6 = 24, so this returns true.

example_2.py — Impossible Case

$ Input: [1, 1, 1, 1]

› Output: false

💡 Note: No matter how we combine four 1's with basic operations, we cannot reach 24. The maximum we can get is 1+1+1+1=4.

example_3.py — Division Required

$ Input: [1, 2, 1, 2]

› Output: false

💡 Note: Even with operations like (1+1) × (2+2) = 8 or (1×2) + (1×2) = 4, we cannot reach 24 with these numbers.

Constraints

cards.length == 4
1 ≤ cards[i] ≤ 9
Precision requirement: Consider two numbers equal if their difference is less than 10^-6

Visualization

Tap to expand

Understanding the Visualization

Root: 4 Numbers

Start with all four cards: [4,1,8,7]

Level 1: Choose First Pair

Pick any 2 numbers to combine first (6 ways to choose pairs)

Level 2: Apply Operations

For each pair, try +, -, *, / operations (up to 6 operations considering order)

Level 3: Recurse with 3 Numbers

Continue with result plus 2 remaining numbers

Leaf: Check Result

When 1 number remains, check if it equals 24

Key Takeaway

🎯 Key Insight: With only 4 numbers, we can afford to try every possible combination systematically. The recursive backtracking explores all ~1500 possibilities efficiently, guaranteeing we find a solution if one exists!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Facebook 12

The optimal approach uses recursive backtracking to systematically try all possible combinations of the 4 numbers with all 4 operations. At each step, we pick any two numbers, apply an operation, and recurse with the result plus remaining numbers. The key insight is that with only 4 numbers, the search space is manageable at roughly O(1536) operations, making this exhaustive approach feasible and guaranteed to find a solution if one exists.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Backtracking (Optimal)	O(1)	O(1)	Try all possible combinations of numbers and operations recursively

Recursive Backtracking (Optimal) — Algorithm Steps

Base case: If only one number remains, check if it equals 24
Try every pair of numbers from the current list
For each pair, try all four operations (+, -, *, /)
Create a new list with the result and remaining numbers
Recursively solve the smaller problem
Handle division by zero and floating point precision

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 4 numbers

Begin with all four cards

Pick any two numbers

Choose a pair to combine first

Try all operations

Test +, -, *, / between the pair

Recurse with 3 numbers

Continue with result + remaining numbers

Base case check

When one number remains, check if it's 24

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

#define EPS 1e-6

bool solve(double* nums, int size) {
    if (size == 1) {
        return fabs(nums[0] - 24) < EPS;
    }
    
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            double a = nums[i], b = nums[j];
            double remaining[4];
            int remainingSize = 0;
            
            for (int k = 0; k < size; k++) {
                if (k != i && k != j) {
                    remaining[remainingSize++] = nums[k];
                }
            }
            
            double candidates[] = {a + b, a - b, b - a, a * b};
            int candidateCount = 4;
            
            if (fabs(b) > EPS) {
                candidates[candidateCount++] = a / b;
            }
            if (fabs(a) > EPS) {
                candidates[candidateCount++] = b / a;
            }
            
            for (int c = 0; c < candidateCount; c++) {
                remaining[remainingSize] = candidates[c];
                if (solve(remaining, remainingSize + 1)) {
                    return true;
                }
            }
        }
    }
    
    return false;
}

bool judgePoint24(int* cards) {
    double nums[4];
    for (int i = 0; i < 4; i++) {
        nums[i] = cards[i];
    }
    return solve(nums, 4);
}

int main() {
    int cards[4];
    scanf("[%d,%d,%d,%d]", &cards[0], &cards[1], &cards[2], &cards[3]);
    printf("%s\n", judgePoint24(cards) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Although complex, it's constant time since we always have exactly 4 numbers - roughly O(4! * 4^3) = O(1536) operations

✓ Linear Growth

Space Complexity

O(1)

Recursion depth is at most 3 levels, and we use constant additional space

✓ Linear Space

42.5K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler