Bitwise XOR of All Pairings - Practice Coding Problems

Bitwise XOR of All Pairings - Problem

Imagine you have two arrays of non-negative integers, nums1 and nums2. Your task is to create all possible pairs where you take one number from nums1 and one number from nums2, then calculate the bitwise XOR of each pair.

For example, if nums1 = [2, 1] and nums2 = [1, 3], you would create pairs: (2, 1), (2, 3), (1, 1), and (1, 3). The XOR values would be [3, 1, 0, 2].

Finally, you need to return the XOR of all these XOR values. This might seem like you need to compute all pairs explicitly, but there's a clever mathematical pattern that can solve this much more efficiently!

Can you find the pattern that avoids computing all O(m×n) pairs?

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [2,1], nums2 = [1,3]

› Output: 0

💡 Note: All pairings: (2,1)→3, (2,3)→1, (1,1)→0, (1,3)→2. Final XOR: 3⊕1⊕0⊕2 = 0. Using the optimal approach: both arrays have even-length counterparts, so all contributions cancel out.

example_2.py — Single Elements

$ Input: nums1 = [1], nums2 = [6]

› Output: 7

💡 Note: Only one pairing: (1,6)→7. Since nums2 has length 1 (odd), nums1's XOR (which is 1) contributes. Since nums1 has length 1 (odd), nums2's XOR (which is 6) contributes. Result: 1⊕6 = 7.

example_3.py — Mixed Lengths

$ Input: nums1 = [1,2,3], nums2 = [4,5]

› Output: 4

💡 Note: nums1 XOR = 1⊕2⊕3 = 0, nums2 XOR = 4⊕5 = 1. Since len(nums2)=2 is even, nums1's contribution cancels. Since len(nums1)=3 is odd, nums2's contribution (1) remains. Result: 1.

Visualization

Tap to expand

Understanding the Visualization

Count the Dances

Each nums1 element dances len(nums2) times, each nums2 element dances len(nums1) times

Find the Survivors

Only dancers with odd performance counts contribute to the final result

Combine Contributions

XOR the surviving group contributions together

Key Takeaway

🎯 Key Insight: XOR's self-canceling property (x ⊕ x = 0) means we only need to count occurrences and track which elements appear an odd number of times!

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We need to generate all m × n pairs and compute XOR for each

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the result variable

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
0 ≤ nums1[i], nums2[j] ≤ 10⁹
Arrays contain only non-negative integers

Asked in

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

The key insight is recognizing that XOR properties allow us to avoid generating all pairs. Each element appears a predictable number of times, and since x ⊕ x = 0, even occurrences cancel out. The optimal solution runs in O(m + n) time by computing XOR sums and checking array length parities.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Pairs)	O(m × n)	O(1)	Compute XOR of every possible pair and then XOR all results together
Mathematical Insight (Optimal)	O(m + n)	O(1)	Use XOR properties: result depends only on array lengths and XOR sums

Brute Force (All Pairs) — Algorithm Steps

Create a result variable initialized to 0
For each element in nums1, pair it with every element in nums2
Compute the XOR of each pair
XOR the pair result with our running result
Return the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with result = 0

Generate Pairs

Create all possible (nums1[i], nums2[j]) pairs

XOR Each Pair

Compute nums1[i] ^ nums2[j] for each pair

Accumulate

XOR each pair result with the running total

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <cjson/cJSON.h>

int getXORSum(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int result = 0;
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            result ^= (nums1[i] ^ nums2[j]);
        }
    }
    return result;
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    cJSON *json = cJSON_Parse(buffer);
    cJSON *nums1_json = cJSON_GetObjectItem(json, "nums1");
    cJSON *nums2_json = cJSON_GetObjectItem(json, "nums2");
    
    int nums1Size = cJSON_GetArraySize(nums1_json);
    int nums2Size = cJSON_GetArraySize(nums2_json);
    
    int *nums1 = malloc(nums1Size * sizeof(int));
    int *nums2 = malloc(nums2Size * sizeof(int));
    
    for (int i = 0; i < nums1Size; i++) {
        nums1[i] = cJSON_GetArrayItem(nums1_json, i)->valueint;
    }
    for (int i = 0; i < nums2Size; i++) {
        nums2[i] = cJSON_GetArrayItem(nums2_json, i)->valueint;
    }
    
    printf("%d\n", getXORSum(nums1, nums1Size, nums2, nums2Size));
    
    free(nums1);
    free(nums2);
    cJSON_Delete(json);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We need to generate all m × n pairs and compute XOR for each

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the result variable

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
0 ≤ nums1[i], nums2[j] ≤ 10⁹
Arrays contain only non-negative integers

42.0K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler