Minimize XOR - Practice Coding Problems

Minimize XOR - Problem

Minimize XOR is a fascinating bit manipulation problem that challenges you to construct an optimal number based on XOR properties.

You're given two positive integers num1 and num2. Your task is to find a positive integer x that satisfies two critical conditions:

1. Same Set Bit Count: x must have exactly the same number of 1-bits as num2
2. Minimal XOR: The value x XOR num1 must be as small as possible

The key insight is that to minimize XOR, we want x to be as similar to num1 as possible. Since XOR returns 0 when bits are identical and 1 when they differ, we should strategically place our set bits to maximize overlap with num1's set bits.

Example: If num1 = 3 (binary: 11) and num2 = 5 (binary: 101, has 2 set bits), we need to find x with exactly 2 set bits that minimizes x XOR 3. The answer is x = 3 because 3 XOR 3 = 0, which is minimal.

Input & Output

example_1.py — Basic Case

$ Input: num1 = 3, num2 = 5

› Output: 3

💡 Note: num1 = 3 (011), num2 = 5 (101) has 2 set bits. We need x with 2 set bits that minimizes x ⊕ 3. Since 3 already has 2 set bits, x = 3 gives us 3 ⊕ 3 = 0, which is the minimum possible.

example_2.py — Need More Bits

$ Input: num1 = 1, num2 = 12

› Output: 3

💡 Note: num1 = 1 (001), num2 = 12 (1100) has 2 set bits. We start with 1, but need 2 bits total. Adding bit 1 gives us 3 (011). Result: 3 ⊕ 1 = 2.

example_3.py — Need Fewer Bits

$ Input: num1 = 25, num2 = 72

› Output: 24

💡 Note: num1 = 25 (11001) has 3 set bits, num2 = 72 (1001000) has 2 set bits. We start with 25 and remove the lowest set bit (bit 0), giving us 24 (11000). Result: 24 ⊕ 25 = 1.

Constraints

1 ≤ num1, num2 ≤ 10⁹
Both num1 and num2 are positive integers
The answer x is uniquely determined for each test case

Visualization

Tap to expand

Understanding the Visualization

Start Smart

Begin with num1 to get maximum overlap

Count the Gap

Determine if we need more or fewer set bits

Adjust Minimally

Change only the lowest bits to minimize impact

Key Takeaway

🎯 Key Insight: Starting with num1 gives us the best possible foundation, and adjusting only the lowest necessary bits ensures we minimize the XOR difference while meeting the set bit count requirement.

Asked in

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

The optimal solution uses a greedy bit manipulation approach in O(log n) time. Start with num1 as the base to maximize bit overlap, then adjust by adding bits to lowest positions (if we need more) or removing bits from lowest positions (if we have too many). This minimizes the XOR difference while maintaining the exact set bit count from num2.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(1)	Generate all numbers with required set bits and find minimum XOR
One-Pass Greedy (Optimal)	O(log n)	O(1)	Construct optimal result in single pass using greedy bit manipulation
Two-Pass Greedy Bit Construction	O(log n)	O(1)	First copy matching bits from num1, then fill remaining positions optimally

Brute Force (Try All Combinations) — Algorithm Steps

Count the number of set bits in num2
Generate all possible numbers with that many set bits
For each candidate, calculate XOR with num1
Return the candidate that produces minimum XOR

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Target Bits

Count set bits in num2

Generate Candidates

Try all numbers with same bit count

Calculate XOR

Compute XOR with num1 for each

Track Minimum

Keep the candidate with smallest XOR

Code -

solution.c — C

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

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

int minimizeXor(int num1, int num2) {
    int targetBits = countSetBits(num2);
    
    int minXor = INT_MAX;
    int result = 0;
    
    int maxVal = (num1 > num2 ? num1 : num2) * 2;
    
    for (int x = 1; x <= maxVal; x++) {
        if (countSetBits(x) == targetBits) {
            int xorVal = x ^ num1;
            if (xorVal < minXor) {
                minXor = xorVal;
                result = x;
            }
        }
    }
    
    return result;
}

int main() {
    int num1, num2;
    scanf("%d,%d", &num1, &num2);
    printf("%d\n", minimizeXor(num1, num2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Where n is the number of bits. We potentially check all combinations of set bits

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the current minimum and candidate values

✓ Linear Space

24.7K Views

Medium Frequency

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