24 Game
We can use a recursive function to consider all possible ways to apply the operators between the cards, and check if any of these combinations result in 24.
Here’s a Python code that does this:


Explanation:
 The
dfs
function is a recursive depthfirst search that takes a list of numbers (initially the cards) and tries all possible combinations of binary operations.  In each step, we choose a pair of numbers and apply one of the four operators to them, then call the
dfs
function recursively on the remaining numbers, along with the result of the chosen operation.  If at any point we reach a list with a single number that is equal to 24 (allowing for a small tolerance due to floatingpoint arithmetic), we return
True
.  If we exhaust all possibilities without finding 24, we return
False
.
This code checks all possible combinations and returns True
if any of them result in 24, False
otherwise. The time complexity of this solution is O(4! * 4^4) since we have to consider all permutations and combinations of the four numbers and four operations.
10 Prerequisite LeetCode Problems
“679. 24 Game” requires knowledge of recursion, backtracking, and combinatorics. Here are some simpler problems to prepare for this problem:
78. Subsets: This problem involves generating all possible subsets of a set, which is a good introduction to the concept of recursion and backtracking.
22. Generate Parentheses: This problem requires generating all valid combinations of parentheses, which helps in understanding backtracking.
39. Combination Sum: This problem requires finding all combinations in an array that sum up to a target, which is a good problem for understanding recursion and backtracking.
216. Combination Sum III: This problem extends the previous one by adding the constraint that you must use exactly k numbers, which adds another level of complexity to the backtracking process.
46. Permutations: This problem asks you to generate all permutations of a sequence of numbers. It helps to understand how to traverse all possible combinations in a sequence.
77. Combinations: This problem is about generating all combinations of a certain size from a sequence of numbers. It’s good for understanding recursion and backtracking in a combinatorial context.
241. Different Ways to Add Parentheses: This problem requires you to find different ways to compute a mathematical expression by changing the order of operations. It’s good practice for dealing with mathematical expressions in recursion.
131. Palindrome Partitioning: This problem asks for all possible ways to partition a string into substrings that are palindromes, which is another form of combinatorial problem.
40. Combination Sum II: This problem, similar to Combination Sum, requires finding all unique combinations in an array that sum up to a target.
47. Permutations II: This problem requires generating all permutations of a sequence of numbers, considering there could be duplicates.


Problem Classification
This problem falls under the domain of combinatorics and mathematical expressions.
Components of the problem:
Input: An array of four integers, each representing the number on a card. Each integer is between 1 and 9 inclusive.
Output: A boolean value 
true
if it’s possible to arrange the numbers on the cards using mathematical operators to get a total of 24, andfalse
otherwise.Constraints:
 The division operation is real division, not integer division.
 All operations are binary, i.e., between two numbers.
 Unary operators are not allowed.
 Concatenation of numbers is not allowed.
Based on these components, this problem can be classified as a “Search problem” where the objective is to search through all possible combinations and permutations of numbers and mathematical operations to check if any of them result in a specific value (24 in this case).
Furthermore, given the constraints of the problem (such as no unary operations and no concatenation of numbers), it also touches upon the subdomain of “Parsing and Evaluating Mathematical Expressions”, although in a more limited and specific context than general problems in that subdomain.
The ‘how’ part of the solution likely involves generating all permutations of the numbers and combinations of the operations and then evaluating these expressions to check if any of them equals 24. This is an exhaustive search approach, which is feasible due to the relatively small input size. The problem also likely requires some understanding of the order of operations in mathematics to correctly evaluate the expressions.
Based on the problem statement, the problem can be classified as follows:
Combinatorial Problem: The problem deals with all possible combinations of the given numbers and their various operations. Hence, it involves combinatorics.
Recursion: The problem involves checking each possibility and then recursing on the remaining possibilities.
Number Theory: The problem requires a good understanding of arithmetic operations and the numbers themselves.
Decision Problem: At its core, this problem asks a yesorno question: Can we obtain a certain number (24 in this case) by performing a sequence of operations on the given numbers?
DepthFirst Search (DFS): The recursive nature of the problem also suggests a depthfirst traversal of the tree of all possible combinations of operations and number choices.
The above classifications are based on the conceptual and computational tasks required to solve the problem, not on specific implementation details.
Clarification Questions
What are the clarification questions we can ask about this problem?
Identifying Problem Isomorphism
The problem “24 Game” (#679 on LeetCode) involves using any of the 4 operations (+, , *, /) to manipulate 4 numbers to achieve the final value of 24. You can use parentheses to change the priority of the operations.
An isomorphic problem to this could be “Basic Calculator” (#224 on LeetCode). In this problem, you are given a string s representing a valid expression and you are asked to evaluate this expression and return its value. The string s contains only nonnegative integers, ‘+’, ‘’, ‘*’, ‘/’, ‘(’, and ‘)’. It is guaranteed that the expression is a valid one.
Both problems deal with the manipulation of numbers using arithmetic operations and respecting the priority of operations by considering the use of parentheses. The primary difference is that “24 Game” has a fixed target (24), and you are manipulating specific numbers to reach that target, while “Basic Calculator” is more general, involving the calculation of an arbitrary arithmetic expression.
“24 Game” is more complex because it involves more operations and combinations, and the task of trying to reach a specific target adds an additional layer of challenge. “Basic Calculator” is simpler in that it involves the straightforward evaluation of an arithmetic expression.
Language Agnostic Coding Drills
This Python code uses recursion and combinatorics to solve the problem. Here are the learning units:
Understanding Basic Python Syntax and Control Flow: The basic building block of any program. This includes understanding of for loops, ifelse conditions, function definitions, and calling a function.
Data Types and Variables: Understanding of basic data types in Python, such as lists, integers, floatingpoint numbers, and Boolean. How to define variables and manipulate them.
Understanding itertools and Combinations: The itertools module standardizes a core set of fast, memory efficient tools that are useful by themselves or in combination. Understanding combinations is crucial here, as the code uses the
combinations
function from theitertools
module to generate all possible pairs of indices and their corresponding values.Enumerate Function: Understand how to use the
enumerate
function, which is used for iterating over indices and items of a list.List Comprehensions: Understanding of how list comprehensions work, and how to create and use them. List comprehensions provide a concise way to create lists.
Understanding Sets and Operations: Understand how to define and manipulate sets. The set is a builtin data type in Python, and here it is used to keep the intermediate results.
Recursion: Understanding the concept of recursion and how to use it in functions. This is used in the function
judgePoint24
, where the function calls itself.ProblemSolving Approach and Algorithm Design: Understanding how to approach a problem and design a solution. The key here is recognizing the need to try every possible combination of operations on all pairs of numbers.
The problemsolving approach here is to apply all possible combinations of basic operations (addition, subtraction, multiplication, division) to all pairs of numbers, and to repeat this process on the results until we have only one number left, which we check against the target (24 in this case). The key is to understand that the solution requires us to try all possible operations, on all possible pairs, and to repeat this until we reach the target or exhaust all possibilities. This can be achieved by combining all of the abovementioned drills.
Targeted Drills in Python
Drill 1: Understanding Basic Python Syntax and Control Flow


Drill 2: Data Types and Variables


Drill 3: Understanding itertools and Combinations


Drill 4: Enumerate Function


Drill 5: List Comprehensions


Drill 6: Understanding Sets and Operations


Drill 7: Recursion


Each of these drills represents a unit of learning necessary to understand and implement the final solution. By combining these elements, one can approach solving the problem by iteratively applying operations on combinations of numbers, storing intermediate results in a set, and recursively trying until a solution is found or all options are exhausted.
Python Basics
any
The any()
function in Python 3 is a builtin function that takes an iterable (like a list, tuple, dictionary etc.) and returns True
if any of the elements in the iterable are truthy (i.e., they evaluate to True
in a Boolean context), otherwise it returns False
.
In other words, any()
returns True
if at least one element in the iterable is True
.
Here’s an example:


In the first example, any()
returns True
because there’s at least one True
in the list. In the second example, all elements are False
, so any()
returns False
. In the third example, all elements are falsy (they all evaluate to False
in a Boolean context), so again any()
returns False
.
Note that any()
stops processing as soon as it encounters the first True
element, a property known as shortcircuiting. This can be an advantage in terms of performance when dealing with large iterables.
abs
The abs()
function in Python3 returns the absolute value of a number. The absolute value of a number is its distance from 0 on the number line, regardless of the direction. So, the absolute value of both 10 and 10 is 10.
Here’s how you might use it:


The abs()
function works with integers, floatingpoint numbers, and complex numbers:


In the case of complex numbers, the abs()
function calculates the magnitude (length of the vector from the origin to the point) using the Pythagorean theorem. For a complex number z = a + bj
, the absolute value is calculated as sqrt(a**2 + b**2)
.