Divisor Game

Divisor Game - Problem

Alice and Bob take turns playing a game, with Alice starting first. Initially, there is a number n on the chalkboard.

On each player's turn, that player makes a move consisting of:

Choosing any integer x with 0 < x < n and n % x == 0
Replacing the number n on the chalkboard with n - x

If a player cannot make a move, they lose the game.

Return true if Alice wins the game, assuming both players play optimally.

Input & Output

Example 1 — Alice Loses (Odd)

$ Input: n = 3

› Output: false

💡 Note: Alice can only choose x=1, giving Bob n=2. Bob then chooses x=1, giving Alice n=1. Alice cannot move and loses.

Example 2 — Alice Wins (Even)

$ Input: n = 4

› Output: true

💡 Note: Alice chooses x=1, giving Bob n=3. Bob must choose x=1, giving Alice n=2. Alice chooses x=1, giving Bob n=1. Bob cannot move and loses.

Example 3 — Base Case

$ Input: n = 2

› Output: true

💡 Note: Alice chooses x=1 (only valid divisor), giving Bob n=1. Bob has no valid moves and loses.

Constraints

1 ≤ n ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 F Facebook 8

The key insight is that Alice wins if and only if n is even. This is because even numbers always have the divisor 1, allowing Alice to give Bob an odd number. Best approach is mathematical pattern recognition with Time: O(1), Space: O(1).

Common Approaches

✓ Dynamic Programming with Memoization

⏱️ Time: O(n²) Space: O(n)

Use memoization to store whether each number is a winning or losing position. This eliminates redundant recursive calls and improves efficiency significantly.

Mathematical Pattern Recognition

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

Through mathematical analysis, we can prove that Alice always wins when n is even and always loses when n is odd. This is because even numbers always have odd divisors, leading to odd results for Bob.

Recursive Simulation

⏱️ Time: O(2^n) Space: O(n)

For each number, try all valid divisor moves and see if any leads to a losing position for the opponent. Use recursion to explore all game states.

Dynamic Programming with Memoization — Algorithm Steps

Step 1: Create a memoization table to cache results
Step 2: For each number, check if result is already computed
Step 3: Try all divisor moves and cache the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute

Calculate result for each number

Cache

Store result in memo table

Reuse

Use cached results for future queries

Code -

solution.c — C

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

int memo[1001];
bool initialized = false;

bool canWin(int num) {
    if (!initialized) {
        memset(memo, -1, sizeof(memo));
        initialized = true;
    }
    
    if (memo[num] != -1) {
        return memo[num];
    }
    
    if (num == 1) {
        memo[num] = 0;
        return false;
    }
    
    for (int x = 1; x < num; x++) {
        if (num % x == 0) {
            if (!canWin(num - x)) {
                memo[num] = 1;
                return true;
            }
        }
    }
    
    memo[num] = 0;
    return false;
}

bool solution(int n) {
    return canWin(n);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each number from 1 to n is computed once, each with up to n divisors

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization table stores result for each number up to n

⚡ Linearithmic Space

66.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler