Maximum XOR With an Element From Array - Practice Coding Problems

Maximum XOR With an Element From Array - Problem

Maximum XOR With an Element From Array

Imagine you're a data analyst tasked with finding the strongest possible signal by combining query values with array elements through XOR operations, but with a crucial constraint: you can only use array elements that don't exceed a given threshold.

You are given an array nums consisting of non-negative integers, and a queries array where queries[i] = [xi, mi].

For each query i, your goal is to find the maximum bitwise XOR value of xi and any element from nums that is ≤ mi. In other words, find max(nums[j] XOR xi) for all valid j where nums[j] ≤ mi.

If no elements in nums satisfy the constraint nums[j] ≤ mi, return -1 for that query.

Example: If nums = [0,1,2,3,4] and you have query [3, 1], you can only use elements ≤ 1 (so 0 and 1), and max(3^0, 3^1) = max(3, 2) = 3.

Input & Output

example_1.py — Basic Case

$ Input: nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]

› Output: [3,3,7]

💡 Note: For query [3,1]: valid nums are {0,1}, max(3^0, 3^1) = max(3,2) = 3. For query [1,3]: valid nums are {0,1,2,3}, max XORs are {1,0,3,2}, so answer is 3. For query [5,6]: all nums are valid, max(5^0,5^1,5^2,5^3,5^4) = max(5,4,7,6,1) = 7.

example_2.py — No Valid Elements

$ Input: nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]

› Output: [15,-1,5]

💡 Note: For query [12,4]: valid nums are {2,4,3}, max XORs are {14,8,15}, answer is 15. For query [8,1]: no nums ≤ 1, so return -1. For query [6,3]: valid nums are {2,3}, max XORs are {4,5}, answer is 5.

example_3.py — Single Element

$ Input: nums = [0], queries = [[0,0],[1,0]]

› Output: [0,1]

💡 Note: For query [0,0]: only 0 is valid, 0^0 = 0. For query [1,0]: only 0 is valid, 1^0 = 1.

Visualization

Tap to expand

Understanding the Visualization

Sort & Prepare

Sort nums and queries to enable incremental processing

Build Trie

Insert valid numbers into Trie as we process queries in order

Maximize XOR

For each query, traverse Trie choosing opposite bits when possible

Collect Results

Maintain original query order in final results

Key Takeaway

🎯 Key Insight: The Trie data structure is perfect for XOR maximization because it allows us to greedily select opposite bits at each level, and offline processing with sorting enables efficient constraint handling.

Time & Space Complexity

Time Complexity

⏱️

O((N+Q)log(max_value))

Sorting takes O(NlogN + QlogQ), Trie operations take O(log(max_value)) per element/query

⚡ Linearithmic

Space Complexity

O(N*log(max_value))

Trie stores all numbers with up to log(max_value) bits each

✓ Linear Space

Constraints

1 ≤ nums.length, queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ nums[j], xi, mi ≤ 10⁹
All values are non-negative integers

Asked in

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

The optimal solution uses a Trie data structure combined with offline query processing. By sorting queries by their constraint values and processing them in order, we can incrementally build a Trie containing valid elements. The Trie enables O(log(max_value)) XOR maximization by greedily selecting opposite bits at each level, achieving overall O((N+Q)log(max_value)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Trie + Offline Query Processing (Optimal)	O((N+Q)log(max_value))	O(N*log(max_value))	Use Trie for XOR maximization and process queries offline after sorting by constraint values
Brute Force (Nested Loops)	O(Q*N)	O(1)	For each query, check every element in nums that satisfies the constraint and find maximum XOR

Trie + Offline Query Processing (Optimal) — Algorithm Steps

Sort nums array in ascending order
Create queries with indices and sort by mi values
Initialize empty Trie for binary representation
For each sorted query, add all nums[j] ≤ mi to Trie
Use Trie to find maximum XOR with xi in O(log(max_value)) time
Store result and restore original query order

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Data

Sort nums array and queries by mi constraint

Build Trie

Incrementally add valid elements to Trie as we process queries

Find Max XOR

Use Trie to find maximum XOR by choosing opposite bits greedily

Restore Order

Return results in original query order

Code -

solution.c — C

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

typedef struct TrieNode {
    struct TrieNode* children[2];
    int minVal;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->children[0] = node->children[1] = NULL;
    node->minVal = INT_MAX;
    return node;
}

typedef struct {
    TrieNode* root;
} Trie;

Trie* createTrie() {
    Trie* trie = (Trie*)malloc(sizeof(Trie));
    trie->root = createNode();
    return trie;
}

void insertTrie(Trie* trie, int num) {
    TrieNode* node = trie->root;
    if (num < node->minVal) node->minVal = num;
    
    for (int i = 30; i >= 0; i--) {
        int bit = (num >> i) & 1;
        if (!node->children[bit]) {
            node->children[bit] = createNode();
        }
        node = node->children[bit];
        if (num < node->minVal) node->minVal = num;
    }
}

int findMaxXor(Trie* trie, int num, int limit) {
    if (trie->root->minVal > limit) return -1;
    
    TrieNode* node = trie->root;
    int result = 0;
    
    for (int i = 30; i >= 0; i--) {
        int bit = (num >> i) & 1;
        int opposite = 1 - bit;
        
        if (node->children[opposite] && 
            node->children[opposite]->minVal <= limit) {
            result |= (1 << i);
            node = node->children[opposite];
        } else if (node->children[bit]) {
            node = node->children[bit];
        } else {
            return -1;
        }
    }
    
    return result;
}

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

typedef struct {
    int xi, mi, origIdx;
} IndexedQuery;

int cmpQuery(const void* a, const void* b) {
    return ((IndexedQuery*)a)->mi - ((IndexedQuery*)b)->mi;
}

int* maximizeXor(int* nums, int numsSize, int** queries, int queriesSize, 
                 int* queriesColSize, int* returnSize) {
    qsort(nums, numsSize, sizeof(int), cmpInt);
    
    IndexedQuery* indexedQueries = (IndexedQuery*)malloc(queriesSize * sizeof(IndexedQuery));
    for (int i = 0; i < queriesSize; i++) {
        indexedQueries[i] = (IndexedQuery){queries[i][0], queries[i][1], i};
    }
    qsort(indexedQueries, queriesSize, sizeof(IndexedQuery), cmpQuery);
    
    Trie* trie = createTrie();
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    int numsIdx = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        IndexedQuery query = indexedQueries[i];
        
        while (numsIdx < numsSize && nums[numsIdx] <= query.mi) {
            insertTrie(trie, nums[numsIdx]);
            numsIdx++;
        }
        
        result[query.origIdx] = findMaxXor(trie, query.xi, query.mi);
    }
    
    free(indexedQueries);
    return result;
}

int main() {
    // Parse input and call maximizeXor
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((N+Q)log(max_value))

Sorting takes O(NlogN + QlogQ), Trie operations take O(log(max_value)) per element/query

⚡ Linearithmic

Space Complexity

O(N*log(max_value))

Trie stores all numbers with up to log(max_value) bits each

✓ Linear Space

Constraints

1 ≤ nums.length, queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ nums[j], xi, mi ≤ 10⁹
All values are non-negative integers

47.5K Views

High Frequency

~25 min Avg. Time

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

Trie + Offline Query Processing (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler