Minimum XOR Sum of Two Arrays - Practice Coding Problems

Minimum XOR Sum of Two Arrays - Problem

You are given two integer arrays nums1 and nums2, both of length n. Your task is to find an optimal pairing strategy that minimizes the total XOR sum.

The XOR sum is calculated as: (nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n-1] XOR nums2[n-1])

For example: If nums1 = [1,2,3] and nums2 = [3,2,1], the XOR sum equals (1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4

You can rearrange the elements of nums2 in any order to minimize this sum. Your goal is to find the arrangement that produces the smallest possible XOR sum.

Key insight: XOR operations have unique properties that can be exploited - when two identical numbers are XORed, the result is 0, and XOR values tend to be smaller when the binary representations of numbers are similar.

Input & Output

example_1.py — Python

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

› Output: 1

💡 Note: Rearrange nums2 to [3,2]. XOR sum = (1^3) + (2^2) = 2 + 0 = 2. Alternative: [2,3] gives (1^2) + (2^3) = 3 + 1 = 4. Minimum is 1 when we use [3,2].

example_2.py — Python

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

› Output: 8

💡 Note: Optimal arrangement: nums2 = [5,4,3]. XOR sum = (1^5) + (0^4) + (3^3) = 4 + 4 + 0 = 8. The key insight is pairing 3 with 3 to get 0.

example_3.py — Python

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

› Output: 0

💡 Note: Only one element in each array. XOR sum = 1^1 = 0, which is the minimum possible XOR value.

Visualization

Tap to expand

Understanding the Visualization

Problem Setup

We have fixed seats (nums1) and flexible guests (nums2)

DP States

Each bitmask represents which guests have been seated

Transitions

For each empty seat, try all remaining guests

Optimal Solution

Find minimum cost when all guests are seated

Key Takeaway

🎯 Key Insight: Use bitmask DP where each bit represents assignment status, allowing efficient exploration of all O(2ⁿ) possible partial assignments while avoiding redundant computations.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

For each of 2ⁿ possible masks, we consider n positions and n choices

⚠ Quadratic Growth

Space Complexity

O(2ⁿ)

DP array to store results for each possible mask

✓ Linear Space

Constraints

n == nums1.length
n == nums2.length
1 ≤ n ≤ 14
0 ≤ nums1[i], nums2[i] ≤ 10⁷
Note: The constraint n ≤ 14 makes bitmask DP feasible since 2¹⁴ = 16,384 is manageable

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses dynamic programming with bitmasks in O(n² × 2ⁿ) time. Each bit in the mask represents whether an element from nums2 has been used. We build the solution by considering each position in nums1 sequentially and trying all unused elements from nums2, maintaining the minimum XOR sum for each state.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(n² × 2ⁿ)	O(2ⁿ)	Use bitmask DP to efficiently explore all assignment possibilities
Brute Force (All Permutations)	O(n! × n)	O(n)	Generate all permutations of nums2 and calculate XOR sum for each

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Initialize DP array where dp[mask] represents minimum XOR sum for the given mask
For each position i in nums1, try assigning each unused element from nums2
Update DP state by setting the corresponding bit in the mask
Return the value when all elements are assigned (mask = (1<<n)-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = 0, all others to infinity

State Transition

For each mask, try adding one more element

Update States

Update dp[new_mask] with minimum cost

Code -

solution.c — C

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

int popCount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int minimumXORSum(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int n = nums1Size;
    int* dp = malloc((1 << n) * sizeof(int));
    
    for (int i = 0; i < (1 << n); i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        if (dp[mask] == INT_MAX) continue;
        
        int pos = popCount(mask);
        if (pos >= n) continue;
        
        for (int i = 0; i < n; i++) {
            if (!(mask & (1 << i))) {
                int newMask = mask | (1 << i);
                int newCost = dp[mask] + (nums1[pos] ^ nums2[i]);
                if (newCost < dp[newMask]) {
                    dp[newMask] = newCost;
                }
            }
        }
    }
    
    int result = dp[(1 << n) - 1];
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

For each of 2ⁿ possible masks, we consider n positions and n choices

⚠ Quadratic Growth

Space Complexity

O(2ⁿ)

DP array to store results for each possible mask

✓ Linear Space

Constraints

n == nums1.length
n == nums2.length
1 ≤ n ≤ 14
0 ≤ nums1[i], nums2[i] ≤ 10⁷
Note: The constraint n ≤ 14 makes bitmask DP feasible since 2¹⁴ = 16,384 is manageable

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler