Maximum Strong Pair XOR II - Practice Coding Problems

Maximum Strong Pair XOR II - Problem

Array Hash Table Bit Manipulation Trie Sliding Window Hard

Maximum Strong Pair XOR II is a challenging bit manipulation problem that combines mathematical constraints with advanced data structures.

You're given a 0-indexed integer array nums. Two integers x and y form a "strong pair" if they satisfy the condition: |x - y| <= min(x, y).

Your goal is to find two integers from nums that form a strong pair and have the maximum possible XOR value among all valid strong pairs. Note that you can select the same element twice to form a pair.

Example: If nums = [1, 2, 3, 4], the pair (3, 4) is strong because |3 - 4| = 1 <= min(3, 4) = 3, and their XOR is 3 ^ 4 = 7.

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: The strong pairs are (1,1), (1,2), (2,2), (2,3), (2,4), (3,3), (3,4), (4,4). Among these, (3,4) gives the maximum XOR: 3 ^ 4 = 7.

example_2.py — Single Element

$ Input: nums = [5]

› Output: 0

💡 Note: Only one element exists, so we can only pair it with itself: (5,5). The XOR of identical elements is always 0.

example_3.py — No Valid Pairs Except Self

$ Input: nums = [1, 10, 100]

› Output: 0

💡 Note: The only strong pairs are (1,1), (10,10), and (100,100) since other combinations don't satisfy |x-y| <= min(x,y). All self-pairs have XOR = 0.

Visualization

Tap to expand

Time: O(n² log C) - where C is max element value• Space: O(n log C) - for trie storage and sorting• Key Insight: Strong pair ⟺ y ≤ 2x (when x ≤ y)• Optimization: Trie for efficient XOR maximization

Understanding the Visualization

Understand Strong Pairs

Two numbers form a strong pair if their difference doesn't exceed the smaller number

Mathematical Insight

For x ≤ y, strong pair condition becomes y ≤ 2x, enabling sliding window

Trie Optimization

Use binary trie to efficiently find maximum XOR among valid candidates

Sliding Window

Process elements in sorted order, maintaining window of valid pairs

Key Takeaway

🎯 Key Insight: The constraint |x-y| ≤ min(x,y) for strong pairs, when combined with sorting, enables a sliding window approach where we only need to check elements in range [x, 2x]. Using a trie data structure allows us to efficiently find the maximum XOR among valid candidates.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all n*(n+1)/2 pairs in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 * 10⁴
1 ≤ nums[i] ≤ 2²⁰
Strong pair condition: |x - y| ≤ min(x, y)

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses sorting with sliding window and trie data structure. Key insight: for a strong pair (x,y) where x ≤ y, the condition |x-y| ≤ min(x,y) simplifies to y ≤ 2x. We sort the array, then for each element x, we use a sliding window to find all valid candidates y in range [x, 2x], build a trie with these candidates, and query for maximum XOR efficiently. Time complexity: O(n² log C) where C is the maximum value.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all pairs and find maximum XOR among strong pairs
Two Pointers with Sliding Window	O(n² log C)	O(n * log C)	Sort array and use sliding window to find valid pairs efficiently

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all pairs (i, j) where i <= j
For each pair, check if |nums[i] - nums[j]| <= min(nums[i], nums[j])
If it's a strong pair, calculate XOR and update maximum
Return the maximum XOR found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the first element and check all pairs

Check Pairs

For each pair, verify the strong pair condition

Calculate XOR

If valid, compute XOR and update maximum

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 maximumStrongPairXor(int* nums, int n) {
    int maxXor = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; 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[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", maximumStrongPairXor(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all n*(n+1)/2 pairs in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 * 10⁴
1 ≤ nums[i] ≤ 2²⁰
Strong pair condition: |x - y| ≤ min(x, y)

43.7K Views

Medium Frequency

~35 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler