Nim Game

Nim Game - Problem

You are playing the following Nim Game with your friend:

Initially, there is a heap of stones on the table. You and your friend will alternate taking turns, and you go first. On each turn, the person whose turn it is will remove 1 to 3 stones from the heap. The one who removes the last stone is the winner.

Given n, the number of stones in the heap, return true if you can win the game assuming both you and your friend play optimally, otherwise return false.

Input & Output

Example 1 — Small Winning Position

$ Input: n = 4

› Output: false

💡 Note: No matter what you choose (1, 2, or 3 stones), your opponent can take the remaining stones and win. If you take 1, opponent can take 3. If you take 2, opponent can take 2. If you take 3, opponent can take 1.

Example 2 — Winning Move Available

$ Input: n = 1

› Output: true

💡 Note: You can take the last stone directly and win the game.

Example 3 — Strategic Winning

$ Input: n = 5

› Output: true

💡 Note: You can take 1 stone, leaving 4 stones for your opponent. From 4 stones, your opponent will be in a losing position (any move they make puts you in a winning position).

Constraints

1 ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

A Adobe 15 M Microsoft 8

The key insight is recognizing the mathematical pattern: positions where n is divisible by 4 are always losing positions. The optimal approach uses modulo arithmetic to check if n % 4 == 0. Time: O(1), Space: O(1)

Common Approaches

✓ Dynamic Programming / Recursion

⏱️ Time: O(3ⁿ) Space: O(n)

For each position, check if taking 1, 2, or 3 stones leads to a losing position for the opponent. If any move puts the opponent in a losing position, the current player wins.

Mathematical Pattern Recognition

⏱️ Time: O(1) Space: O(1)

Through mathematical analysis, we discover that if n is divisible by 4, the current player is in a losing position. Otherwise, they can always move to put their opponent in a losing position.

Dynamic Programming / Recursion — Algorithm Steps

Step 1: Base case - if n ≤ 3, first player wins
Step 2: For each n, try removing 1, 2, or 3 stones
Step 3: If any move puts opponent in losing position, current player wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Current Position

Check if current player can win from n stones

Try All Moves

Test taking 1, 2, or 3 stones

Find Winning Move

If any move puts opponent in losing position, we win

Code -

solution.c — C

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

int solution(int n) {
    // For large n, use the mathematical approach
    // since memoization with arrays isn't feasible
    return n % 4 != 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(3ⁿ)

Each position branches into 3 recursive calls, creating exponential growth

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to n levels deep

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~5 min Avg. Time

890 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

Dynamic Programming / Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler