24 Game - Practice Coding Problems

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

Understanding the Visualization

Input

4 cards with numbers [4,1,8,7]

Process

Try all combinations of +, -, *, / with different groupings

Output

Return true if any combination equals 24

Key Takeaway

🎯 Key Insight: Use backtracking to systematically try all possible combinations of operations and groupings

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

Approach	Time	Space	Notes
✓ Optimized Backtracking	O(1)	O(1)	Smart backtracking with early pruning and precision handling
Brute Force Backtracking	O(1)	O(1)	Try all possible combinations of numbers and operations recursively

Optimized Backtracking — Algorithm Steps

Step 1: Convert integers to floating point for precise division
Step 2: Use epsilon comparison for floating point equality
Step 3: Avoid redundant permutations by trying operations in both directions
Step 4: Prune branches that cannot possibly reach 24

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Convert to floats, set epsilon for precision

Smart Combining

Try operations in both directions, skip invalid divisions

Early Exit

Return immediately when 24 is found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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.0) < 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 operations[6] = {a + b, a - b, b - a, a * b, 0, 0};
            int opCount = 4;
            if (fabs(b) > EPS) {
                operations[opCount++] = a / b;
            }
            if (fabs(a) > EPS) {
                operations[opCount++] = b / a;
            }
            
            for (int op = 0; op < opCount; op++) {
                remaining[remainingSize] = operations[op];
                if (solve(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 solve(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 leads to constant number of operations regardless of values

✓ Linear Growth

Space Complexity

O(1)

Recursion depth is constant (at most 3 recursive calls for 4 numbers)

✓ Linear Space

32.0K 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

Optimized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler