Stone Game III - Practice Coding Problems

Stone Game III - Problem

Welcome to another thrilling round of Alice and Bob's Stone Game! 🎮

In this strategic battle, Alice and Bob face a row of stones, each carrying a specific point value (which can be positive, negative, or zero). The twist? Players must take stones from the beginning of the row, and they can grab 1, 2, or 3 stones per turn.

Game Rules:

Alice always goes first
Players alternate turns
On each turn, a player must take 1, 2, or 3 stones from the front
Each player's score = sum of values of stones they collected
Both players play optimally (always make the best possible move)

Your mission: Determine who wins when both players play perfectly! Return "Alice" if Alice wins, "Bob" if Bob wins, or "Tie" if they end with equal scores.

Example: For stones [1,2,3,7], Alice takes 3 stones (1+2+3=6), Bob takes the last stone (7), Bob wins with 7 > 6.

Input & Output

example_1.py — Basic Game

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

› Output: Bob

💡 Note: Alice takes 3 stones (1+2+3=6), Bob takes the remaining stone (7). Bob wins 7 > 6.

example_2.py — Negative Values

$ Input: [1,2,3,-9]

› Output: Alice

💡 Note: Alice takes 3 stones (1+2+3=6), Bob is forced to take -9. Alice wins 6 > -9.

example_3.py — Tie Game

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

› Output: Tie

💡 Note: Alice takes 3 stones (1+2+3=6), Bob takes 1 stone (6). Both end with score 6, it's a tie.

Visualization

Tap to expand

Understanding the Visualization

Current Player's Turn

Consider taking 1, 2, or 3 stones from the front

Score Current Move

Calculate the sum of stones taken in this move

Opponent's Response

Assume opponent plays optimally from remaining stones

Maximize Advantage

Choose the move that gives maximum score difference

Cache Result

Store result to avoid recalculating this position

Key Takeaway

🎯 Key Insight: Transform the two-player problem into a single-player optimization by tracking score differences. Use memoization for optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is calculated exactly once, with O(1) work per position

✓ Linear Growth

Space Complexity

O(n)

Memoization cache stores result for each position, plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ stoneValue.length ≤ 5 × 10⁴
-1000 ≤ stoneValue[i] ≤ 1000
Both players play optimally

Asked in

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

This is a classic game theory problem solved with dynamic programming. The key insight is to track the maximum score difference the current player can achieve rather than individual scores. Use memoization to avoid recalculating the same game states, achieving O(n) time complexity. Each player tries taking 1, 2, or 3 stones and chooses the move that maximizes their advantage over the opponent.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Dynamic Programming (Optimal)	O(n)	O(n)	Use memoization to avoid recalculating the same game states
Brute Force Recursion	O(3^n)	O(n)	Try all possible moves recursively for both players

Memoized Dynamic Programming (Optimal) — Algorithm Steps

Create a memoization cache (dictionary/array) to store calculated results
For each position, check if result is already cached
If not cached, calculate using the same recursive logic as brute force
Store the result in cache before returning
Return cached result for future calls to same position

Visualization

Tap to expand

Step-by-Step Walkthrough

Cache Miss

First time visiting position i, calculate result

Store Result

Cache the calculated maximum advantage for position i

Cache Hit

Subsequent calls to same position return cached result instantly

Build Solution

Work backwards from end positions to build complete solution

Code -

solution.c — C

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

#define MAX_SIZE 50000

int memo[MAX_SIZE];
int memo_set[MAX_SIZE];

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int dfs(int* stoneValue, int size, int i) {
    if (i >= size) {
        return 0;
    }
    
    if (memo_set[i]) {
        return memo[i];
    }
    
    int res = INT_MIN;
    int currentSum = 0;
    
    // Try taking 1, 2, or 3 stones
    for (int j = 0; j < min(3, size - i); j++) {
        currentSum += stoneValue[i + j];
        res = max(res, currentSum - dfs(stoneValue, size, i + j + 1));
    }
    
    memo[i] = res;
    memo_set[i] = 1;
    return res;
}

char* stoneGameIII(int* stoneValue, int stoneValueSize) {
    // Clear memoization arrays
    memset(memo_set, 0, sizeof(memo_set));
    
    int diff = dfs(stoneValue, stoneValueSize, 0);
    char* result = (char*)malloc(6 * sizeof(char));
    
    if (diff > 0) {
        strcpy(result, "Alice");
    } else if (diff < 0) {
        strcpy(result, "Bob");
    } else {
        strcpy(result, "Tie");
    }
    
    return result;
}

int main() {
    int stones[] = {1, 2, 3, 7};
    char* result = stoneGameIII(stones, 4);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is calculated exactly once, with O(1) work per position

✓ Linear Growth

Space Complexity

O(n)

Memoization cache stores result for each position, plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ stoneValue.length ≤ 5 × 10⁴
-1000 ≤ stoneValue[i] ≤ 1000
Both players play optimally

89.2K Views

Medium-High Frequency

~18 min Avg. Time

1.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

Memoized Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler