24 Game

24 Game - Problem

You are given an integer array cards of length 4. You have four cards, each containing a number in the range [1, 9].

You should arrange the numbers on these cards in a mathematical expression using the operators ['+', '-', '*', '/'] and the parentheses '(' and ')' to get the value 24.

You are restricted with the following rules:

The division operator '/' represents real division, not integer division. For example, 4 / (1 - 2 / 3) = 4 / (1 / 3) = 12.
Every operation done is between two numbers. In particular, we cannot use '-' as a unary operator. For example, if cards = [1, 1, 1, 1], the expression "-1 - 1 - 1 - 1" is not allowed.
You cannot concatenate numbers together. For example, if cards = [1, 2, 1, 2], the expression "12 + 12" is not valid.

Return true if you can get such expression that evaluates to 24, and false otherwise.

Input & Output

Example 1 — Valid 24 Game

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

› Output: true

💡 Note: We can form (8-4) * (7-1) = 4 * 6 = 24

Example 2 — Invalid 24 Game

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

› Output: false

💡 Note: No valid combination of operations can produce 24 from these numbers

Example 3 — Division Required

$ Input: cards = [3,3,8,8]

› Output: true

💡 Note: We can form (8/(3-8/3)) = 8/(3-8/3) = 8/(1/3) = 24

Constraints

cards.length == 4
1 ≤ cards[i] ≤ 9

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to use backtracking to try all possible combinations of operations and groupings. Convert to floating point numbers and use epsilon comparison for precision. Best approach uses optimized backtracking with smart pruning. Time: O(1), Space: O(1)

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(1) Space: O(1)

Generate all permutations of the 4 numbers, then for each permutation try all combinations of 3 operators. Use recursive backtracking to explore all possible ways to parenthesize the expression.

Optimized Backtracking

⏱️ Time: O(1) Space: O(1)

Uses backtracking but with optimizations like avoiding division by zero, handling floating point precision carefully, and pruning impossible branches early.

Brute Force Backtracking — Algorithm Steps

Step 1: Try all permutations of the 4 cards
Step 2: For each permutation, try all combinations of 3 operators (+, -, *, /)
Step 3: Try all possible ways to group operations with parentheses
Step 4: Check if any combination evaluates to 24

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with 4 numbers from cards

Combine

Pick 2 numbers, try all 4 operations

Recurse

Continue with 3 numbers, then 2, then check if final result is 24

Code -

solution.c — C

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

#define EPS 1e-6

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

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

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    int cards[4];
    char* token = strtok(line, "[,]");
    int i = 0;
    while (token != NULL && i < 4) {
        cards[i++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    bool result = solution(cards);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed input size (4 cards, 4 operators, limited parenthesization patterns) results in constant time

✓ Linear Growth

Space Complexity

O(1)

Recursion depth is bounded by constant (at most 3 levels for 4 numbers)

✓ Linear Space

32.3K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler