Program to find list of elements which are less than limit and XOR is maximum in Python

Suppose we have a list of numbers nums and a list of queries where each query contains [x, limit]. We have to find a list such that for each query [x, limit], we find an element e in nums such that e ≤ limit and e XOR x is maximized. If there is no such element, return -1.

So, if the input is like nums = [3, 5, 9] queries = [[4, 6],[2, 0]], then the output will be [3, -1], as for the first query, we can use 2 or 4 in nums. 3 ^ 4 = 7 while 5 ^ 4 = 3 so we select 3 which yields the bigger XOR. In the second query, there is no such number that's less than or equal to 0, so we set it to -1.

To solve this, we will follow these steps −

• trie := a new map

• Define a function bits() . This will take i

• return 32 bit binary representation of i

• Define a function insert. This will take i

• node := trie

• for each c in bits(i), do

  • node := if c is not in node, insert an empty map inside it

• node[2] := i

• Define a function query() . This will take i

• node := trie

• for each c in bits(i), do

  • rc := c XOR 1

  • node := node[rc] if exists otherwise node[c]

• return node[2]

• From the main method do the following −

• sort the list A

• B := a list of elements in the form (i, x, limit) for each query index i and query values x and limit. Then sort it based on limit

• (j, n, ans) := (0, size of A , a list of size same as queries, fill with -1)

• for each index i and value x and limit in B, do

  • while j < n and A[j] <= limit, do

    • insert(A[j])

    • j := j + 1

  • if j is non-zero, then

    • ans[i] := query(x)

• return ans

Example (Python)

Let us see the following implementation to get a better understanding −

 Live Demo

class Solution:
   def solve(self, A, queries):
      trie = {}
      def bits(i):
         return map(int, bin(i)[2:].zfill(32))
      def insert(i):
         node = trie
         for c in bits(i):
            node = node.setdefault(c, {})
         node[2] = i
      def query(i):
         node = trie
         for c in bits(i):
            rc = c ^ 1
            node = node.get(rc, node.get(c))
         return node[2]
      A.sort()
      B = sorted([(i, x, limit) for i, (x, limit) in enumerate(queries)], key=lambda x: x[2])
j, n, ans = 0, len(A), [-1] * len(queries)
      for i, x, limit in B:
         while j < n and A[j] <= limit:
            insert(A[j])
            j += 1
         if j:
            ans[i] = query(x)
      return ans
ob = Solution()
nums = [3, 5, 9]
queries = [
   [4, 6],
   [2, 0]
]
print(ob.solve(nums, queries))

Input

[3, 5, 9], [[4, 6],[2, 0]]

Output

[3, -1]