Game of Nim - Practice Coding Problems

Game of Nim - Problem

Array Math Dynamic Programming Bit Manipulation Brainteaser Game Theory Medium

The Classic Game of Nim

Alice and Bob are playing the ancient mathematical game of Nim. The game starts with n piles of stones, where each pile contains a certain number of stones. Players take turns removing stones from the piles, with Alice going first.

On each turn, a player must:
• Choose any non-empty pile
• Remove any positive number of stones from that pile (from 1 stone up to all remaining stones)

The player who cannot make a move (because all piles are empty) loses the game. Both players play optimally, meaning they always make the best possible move.

Given an integer array piles where piles[i] represents the number of stones in the i-th pile, determine if Alice can guarantee a win. Return true if Alice has a winning strategy, false if Bob will win with optimal play.

Input & Output

example_1.py — Basic winning position

$ Input: piles = [1, 3, 5, 4]

› Output: true

💡 Note: Alice can win. The nim-sum is 1⊕3⊕5⊕4 = 7, which is non-zero. Alice can make a move to force Bob into a losing position (nim-sum = 0).

example_2.py — Balanced losing position

$ Input: piles = [2, 7, 5]

› Output: true

💡 Note: Alice wins because nim-sum = 2⊕7⊕5 = 0⊕5 = 5 ≠ 0. Any non-zero nim-sum means the current player can force a win.

example_3.py — Perfect losing position

$ Input: piles = [3, 4, 7]

› Output: false

💡 Note: Alice loses because nim-sum = 3⊕4⊕7 = 7⊕7 = 0. When nim-sum is 0, the current player is in a losing position with optimal play.

Visualization

Tap to expand

Calculate nim-sum: XOR all pile sizes2. If nim-sum = 0: You're in a losing position (sorry!)3. If nim-sum ≠ 0: You can guarantee a win!4. How to win: Find pile wherepile_size ⊕ nim_sum < pile_size5. Remove stones to make that pileequal to pile_size ⊕ nim_sumThis forces your opponent into nim-sum = 0 (losing position)

Understanding the Visualization

Binary Representation

Convert each pile size to binary and align them in columns

Column-wise XOR

XOR each binary column independently (even 1s become 0, odd 1s become 1)

Interpret Result

If result is all zeros, current player loses; otherwise they can win

Winning Strategy

From non-zero nim-sum, always exists a move to make nim-sum zero for opponent

Key Takeaway

🎯 Key Insight: XOR captures the 'balance' of the game - when balanced (XOR = 0), you lose; when unbalanced, you can always rebalance it in your favor!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all piles to compute XOR

✓ Linear Growth

Space Complexity

O(1)

Only using a single variable to store the nim-sum

✓ Linear Space

Constraints

1 ≤ piles.length ≤ 7
1 ≤ piles[i] ≤ 7
Both players play optimally
Alice always goes first

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses the mathematical property of Nim: compute the XOR (nim-sum) of all pile sizes. If the result is 0, Alice loses; otherwise, Alice can force a win. This elegant O(n) time solution is based on the Sprague-Grundy theorem from combinatorial game theory.

Common Approaches

Approach	Time	Space	Notes
✓ XOR Nim-Sum (Optimal)	O(n)	O(1)	Use the mathematical property: XOR all pile sizes to determine winner instantly

XOR Nim-Sum (Optimal) — Algorithm Steps

Initialize nim_sum to 0
XOR all pile sizes together: nim_sum ^= piles[i] for each pile
If nim_sum equals 0, the current player (Alice) is in a losing position
If nim_sum is non-zero, Alice can force a win
Return true if nim_sum != 0, false otherwise

Visualization

Tap to expand

losing position if and only if the nim-sum is 0.• If nim-sum = 0: Current player will lose with optimal play• If nim-sum ≠ 0: Current player can force a winThis reduces an exponential problem to O(n) time!Why it works: Any move changes the nim-sum, and there's always a movefrom non-zero nim-sum to zero nim-sum (but not vice versa).

Step-by-Step Walkthrough

Convert to Binary

Convert each pile size to binary representation

XOR Operation

Perform XOR operation across all pile sizes

Check Result

If result is 0, current player loses; otherwise wins

Mathematical Proof

Based on Sprague-Grundy theorem from game theory

Code -

solution.c — C

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

bool canWinNim(int* piles, int size) {
    int nimSum = 0;
    for (int i = 0; i < size; i++) {
        nimSum ^= piles[i];
    }
    return nimSum != 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all piles to compute XOR

✓ Linear Growth

Space Complexity

O(1)

Only using a single variable to store the nim-sum

✓ Linear Space

Constraints

1 ≤ piles.length ≤ 7
1 ≤ piles[i] ≤ 7
Both players play optimally
Alice always goes first

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

XOR Nim-Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler