Make the XOR of All Segments Equal to Zero - Problem

You are given an array nums and an integer k. The XOR of a segment [left, right] where left <= right is the XOR of all the elements with indices between left and right, inclusive: nums[left] XOR nums[left+1] XOR ... XOR nums[right].

Return the minimum number of elements to change in the array such that the XOR of all segments of size k is equal to zero.

A segment of size k starting at position i includes elements nums[i], nums[i+1], ..., nums[i+k-1].

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We need segments [1,2,0], [2,0,3], [0,3,1] to all XOR to 0. One solution: change nums to [0,0,0,0,0], requiring 3 changes (positions 0,1,3).

Example 2 — Smaller Array

$ Input: nums = [3,4,5,2], k = 2

› Output: 2

💡 Note: Segments are [3,4], [4,5], [5,2] with XORs 7, 1, 7. To make all XORs equal 0, we can change the array to [0,0,0,0], requiring 2 changes.

Example 3 — Minimum Size

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

› Output: 1

💡 Note: Only one segment [1,2]. Need 1⊕2=3 to become 0. Change one element: [0,0] gives 0⊕0=0. Cost: 1 change.

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ k ≤ nums.length
0 ≤ nums[i] < 2¹⁰

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that positions with the same remainder when divided by k must have related values across all segments. The optimal approach uses dynamic programming to group positions and find minimum-cost assignments that make all segments XOR to zero. Time: O(n × 1024), Space: O(k × 1024)

Common Approaches

✓ Dfs

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

Brute Force with Backtracking

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

For each element, try all possible values (0-1023) and recursively check if all segments XOR to zero. Use backtracking to explore all combinations and return the minimum changes needed.

Dynamic Programming with Position Groups

⏱️ Time: O(n × 1024) Space: O(k × 1024)

Key insight: positions i and i+k must have the same relationship in all segments. Group positions by their remainder when divided by k, then use dynamic programming to assign optimal values to each group ensuring all segments XOR to zero.

Optimized Greedy with Pattern Recognition

⏱️ Time: O(n) Space: O(k + unique_values)

Recognize that positions with same remainder mod k must follow a pattern. For each group of positions (i % k), find the most frequent value and change others to match. Use XOR properties to ensure segments sum to zero.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000

static int nums[MAX_N];
static int n, k;

int backtrack(int pos, int changes) {
    if (pos == n) {
        // Check all segments
        for (int i = 0; i <= n - k; i++) {
            int xor_sum = 0;
            for (int j = i; j < i + k; j++) {
                xor_sum ^= nums[j];
            }
            if (xor_sum != 0) {
                return INT_MAX;
            }
        }
        return changes;
    }
    
    // Try keeping current value
    int result = backtrack(pos + 1, changes);
    
    // Try changing to different values
    int original = nums[pos];
    for (int val = 0; val < 1024; val++) {
        if (val != original) {
            nums[pos] = val;
            int candidate = backtrack(pos + 1, changes + 1);
            if (candidate < result) {
                result = candidate;
            }
        }
    }
    nums[pos] = original;
    
    return result;
}

int solution(int input_nums[], int input_n, int input_k) {
    for (int i = 0; i < input_n; i++) {
        nums[i] = input_nums[i];
    }
    n = input_n;
    k = input_k;
    
    if (n < k) {
        return 0;
    }
    
    return backtrack(0, 0);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int input_nums[MAX_N];
    int count = 0;
    
    // Parse array [1,2] format
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            input_nums[count++] = (int)strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    int input_k;
    scanf("%d", &input_k);
    
    printf("%d\n", solution(input_nums, count, input_k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

427 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