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

You are given a 0-indexed integer array nums and a positive integer k.

You can apply the following operation on the array any number of times:

Choose any element of the array and flip a bit in its binary representation. Flipping a bit means changing a 0 to 1 or vice versa.

Return the minimum number of operations required to make the bitwise XOR of all elements of the final array equal to k.

Note: You can flip leading zero bits in the binary representation of elements. For example, for the number (101)₂ you can flip the fourth bit and obtain (1101)₂.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Current XOR = 2⊕1⊕3⊕4 = 4. To get k=1, we need 4⊕1=5. Binary 5 = 101 has 2 bits set, so 2 operations needed.

Example 2 — Already Equal

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

› Output: 0

💡 Note: Current XOR = 2⊕0⊕2⊕0 = 0, which equals k=0. No operations needed.

Example 3 — Single Element

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

› Output: 2

💡 Note: Current XOR = 5. To get k=3, we need 5⊕3=6. Binary 6 = 110 has 2 bits set, so 2 operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
0 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that we only need to count differing bits between the current XOR and target K. Best approach is bit manipulation - calculate array XOR, compare with K, and count different bits. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force

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

Generate all possible combinations of bit flips for each element and check which combination gives the minimum operations to achieve target XOR k.

Optimal Bit Manipulation

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

Calculate the XOR of all elements in the array, then compare it with target K. Count the number of differing bits - each different bit requires exactly one flip operation.

Brute Force — Algorithm Steps

Step 1: Generate all possible bit flip combinations
Step 2: For each combination, calculate XOR and check if equals k
Step 3: Return minimum operations among valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible bit flip combinations

Check Each

Calculate XOR for each combination

Find Minimum

Return combination with minimum operations

Code -

solution.c — C

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

int solution(int* nums, int n, int k) {
    // Calculate XOR of all elements
    int currentXor = 0;
    for (int i = 0; i < n; i++) {
        currentXor ^= nums[i];
    }
    
    // Find difference between current XOR and target k
    int diff = currentXor ^ k;
    
    // Count number of set bits in the difference
    int operations = 0;
    while (diff > 0) {
        operations += diff & 1;
        diff >>= 1;
    }
    
    return operations;
}

static int nums[100000];

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        
        long val = strtol(ptr, &ptr, 10);
        nums[n++] = (int)val;
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×32))

Each element can have up to 32 bits flipped in 2^32 ways, with n elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler