Codestin Search App

Chalkboard XOR Game - Problem

Array Math Bit Manipulation Brainteaser Game Theory Hard

The Chalkboard XOR Game is a strategic two-player game where Alice and Bob take turns erasing numbers from a chalkboard.

Here's how it works:
• You're given an array nums representing numbers written on a chalkboard
• Alice starts first, then players alternate turns
• Each turn, a player must erase exactly one number
• If erasing a number causes the XOR of all remaining numbers to become 0, that player loses
• If a player starts their turn with the XOR already equal to 0, they win immediately

Goal: Determine if Alice wins assuming both players play optimally.

XOR Rules:
• XOR of one element = that element itself
• XOR of no elements = 0
• XOR is associative and commutative

Input & Output

example_1.py — Basic Winning Case

$ Input: [1, 1, 2]

› Output: false

💡 Note: Initial XOR = 1⊕1⊕2 = 2 (not 0). Array length = 3 (odd). Since XOR≠0 and length is odd, Bob wins. Alice cannot force a winning position.

example_2.py — Even Length Case

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

› Output: true

💡 Note: Initial XOR = 1⊕1⊕2⊕2 = 0. Alice wins immediately because the XOR is already 0 at the start of her turn.

example_3.py — Strategic Even Case

$ Input: [1, 2, 3]

› Output: false

💡 Note: Initial XOR = 1⊕2⊕3 = 0. Alice wins immediately! Even though length is odd, the initial XOR being 0 gives Alice an instant victory.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] < 2¹⁶
Both players play optimally

Visualization

Tap to expand

Understanding the Visualization

Initial Check

If XOR of all numbers equals 0, Alice wins immediately

Parity Analysis

Even length arrays favor Alice, odd length favor Bob

Strategic Moves

Alice can mirror Bob's strategy when she has the advantage

Optimal Play

Both players play to avoid making XOR=0 on their turn

Key Takeaway

🎯 Key Insight: This problem reduces to pure mathematics - no need to simulate the game! Alice's winning conditions are determined by initial XOR value and array length parity.

Asked in

G Google 35 ⊞ Microsoft 28 Apple 22 a Amazon 18

The Chalkboard XOR Game has an elegant mathematical solution: Alice wins if XOR = 0 initially OR if the array length is even. This is based on game theory - with optimal play, even-length arrays favor Alice due to move parity, while odd-length arrays favor Bob. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Solution (Optimal)	O(n)	O(1)	Use mathematical properties: Alice wins if XOR=0 initially OR array length is even

Mathematical Solution (Optimal) — Algorithm Steps

Calculate the XOR of all elements in the array
If XOR equals 0, Alice wins immediately (rule of the game)
If XOR is not 0, check if array length is even
If length is even, Alice wins; if odd, Bob wins
Return the result based on these conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Initial XOR

If XOR = 0, Alice wins immediately

Check Array Length

If even length, Alice can mirror Bob's moves

Parity Argument

Even arrays favor Alice, odd arrays favor Bob

Mathematical Proof

Based on invariant properties of XOR

Code -

solution.c — C

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

bool xorGame(int* nums, int numsSize) {
    // Calculate XOR of all elements
    int totalXor = 0;
    for (int i = 0; i < numsSize; i++) {
        totalXor ^= nums[i];
    }
    
    // Alice wins if:
    // 1. Initial XOR is 0 (wins immediately), OR
    // 2. Array length is even (can force a win)
    return totalXor == 0 || numsSize % 2 == 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to calculate XOR

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store XOR and length

✓ Linear Space

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

Mathematical Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler