Chalkboard XOR Game

Chalkboard XOR Game - Problem

Array Math Bit Manipulation Brainteaser Game Theory Hard

You are given an array of integers nums that represents the numbers written on a chalkboard. Alice and Bob take turns erasing exactly one number from the chalkboard, with Alice starting first.

If erasing a number causes the bitwise XOR of all the elements of the chalkboard to become 0, then that player loses. The bitwise XOR of one element is that element itself, and the bitwise XOR of no elements is 0.

Also, if any player starts their turn with the bitwise XOR of all the elements of the chalkboard equal to 0, then that player wins.

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

Input & Output

Example 1 — Basic Losing Case

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

› Output: false

💡 Note: XOR = 1⊕1⊕2 = 2 ≠ 0, and length is odd (3), so Alice loses

Example 2 — Immediate Win

$ Input: nums = [1,2,3]

› Output: true

💡 Note: XOR = 1⊕2⊕3 = 0. Since XOR equals 0 at the start of Alice's turn, Alice wins immediately.

Example 3 — Even Length Win

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

› Output: true

💡 Note: Even though XOR = 0, Alice wins because she starts when XOR=0. Also even length guarantees Alice can win.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] < 2¹⁶

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is that Alice wins if either the initial XOR equals 0 OR the array has even length. This elegant mathematical solution avoids expensive game simulation. Best approach uses game theory with Time: O(n), Space: O(1)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Mathematical Game Theory

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

Based on game theory: Alice wins if either (1) the initial XOR is 0, or (2) the array has even length. This avoids expensive simulation by leveraging mathematical properties of the XOR game.

Recursive Game Simulation

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

Try every possible move for each player recursively. For each turn, try removing each number and see if it leads to a win or loss. Use memoization to avoid recalculating the same board states.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool xorGame(int* nums, int numsSize) {
    // Calculate XOR of all elements
    int xorSum = 0;
    for (int i = 0; i < numsSize; i++) {
        xorSum ^= nums[i];
    }
    
    // Alice wins if:
    // 1. Initial XOR is 0 (she wins immediately)
    // 2. Array length is even (she can always mirror Bob's strategy)
    return xorSum == 0 || numsSize % 2 == 0;
}

int* parseArray(char* line, int* size) {
    *size = 0;
    int capacity = 100;
    int* nums = (int*)malloc(capacity * sizeof(int));
    
    char* ptr = line;
    
    // Skip to first digit or negative sign
    while (*ptr && (*ptr < '0' || *ptr > '9') && *ptr != '-') {
        ptr++;
    }
    
    while (*ptr) {
        if ((*ptr >= '0' && *ptr <= '9') || *ptr == '-') {
            char* endptr;
            int num = strtol(ptr, &endptr, 10);
            
            if (endptr != ptr) { // Valid number parsed
                if (*size >= capacity) {
                    capacity *= 2;
                    nums = (int*)realloc(nums, capacity * sizeof(int));
                }
                nums[(*size)++] = num;
                ptr = endptr;
            } else {
                ptr++;
            }
        } else {
            ptr++;
        }
    }
    
    return nums;
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) != NULL) {
        int size;
        int* nums = parseArray(line, &size);
        
        bool result = xorGame(nums, size);
        printf(result ? "true\n" : "false\n");
        
        free(nums);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

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