Maximum Strong Pair XOR II

Maximum Strong Pair XOR II - Problem

Array Hash Table Bit Manipulation Trie Sliding Window Hard

You are given a 0-indexed integer array nums. A pair of integers x and y is called a strong pair if it satisfies the condition:

|x - y| <= min(x, y)

You need to select two integers from nums such that they form a strong pair and their bitwise XOR is the maximum among all strong pairs in the array.

Return the maximum XOR value out of all possible strong pairs in the array nums.

Note: You can pick the same integer twice to form a pair.

Input & Output

Example 1 — Basic Strong Pairs

$ Input: nums = [1,6,2,3]

› Output: 5

💡 Note: Strong pairs: (1,1) with XOR=0, (2,2) with XOR=0, (3,3) with XOR=0, (2,3) with XOR=1, (1,2) with XOR=3, (1,3) with XOR=2, (6,6) with XOR=0. However, we need |x-y| <= min(x,y). Checking: |1-6|=5 > min(1,6)=1 (not strong), |2-3|=1 <= min(2,3)=2 (strong), etc. The maximum XOR is 5 from a valid strong pair.

Example 2 — Same Elements

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

› Output: 0

💡 Note: All elements are the same, so all pairs are (5,5) with |5-5|=0 <= min(5,5)=5, making them strong pairs. The XOR of any pair is 5^5=0.

Example 3 — No Valid Pairs

$ Input: nums = [1,10]

› Output: 0

💡 Note: Check pair (1,10): |1-10|=9 > min(1,10)=1, so not a strong pair. Check pairs with same element: (1,1) and (10,10) both give XOR=0. Maximum XOR is 0.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 2²⁰

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that two numbers form a strong pair when their absolute difference doesn't exceed the smaller number. The optimal approach uses a Trie data structure combined with sliding window to efficiently find the maximum XOR among all valid strong pairs. Time: O(n log n + 32n), Space: O(32n).

Common Approaches

✓ Brute Force - Check All Pairs

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

Generate all possible pairs from the array, check if each pair satisfies the strong pair condition, and track the maximum XOR value among valid pairs.

Sort + Two Pointers

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

Sort the array to group similar values together. Use two pointers to find all valid strong pairs more efficiently, since sorted order helps identify when pairs become invalid.

Trie + Sliding Window

⏱️ Time: O(n log n + n * 32) Space: O(32n)

Build a Trie for efficient XOR maximization. For each number, use sliding window approach to find all valid strong pair candidates, then query Trie to get maximum XOR.

Brute Force - Check All Pairs — Algorithm Steps

Iterate through all pairs (i,j) where i <= j
Check if |nums[i] - nums[j]| <= min(nums[i], nums[j])
If strong pair, calculate XOR and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pairs

Examine all possible pairs (i,j)

Validate Strong Pair

Check |x-y| <= min(x,y) condition

Track Max XOR

Keep maximum XOR among valid pairs

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize) {
    int maxXor = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int x = nums[i], y = nums[j];
            // Check if it's a strong pair
            if (abs_val(x - y) <= min_val(x, y)) {
                maxXor = max_val(maxXor, x ^ y);
            }
        }
    }
    
    return maxXor;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×n pairs in the array

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables to track maximum XOR

✓ Linear Space

28.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler