Maximum Strong Pair XOR I

Maximum Strong Pair XOR I - Problem

Array Hash Table Bit Manipulation Trie Sliding Window Easy

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 Case

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

› Output: 6

💡 Note: Check all pairs: (1,1), (1,2), (2,2), (2,3), (3,3), (3,5) are strong pairs. Among these, (3,5) gives maximum XOR: 3^5 = 6

Example 2 — Same Elements

$ Input: nums = [5,6,25,30]

› Output: 7

💡 Note: Strong pairs: (5,5), (6,6), (5,6), (25,25), (30,30), (25,30). Maximum XOR is from (25,30): 25^30 = 7

Example 3 — Single Element

$ Input: nums = [10]

› Output: 0

💡 Note: Only one element, so only pair is (10,10). XOR of same numbers is 0: 10^10 = 0

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that strong pairs satisfy |x - y| ≤ min(x, y), which limits valid pairs significantly. The brute force approach checks all pairs in O(n²) time. The sorted approach uses the property that for sorted elements x ≤ y, the condition becomes y ≤ 2x, allowing early termination. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force

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

Iterate through all pairs of numbers in the array. For each pair, check if they form a strong pair using the condition |x - y| <= min(x, y). If they do, calculate their XOR and keep track of the maximum.

Sorted Approach

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

Since strong pairs must satisfy |x - y| <= min(x, y), if we sort the array, we can break early when checking pairs. For sorted elements, if x <= y, then |x - y| = y - x, and the condition becomes y - x <= x, or y <= 2x.

Brute Force — Algorithm Steps

Iterate through all pairs (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

Iterate through all pairs (i,j)

Validate

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

Calculate XOR

Find 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 n) {
    int maxXor = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; 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;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×n pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track maximum

✓ Linear Space

26.3K Views

Medium Frequency

~15 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler