Stone Game IX - Practice Coding Problems

Stone Game IX - Problem

Array Math Greedy Counting Game Theory Medium

Welcome to another thrilling chapter in Alice and Bob's strategic stone games! In this game theory puzzle, Alice and Bob face off in a high-stakes battle where one wrong move means instant defeat.

Here's the setup: You have a row of n stones, each with a specific value. Alice goes first, and players alternate turns removing any stone from the collection. But here's the twist that makes this game so treacherous: if the sum of all stones you've removed becomes divisible by 3, you lose immediately!

There's another cruel rule: if Alice can't make a move (no stones left), Bob wins automatically - even if it would have been Alice's turn.

Both players are strategic masterminds who play optimally. Your mission: determine if Alice can secure victory despite these challenging conditions.

Input: An integer array stones where stones[i] represents the value of the i-th stone.
Output: Return true if Alice can win with perfect play, false if Bob will triumph.

Input & Output

example_1.py — Basic Win

$ Input: stones = [2, 1]

› Output: true

💡 Note: Alice picks stone with value 1 (sum=1), then Bob must pick stone with value 2 (sum=3). Since 3 is divisible by 3, Bob loses immediately and Alice wins.

example_2.py — Complex Strategy

$ Input: stones = [1, 3, 5]

› Output: false

💡 Note: All stones have remainder 1 when divided by 3. After Alice's first move (sum=1), Bob picks any stone making sum=2, then Alice picks the last stone making sum=3. Alice loses since 3 is divisible by 3.

example_3.py — Strategic Play

$ Input: stones = [7, 8, 9, 10, 11]

› Output: true

💡 Note: Remainders: [1,2,0,1,2]. Alice can start with remainder 1 stone (value 7), sum=1. Bob picks remainder 2 stone (value 8), sum=2. Alice continues the 1-2-1-2 pattern and eventually forces Bob into a losing position.

Constraints

1 ≤ stones.length ≤ 10⁵
1 ≤ stones[i] ≤ 10⁴
Important: Alice starts first and loses if sum becomes divisible by 3

Visualization

Tap to expand

Understanding the Visualization

Classify Stones

Group all stones by their remainder: 0, 1, or 2 when divided by 3

Identify Danger

Remainder 0 stones are dangerous - they immediately lose the game for whoever picks them when sum > 0

Plan Safe Sequence

Alice must start with remainder 1 or 2, then players alternate: 1→2→1→2... or 2→1→2→1...

Calculate Victory

Alice wins if she can force Bob into having no valid moves while maintaining safe sum

Key Takeaway

🎯 Key Insight: Only remainders matter! Count stones by remainder mod 3, then determine if Alice can force Bob into a losing position using optimal remainder-based strategy.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses game theory analysis by counting stones based on their remainder when divided by 3. Since only remainders matter (not actual values), we can determine the winner in O(n) time by analyzing whether Alice can force Bob into a losing position through strategic remainder management.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursive Game Simulation	O(2^n)	O(2^n)	Simulate all possible game sequences using recursion with memoization
Optimal Game Theory Analysis	O(n)	O(1)	Count remainders mod 3 and use game theory to determine winner in O(n) time

Brute Force Recursive Game Simulation — Algorithm Steps

Create a recursive function that takes current game state and whose turn it is
For each available stone, try removing it and check if sum becomes divisible by 3
If sum is divisible by 3, current player loses
If no stones left, current player loses (Bob wins)
Otherwise, recursively check if opponent can win from new state
Use memoization to cache results for seen states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

All stones available, sum = 0, Alice's turn

Try Each Stone

Alice tries removing each stone that doesn't make sum divisible by 3

Recursive Exploration

For each valid move, recursively check if Bob can win from resulting state

Memoization

Cache results to avoid recalculating same game states

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int mask;
    int sum;
    bool turn;
    bool result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

bool findMemo(int mask, int sum, bool turn, bool* result) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].mask == mask && memo[i].sum == sum && memo[i].turn == turn) {
            *result = memo[i].result;
            return true;
        }
    }
    return false;
}

void addMemo(int mask, int sum, bool turn, bool result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].mask = mask;
        memo[memoSize].sum = sum;
        memo[memoSize].turn = turn;
        memo[memoSize].result = result;
        memoSize++;
    }
}

bool canWin(int* stones, int n, int remainingMask, int currentSum, bool isAliceTurn) {
    bool cached;
    if (findMemo(remainingMask, currentSum, isAliceTurn, &cached)) {
        return cached;
    }
    
    if (currentSum % 3 == 0 && currentSum > 0) {
        addMemo(remainingMask, currentSum, isAliceTurn, false);
        return false;
    }
    
    for (int i = 0; i < n; i++) {
        if (remainingMask & (1 << i)) {
            int newSum = currentSum + stones[i];
            int newMask = remainingMask ^ (1 << i);
            
            if (newSum % 3 == 0) continue;
            
            if (!canWin(stones, n, newMask, newSum, !isAliceTurn)) {
                addMemo(remainingMask, currentSum, isAliceTurn, true);
                return true;
            }
        }
    }
    
    addMemo(remainingMask, currentSum, isAliceTurn, false);
    return false;
}

bool stoneGameIX(int* stones, int stonesSize) {
    memoSize = 0;
    int initialMask = (1 << stonesSize) - 1;
    return canWin(stones, stonesSize, initialMask, 0, true);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int stones[100];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        stones[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%s\n", stoneGameIX(stones, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we explore all possible subsets of stones as game states

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for all possible game states

⚠ Quadratic Space

23.2K Views

Medium Frequency

~25 min Avg. Time

987 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 Recursive Game Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler