Stone Game - Practice Coding Problems

Stone Game - Problem

Stone Game is a classic two-player strategy game that tests your understanding of dynamic programming and game theory.

Alice and Bob are playing a competitive game with piles of stones arranged in a row. There are an even number of piles, and each pile contains a positive number of stones. The goal is simple: collect the most stones to win!

Here's how the game works:
• Alice goes first (advantage!)
• Players alternate turns
• On each turn, a player must take an entire pile from either the beginning or end of the row
• The game continues until all piles are taken
• The player with the most stones wins

Since the total number of stones is odd, there are no ties possible. Both players play optimally, meaning they always make the best possible move.

Input: An array piles where piles[i] is the number of stones in the i-th pile
Output: true if Alice wins when both players play optimally, false otherwise

Input & Output

example_1.py — Basic Case

$ Input: [5,3,4,5]

› Output: true

💡 Note: Alice can win by taking 5 (index 0), then Bob takes 3, Alice takes 5 (index 3), Bob takes 4. Alice gets 5+5=10, Bob gets 3+4=7. Alice wins!

example_2.py — Another Win

$ Input: [3,7,2,3]

› Output: true

💡 Note: Alice takes 3 (right), Bob takes 3 (left), Alice takes 7, Bob takes 2. Alice gets 3+7=10, Bob gets 3+2=5. Alice wins again!

example_3.py — Always True

$ Input: [1,2,3,4,5,6]

› Output: true

💡 Note: With any even number of piles, Alice can always guarantee a win through optimal strategy, regardless of the actual values.

Visualization

Tap to expand

Understanding the Visualization

Game Setup

Even number of piles arranged in a row, players take from ends only

Position Control

Alice can guarantee either all odd positions or all even positions

Strategic Choice

She picks the strategy that gives her more stones

Guaranteed Victory

Since total is odd, one strategy must be better than the other

Key Takeaway

🎯 Key Insight: Alice always wins because she can choose at the start which 'color' of positions (odd or even) to collect throughout the game, and one color must have more stones than the other!

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each turn has 2 choices, leading to 2^n possible game sequences

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

Constraints

2 <= piles.length <= 500
piles.length is even
1 <= piles[i] <= 500
The sum of piles[i] is odd

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The Stone Game has an elegant mathematical solution: Alice always wins when there are an even number of piles! This is because Alice can force the game to give her either all odd-indexed or all even-indexed piles, and since the total stones is odd, one group must be larger. The optimal solution is O(1) time and requires no calculation - just return true!

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Minimax (Brute Force)	O(2^n)	O(n)	Try all possible game sequences using recursive exploration
Mathematical Insight (Optimal)	O(1)	O(1)	Alice always wins with even number of piles - no calculation needed!
Dynamic Programming (Optimized)	O(n²)	O(n²)	Use memoization to avoid recalculating the same subproblems

Recursive Minimax (Brute Force) — Algorithm Steps

For each turn, try taking from both left and right ends
Recursively calculate the best outcome for remaining piles
Current player maximizes their score difference
Return true if Alice's final score difference is positive

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with full array, Alice's turn

Branch

Try both left and right choices

Recurse

Continue with Bob's optimal response

Backtrack

Return best outcome for current player

Code -

solution.c — C

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

int helper(int* piles, int left, int right, int turn) {
    if (left > right) return 0;
    
    if (turn == 0) { // Alice's turn
        int leftChoice = piles[left] + helper(piles, left + 1, right, 1);
        int rightChoice = piles[right] + helper(piles, left, right - 1, 1);
        return leftChoice > rightChoice ? leftChoice : rightChoice;
    } else { // Bob's turn
        int leftChoice = helper(piles, left + 1, right, 0) - piles[left];
        int rightChoice = helper(piles, left, right - 1, 0) - piles[right];
        return leftChoice < rightChoice ? leftChoice : rightChoice;
    }
}

int stoneGame(int* piles, int pilesSize) {
    return helper(piles, 0, pilesSize - 1, 0) > 0;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int piles[500];
    int count = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        piles[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%s\n", stoneGame(piles, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each turn has 2 choices, leading to 2^n possible game sequences

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

Constraints

2 <= piles.length <= 500
piles.length is even
1 <= piles[i] <= 500
The sum of piles[i] is odd

78.5K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Minimax (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler