Stone Removal Game - Practice Coding Problems

Stone Removal Game - Problem

Math Simulation Easy

Alice and Bob's Stone Removal Challenge

Alice and Bob are engaged in a strategic stone removal game that tests their mathematical prowess! Here's how it works:

🎯 Game Rules:
• Alice always goes first and must remove exactly 10 stones on her opening move
• Each subsequent turn, players must remove exactly 1 fewer stone than their opponent's previous move
• The player who cannot make a valid move loses the game

📊 Your Task:
Given a pile of n stones, determine if Alice has a winning strategy. Return true if Alice wins with optimal play, false otherwise.

💡 Example: With 25 stones, Alice takes 10 (15 left), Bob takes 9 (6 left), Alice takes 8 but only 6 remain, so Alice takes 6 and wins!

Input & Output

example_1.py — Basic Win Case

$ Input: n = 25

› Output: true

💡 Note: Alice takes 10 (15 left), Bob takes 9 (6 left), Alice wants to take 8 but only 6 remain, so Alice takes all 6 and wins!

example_2.py — Alice Loses

$ Input: n = 20

› Output: false

💡 Note: Alice takes 10 (10 left), Bob takes 9 (1 left), Alice needs to take 8 but only 1 stone remains, so Alice cannot move and loses.

example_3.py — Insufficient Stones

$ Input: n = 5

› Output: false

💡 Note: Alice cannot even make her first move since she needs 10 stones but only 5 are available.

Constraints

1 ≤ n ≤ 10⁹
Alice must remove exactly 10 stones on her first turn
Each subsequent move must be exactly 1 fewer than the opponent's previous move
Players must make optimal moves

Visualization

Tap to expand

Understanding the Visualization

Identify the Sequence

The game follows a decreasing sequence: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Calculate Total

Sum of sequence 10+9+8+...+1 = 55 stones for a complete game

Analyze Remainder

If n > 55, analyze the remainder pattern to determine who gets stuck first

Determine Winner

Use the pattern to predict if Alice or Bob will be unable to make a move

Key Takeaway

🎯 Key Insight: The game follows a predictable mathematical pattern where we can determine the winner by analyzing the triangular number sequence and remainder stones.

Asked in

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

The simulation approach directly models the game by tracking each player's moves until someone cannot make a valid move. While straightforward, this problem can also be solved with mathematical analysis of the triangular number pattern formed by the sequence 10, 9, 8, 7, ..., 1.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(√n)	O(1)	Simulate the entire game turn by turn until someone cannot make a move

Simulation Approach — Algorithm Steps

Start with Alice taking 10 stones
Alternate between players, reducing stones taken by 1 each turn
Check if current player can make the required move
Return true if Bob gets stuck first, false if Alice gets stuck

Visualization

Tap to expand

Step-by-Step Walkthrough

Alice's Opening

Alice removes exactly 10 stones from the pile

Bob's Response

Bob removes 9 stones (1 fewer than Alice)

Continue Pattern

Players alternate, each taking 1 fewer stone than opponent's last move

Check Victory

The first player who cannot make a required move loses

Code -

solution.c — C

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

bool canAliceWin(int n) {
    if (n < 10) {
        return false;
    }
    
    int remaining = n - 10;  // Alice takes 10 first
    int stonesToTake = 9;    // Bob's turn, takes 1 less than Alice
    bool aliceTurn = false;  // Bob's turn next
    
    while (stonesToTake > 0) {
        if (remaining < stonesToTake) {
            // Current player cannot make the move
            return aliceTurn;  // If it's Alice's turn, she loses (return false)
        }
        
        remaining -= stonesToTake;
        stonesToTake -= 1;
        aliceTurn = !aliceTurn;
    }
    
    // If we reach here, someone needs to take 0 stones, which is invalid
    return !aliceTurn;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", canAliceWin(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We simulate the game which takes at most √n turns since stones decrease from 10, 9, 8, ..., down to 1

✓ Linear Growth

Space Complexity

O(1)

Only need variables to track remaining stones, current move size, and whose turn it is

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler