> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0679-24-game.md).

# 0679. 24 Game

<https://leetcode.com/problems/24-game>

## Description

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.

**Example 1:**

```
**Input:** cards = [4,1,8,7]
**Output:** true
**Explanation:** (8-4) * (7-1) = 24
```

**Example 2:**

```
**Input:** cards = [1,2,1,2]
**Output:** false
```

**Constraints:**

* `cards.length == 4`
* `1 <= cards[i] <= 9`

## ac

```java
class Solution {
    public boolean judgePoint24(int[] nums) {
        // edge cases

        List<Double> list = new ArrayList<>();
        for (int n : nums) list.add((double) n);

        return dfs(list);
    }

    private boolean dfs(List<Double> list) {
        int n = list.size();
        if (n == 1) return Math.abs(list.get(0) - 24.0) < 0.0001;

        // pick 2 numbers, calculate a new number
        for (int i = 0; i < n-1; i++) {
            for (int j = i + 1; j < n; j++) {
                List<Double> newVal = cal(list.get(i), list.get(j));
                // new list, pick remaining number from old list
                List<Double> newList = new ArrayList<>();
                for (int k = 0; k < n; k++) {
                    if (k != i && k != j) newList.add(list.get(k));
                }
                // backtracking, try new values
                int lastIdx = newList.size();
                for (double d : newVal) {
                    newList.add(d);
                    if (dfs(newList)) return true;
                    newList.remove(lastIdx);
                }
            }
        }

        return false;
    }

    private List<Double> cal(double n1, double n2) {
        List<Double> res = new ArrayList<>();
        res.add(n1 + n2);
        res.add(n1 - n2);
        res.add(n1 * n2);
        res.add(n1 / n2);
        res.add(n2 - n1);
        res.add(n2 / n1);
        return res;
    }
}

/*
1) pick 2 numbers, calculate a new number put back to array. 2) repeat, until only one number in array, check if it's 24.
*/
```