Minimum Number of Operations to Make Array XOR Equal to K

Minimum Number of Operations to Make Array XOR Equal to K - Problem

Imagine you're a digital engineer working with binary circuits, and you need to adjust the electrical signals to achieve a specific output pattern. You have an array of integers representing different circuit states, and your goal is to make their combined XOR equal to a target value k.

You can perform one type of operation: flip any bit in any number's binary representation. This means changing a 0 to 1 or a 1 to 0 at any position, including leading zeros.

Your mission: Find the minimum number of bit flips needed to make the XOR of all array elements equal to k.

Example: If you have nums = [2, 1, 3, 4] and k = 1, the current XOR is 2 ⊕ 1 ⊕ 3 ⊕ 4 = 4. You need to transform it to get XOR = 1.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Current XOR: 2⊕1⊕3⊕4 = 4. Target: 1. Difference: 4⊕1 = 5 (binary: 101). Number of 1-bits in 101 is 2, so we need 2 bit flips.

example_2.py — Already Matching

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

› Output: 0

💡 Note: Current XOR: 2⊕0⊕2⊕0 = 0. Target: 0. Difference: 0⊕0 = 0. No bit flips needed.

example_3.py — Single Element

$ Input: nums = [4], k = 7

› Output: 2

💡 Note: Current XOR: 4. Target: 7. Difference: 4⊕7 = 3 (binary: 11). Number of 1-bits in 11 is 2, so we need 2 bit flips.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
0 ≤ k ≤ 10⁶
All array elements and k fit in 32-bit integers

Visualization

Tap to expand

Understanding the Visualization

Compute Array XOR

XOR all numbers to get the current combined pattern

Find Pattern Difference

XOR current pattern with target to see which bits differ

Count Mismatched Bits

Each 1-bit in the difference represents one required flip

Return Flip Count

The number of 1-bits is the minimum operations needed

Key Takeaway

🎯 Key Insight: XOR is self-inverse - the difference between current XOR and target tells us exactly which bits to flip, making this an elegant O(n) solution.

Asked in

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

The optimal solution uses XOR properties: calculate the XOR of all array elements, XOR it with the target k, then count the 1-bits in the result. This gives the minimum number of bit flips needed. Time complexity is O(n) with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Bit Manipulation (One Pass)	O(n)	O(1)	XOR all elements, compare with target, count differing bits
Brute Force (Try All Combinations)	O(2^(32*n))	O(1)	Generate all possible bit flip combinations and find minimum

Optimal Bit Manipulation (One Pass) — Algorithm Steps

Calculate the XOR of all elements in the array
XOR the result with target k to get the difference
Count the number of 1-bits in the difference
Return this count as the minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Array XOR

XOR all elements: 2⊕1⊕3⊕4 = 4

Find Difference

XOR with target: 4⊕1 = 5 (binary: 101)

Count 1-bits

Count bits in 101: two 1-bits = 2 operations

Return Result

Minimum flips needed = 2

Code -

solution.c — C

#include <stdio.h>

int countBits(int n) {
    int count = 0;
    while (n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

int minimumOperations(int nums[], int size, int k) {
    // Calculate XOR of all elements
    int currentXor = 0;
    for (int i = 0; i < size; i++) {
        currentXor ^= nums[i];
    }
    
    // Find difference between current XOR and target
    int diff = currentXor ^ k;
    
    // Count number of 1-bits
    return countBits(diff);
}

// Using GCC builtin for bit counting
int minimumOperationsBuiltin(int nums[], int size, int k) {
    int currentXor = 0;
    for (int i = 0; i < size; i++) {
        currentXor ^= nums[i];
    }
    
    int diff = currentXor ^ k;
    return __builtin_popcount(diff);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to calculate XOR, plus O(log k) to count bits

✓ Linear Growth

Space Complexity

O(1)

Only storing the XOR result and bit count

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Optimal Bit Manipulation (One Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler