Make the XOR of All Segments Equal to Zero

Make the XOR of All Segments Equal to Zero - Problem

Make the XOR of All Segments Equal to Zero

You are given an array nums and an integer k. Your goal is to modify the minimum number of elements in the array so that every segment of size k has XOR equal to zero.

A segment [left, right] where left <= right is defined as the XOR of all elements with indices between left and right, inclusive: nums[left] XOR nums[left+1] XOR ... XOR nums[right].

Example: If nums = [3,4,5,2,1,7,3,4,1] and k = 3, then segments of size 3 are:
• [3,4,5] → XOR = 3⊕4⊕5 = 2
• [4,5,2] → XOR = 4⊕5⊕2 = 3
• [5,2,1] → XOR = 5⊕2⊕1 = 6
• And so on...

Your task is to find the minimum number of changes needed to make all these segment XORs equal to zero.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We need to make segments [1,2,0,3] and [2,0,3,0] both have XOR = 0. Currently [1,2,0,3] has XOR = 1^2^0^3 = 0 (already good), and [2,0,3,0] has XOR = 2^0^3^0 = 1. We can change one element in each overlapping segment to make both XOR to 0.

example_2.py — Small Array

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

› Output: 3

💡 Note: For k=3, we have segments [3,4,5], [4,5,2], [5,2,1], [2,1,7], [1,7,3], [7,3,4], [3,4,1]. We need to modify minimum elements so all segments XOR to 0. The cyclic pattern requires elements at positions 0,3,6 to follow one pattern, 1,4,7 another, and 2,5,8 another.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Only one segment [1,2,3,4] with XOR = 1^2^3^4 = 4. We need to change exactly one element to make XOR = 0. We can change any element to make the total XOR equal to 0.

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 1023
1 ≤ k ≤ nums.length
All segments of size k must have XOR equal to zero

Visualization

Tap to expand

Understanding the Visualization

Identify Cyclic Groups

Elements at positions 0,k,2k belong to group 0; 1,k+1,2k+1 to group 1, etc.

Count Frequencies

For each group, count how often each value appears - this helps minimize changes

Dynamic Programming

Build optimal solution incrementally: dp[pos][xor] = minimum changes to achieve XOR=xor at position pos

Find Optimal Answer

The answer is dp[k][0] - minimum changes needed so that all k positions combine to XOR=0

Key Takeaway

🎯 Key Insight: The problem has a beautiful cyclic structure - elements repeat in groups of size k, so we only need to optimize k independent groups using dynamic programming!

Asked in

G Google 45 f Meta 32 ⊞ Microsoft 28 a Amazon 22

The optimal approach uses Dynamic Programming with cyclic grouping. Key insight: elements at positions i and i+k must follow the same pattern. We group elements by position % k, then use DP to track minimum changes needed for each XOR state. Time complexity: O(n × k × 1024), much better than brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(V^n)	O(n)	Try all possible values for each position and check if all segments XOR to zero
Dynamic Programming with Bitmask	O(n * k * V * 1024)	O(k * 1024)	Use dynamic programming to track optimal solutions for each cyclic position and XOR state

Brute Force (Try All Combinations) — Algorithm Steps

For each position i, try all possible values (0 to 1023)
Recursively solve for the remaining positions
Check if all segments of size k have XOR equal to zero
Keep track of minimum changes needed
Return the minimum across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Try all possible values for first element

Recursively explore

For each value, explore all possibilities for remaining positions

Check constraints

At leaf nodes, verify all segments have XOR = 0

Code -

solution.c — C

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

int backtrack(int* nums, int n, int k, int pos, int changes, int maxVal) {
    if (pos >= n) {
        for (int i = 0; i <= n - k; i++) {
            int xorSum = 0;
            for (int j = i; j < i + k; j++) {
                xorSum ^= nums[j];
            }
            if (xorSum != 0) return INT_MAX;
        }
        return changes;
    }
    
    int minChanges = INT_MAX;
    int original = nums[pos];
    
    for (int val = 0; val <= maxVal; val++) {
        nums[pos] = val;
        int cost = changes + (val != original ? 1 : 0);
        int result = backtrack(nums, n, k, pos + 1, cost, maxVal);
        if (result < minChanges) {
            minChanges = result;
        }
    }
    
    nums[pos] = original;
    return minChanges;
}

int minimumOperations(int* nums, int n, int k) {
    int maxVal = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    if (maxVal < 1023) maxVal = 1023;
    return backtrack(nums, n, k, 0, 0, maxVal);
}

int main() {
    int nums[] = {1, 2, 0, 3, 0};
    int k = 4;
    printf("%d\n", minimumOperations(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V^n)

For each of n positions, we try V possible values, leading to exponential time

✓ Linear Growth

Space Complexity

O(n)

Recursion stack can go up to n levels deep

⚡ Linearithmic Space

28.6K Views

Medium Frequency

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler