Stone Game IX

Stone Game IX - Problem

Array Math Greedy Counting Game Theory Medium

Alice and Bob continue their games with stones. There is a row of n stones, and each stone has an associated value. You are given an integer array stones, where stones[i] is the value of the ith stone.

Alice and Bob take turns, with Alice starting first. On each turn, the player may remove any stone from stones. The player who removes a stone loses if the sum of the values of all removed stones is divisible by 3. Bob will win automatically if there are no remaining stones (even if it is Alice's turn).

Assuming both players play optimally, return true if Alice wins and false if Bob wins.

Input & Output

Example 1 — Alice Wins

$ Input: stones = [2,1]

› Output: true

💡 Note: Alice picks 2 (sum=2), Bob must pick 1 (sum=3), Bob loses since 3 is divisible by 3

Example 2 — Bob Wins

$ Input: stones = [2]

› Output: false

💡 Note: Alice must pick 2 (sum=2), no stones left for Bob, so Bob wins automatically

Example 3 — Only Multiples of 3

$ Input: stones = [3,6,9]

› Output: false

💡 Note: Any first move by Alice creates sum divisible by 3, so Alice loses immediately

Constraints

1 ≤ stones.length ≤ 10⁵
1 ≤ stones[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

The key insight is that Alice loses if she's forced to make the running sum divisible by 3. Group stones by remainder mod 3 and use game theory to check if Alice can maintain a winning pattern. Best approach uses counting with game theory in O(n) time, O(1) space.

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(2^n) Space: O(n)

Use recursion to simulate all possible game states. For each turn, try removing each stone and check if the current player wins in the resulting state.

Game Theory with Counting

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

Group stones by their value modulo 3. Use game theory to determine if Alice can force a win by controlling the sequence of moves.

Brute Force Recursion — Algorithm Steps

Try removing each available stone
Check if sum becomes divisible by 3 (lose)
Recursively check if opponent can win from remaining state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Alice starts with all stones available

Try Each Stone

Recursively explore picking each stone

Check Winner

Player loses if sum divisible by 3

Code -

solution.c — C

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

bool canWin(int turn, int currentSum, bool* available, int* stones, int n) {
    // If no stones left, Bob wins automatically
    bool hasStones = false;
    for (int i = 0; i < n; i++) {
        if (available[i]) {
            hasStones = true;
            break;
        }
    }
    if (!hasStones) return turn == 1;  // True if Bob's turn, False if Alice's turn
    
    // Try each available stone
    for (int i = 0; i < n; i++) {
        if (available[i]) {
            int newSum = currentSum + stones[i];
            // If sum divisible by 3, current player loses
            if (newSum % 3 == 0) {
                continue;
            }
            
            // Remove stone and check if opponent loses
            available[i] = false;
            if (!canWin(1 - turn, newSum, available, stones, n)) {
                available[i] = true;
                return true;
            }
            available[i] = true;
        }
    }
    
    return false;
}

bool solution(int* stones, int n) {
    bool* available = (bool*)malloc(n * sizeof(bool));
    for (int i = 0; i < n; i++) {
        available[i] = true;
    }
    
    bool result = canWin(0, 0, available, stones, n);
    free(available);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array using strtol
    static int stones[1000];
    int n = 0;
    
    const char* p = line;
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endp;
        long val = strtol(p, &endp, 10);
        if (endp != p && n < 1000) {
            stones[n++] = (int)val;
            p = endp;
        } else {
            break;
        }
    }
    
    bool result = solution(stones, n);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each stone can be picked or not picked, creating exponential branches

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth up to n levels

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler