Maximum Strong Pair XOR I - Practice Coding Problems

Maximum Strong Pair XOR I - Problem

Array Hash Table Bit Manipulation Trie Sliding Window Easy

You're given an array of integers and need to find the maximum XOR value among all "strong pairs".

A strong pair is defined as two numbers x and y where the absolute difference between them is at most the smaller of the two: |x - y| ≤ min(x, y).

Your task is to:

Find all valid strong pairs in the array
Calculate the XOR (bitwise exclusive OR) for each strong pair
Return the maximum XOR value found

Note: You can use the same number twice to form a pair (a number paired with itself has XOR = 0).

Example: In array [1, 2, 3, 4], the pair (2, 3) is strong because |2-3| = 1 ≤ min(2,3) = 2, and their XOR is 2 ⊕ 3 = 1.

Input & Output

example_1.py — Basic Array

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

› Output: 7

💡 Note: Strong pairs: (1,1)→XOR=0, (1,2)→XOR=3, (2,2)→XOR=0, (2,3)→XOR=1, (2,4)→XOR=6, (3,3)→XOR=0, (3,4)→XOR=7, (4,4)→XOR=0. Maximum is 7 from pair (3,4).

example_2.py — Single Element

$ Input: [5]

› Output: 0

💡 Note: Only one element, so the only pair is (5,5) which gives XOR = 5⊕5 = 0.

example_3.py — No Strong Pairs

$ Input: [1, 100]

› Output: 0

💡 Note: Check (1,100): |1-100|=99 > min(1,100)=1, so not a strong pair. Only strong pairs are (1,1) and (100,100), both giving XOR=0.

Visualization

Tap to expand

Understanding the Visualization

Define Strong Pairs

Two numbers x,y form a strong pair if |x-y| ≤ min(x,y)

Check All Pairs

Examine each pair to see if it satisfies the strong condition

Calculate XOR

For valid strong pairs, compute x ⊕ y (bitwise XOR)

Track Maximum

Keep track of the highest XOR value found

Key Takeaway

🎯 Key Insight: After checking all valid strong pairs, the maximum XOR value is 7 from the pair (3,4). The constraint |x-y| ≤ min(x,y) ensures that numbers aren't too far apart to form meaningful pairs.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n²)

O(n log n) for sorting plus O(n²) in worst case for checking pairs in valid ranges

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables (excluding space for sorting)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 100
Note: You can use the same element twice to form a pair

Asked in

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

The problem requires finding the maximum XOR value among all strong pairs. A brute force approach checks all pairs in O(n²) time, while a sorted two-pointer approach can optimize by limiting the search range for each element. The key insight is that for any number x, strong pairs can only be formed with numbers in range [x/2, 2x].

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Array)	O(n log n + n²)	O(1)	Sort array first, then use two pointers to efficiently find strong pairs
Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible pair to see if it's strong, then find maximum XOR

Two Pointers (Sorted Array) — Algorithm Steps

Sort the array in ascending order
For each number x at position i, find the valid range [x/2, 2x]
Use two pointers to find all numbers in this range
Calculate XOR for all valid pairs and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

Sort array to enable range-based searching

Range

For each x, find valid range [x/2, 2x]

Use pointers to explore only the valid range

Optimize

Skip impossible pairs early

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int maximumStrongPairXor(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    int maxXor = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int x = nums[i];
        int left = i;
        int right = i;
        
        // Find upper bound (2*x)
        while (right < numsSize && nums[right] <= 2 * x) {
            right++;
        }
        
        // Check all pairs in valid range
        for (int j = left; j < right; j++) {
            int y = nums[j];
            int diff = (x > y) ? x - y : y - x;
            int minVal = (x < y) ? x : y;
            if (diff <= minVal) {
                int xor = x ^ y;
                if (xor > maxXor) {
                    maxXor = xor;
                }
            }
        }
    }
    
    return maxXor;
}

int main() {
    int nums[1000];
    int count = 0;
    char c;
    int num = 0;
    int inNumber = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = 1;
        } else if (inNumber) {
            nums[count++] = num;
            num = 0;
            inNumber = 0;
        }
    }
    if (inNumber) nums[count++] = num;
    
    printf("%d\n", maximumStrongPairXor(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n²)

O(n log n) for sorting plus O(n²) in worst case for checking pairs in valid ranges

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables (excluding space for sorting)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 100
Note: You can use the same element twice to form a pair

26.7K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Sorted Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler