Maximum XOR of Two Numbers in an Array - Practice Coding Problems

Maximum XOR of Two Numbers in an Array - Problem

Given an integer array nums, return the maximum result of nums[i] XOR nums[j], where 0 <= i <= j < n.

The XOR operation compares bits and returns 1 when bits differ and 0 when they're the same.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,10,5,25,2,8]

› Output: 28

💡 Note: The maximum XOR is achieved by 5 XOR 25 = 28. In binary: 00101 XOR 11001 = 11100 = 28

Example 2 — Simple Pair

$ Input: nums = [14,70,53,83,49,91,36,80,92,51,66,70]

› Output: 127

💡 Note: The maximum XOR is 127. We need to find the pair that gives maximum difference in bits

Example 3 — Edge Case

$ Input: nums = [8,10,2]

› Output: 10

💡 Note: Maximum XOR is between 8 XOR 2 = 10. In binary: 1000 XOR 0010 = 1010 = 10

Constraints

1 ≤ nums.length ≤ 2 * 10⁴
0 ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array of integers [3,10,5,25,2,8]

XOR Operation

Find pair with maximum XOR value

Output

Return maximum XOR result: 28

Key Takeaway

🎯 Key Insight: XOR maximizes when bits differ most - build result bit by bit for efficiency

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 25

The key insight is to build the maximum XOR bit by bit from the most significant bit. The bit-by-bit construction approach achieves optimal Time: O(32n), Space: O(n) by using prefix matching.

Common Approaches

Approach	Time	Space	Notes
✓ Bit-by-Bit Construction	O(32n)	O(n)	Build maximum XOR bit by bit using prefix matching
Brute Force	O(n²)	O(1)	Try all pairs and find maximum XOR

Bit-by-Bit Construction — Algorithm Steps

Step 1: Start from most significant bit
Step 2: For each bit, try to make result bit = 1
Step 3: Use prefix set to check if achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Start MSB

Begin with most significant bit

Check Prefixes

See if we can achieve 1 at this position

Build Result

Construct maximum XOR bit by bit

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int maxXor = 0;
    int mask = 0;
    
    for (int i = 31; i >= 0; i--) {
        mask |= (1 << i);
        int prefixes[1000];
        int prefixCount = 0;
        
        // Build prefix array
        for (int j = 0; j < numsSize; j++) {
            int prefix = nums[j] & mask;
            int found = 0;
            for (int k = 0; k < prefixCount; k++) {
                if (prefixes[k] == prefix) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                prefixes[prefixCount++] = prefix;
            }
        }
        
        int temp = maxXor | (1 << i);
        for (int j = 0; j < prefixCount; j++) {
            int target = temp ^ prefixes[j];
            for (int k = 0; k < prefixCount; k++) {
                if (prefixes[k] == target) {
                    maxXor = temp;
                    goto next_bit;
                }
            }
        }
        next_bit:;
    }
    
    return maxXor;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(32n)

32 bits × n numbers to build prefix sets

✓ Linear Growth

Space Complexity

O(n)

Set stores up to n prefixes at each iteration

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~25 min Avg. Time

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

Bit-by-Bit Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler