Suppose we have an array called nums with non-negative values. We also have another array called queries where queries[i] has a pair (xi, mi). The answer of ith query is the maximum bitwise XOR value of xi and any element of nums that less than or equal to mi. If all elements in nums are larger than mi, then the answer is -1. So we have to find an array answer where size of answer is same as size of query and answer[i] is the answer to the ith query.
So, if the input is like nums = [0,1,2,3,4] queries = [[3,1],[1,3],[5,6]], then the output will be [3,3,7], because
0 and 1 are not greater than 1. 0 XOR 3 = 3 and 1 XOR 3 = 2, here larger of these two is 3.
1 XOR 2 = 3.
5 XOR 2 = 7.
To solve this, we will follow these steps −
m := size of nums
n := size of queries
queries = make a triplet (i, x, limit) for each index i, and pair (x, limit) in queries
sort queries based on limit
nums := sort the list nums
res := an array of size n and fill with 0
for k in range 31 to 0, decrease by 1, do
prefixes := a new set
j := 0
for each index i and value (x, limit) in queries, do
while j <= m - 1 and nums[j] <= limit, do
shift nums[j] to the right k bits and insert into prefixes
j := j + 1
if prefixes is empty, then
res[i] := -1
res[i] = quotient of res[i]/2
target := res[i] XOR 1
if (x after shifting k bits to right) XOR target is in prefixes, then
res[i] := target
Let us see the following implementation to get better understanding
def solve(nums, queries): m, n = len(nums), len(queries) queries = sorted(((i, x, limit) for i, (x, limit) in enumerate(queries)), key=lambda x: x) nums = sorted(nums) res =  * n for k in range(31, -1, -1): prefixes = set() j = 0 for i, x, limit in queries: while j <= m - 1 and nums[j] <= limit: prefixes.add(nums[j] >> k) j += 1 if not prefixes: res[i] = -1 else: res[i] <<= 1 target = res[i] ^ 1 if (x >> k) ^ target in prefixes: res[i] = target return res nums = [0,1,2,3,4] queries = [[3,1],[1,3],[5,6]] print(solve(nums, queries))
[3, 3, 7]