Queries to calculate maximum Bitwise XOR of X with any array element not exceeding M

import java.util.*;

public class Main {

    // Function to find the maximum value of 
    // Bitwise XOR of X with an array element
    // with a value at most M
    public static int findMaxXOR(List<Integer> arr, int X, int M) {
        int maxXOR = -1;
      
        // Traversing through the array
        for (int i = 0; i < arr.size(); i++) 
        {
          
            // Checking if the array element is less than or equal to M
            if (arr.get(i) <= M) 
            {
              
                // Calculating the maximum XOR value
                maxXOR = Math.max(maxXOR, X ^ arr.get(i));
            }
        }
        return maxXOR;
    }

    // Function to solve the problem for multiple queries
    public static void solveQueries(List<Integer> arr, List<Pair<Integer, Integer>> queries) {
        
      // Traversing through each query
        for (int i = 0; i < queries.size(); i++)
        {
          
            // Getting the values of X and M for the current query
            int X = queries.get(i).getKey();
            int M = queries.get(i).getValue();
            int maxXOR = findMaxXOR(arr, X, M);
            System.out.print(maxXOR + " ");
        }
    }

    // Driver Code
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(Arrays.asList(0, 1, 2, 3, 4));
        List<Pair<Integer, Integer>> queries = new ArrayList<>(Arrays.asList(new Pair<>(3, 1), new Pair<>(1, 3), new Pair<>(5, 6)));
        solveQueries(nums, queries);
    }
}
class Pair<T, U> {
    private T key;
    private U value;

    public Pair(T key, U value) {
        this.key = key;
        this.value = value;
    }

    public T getKey() {
        return key;
    }

    public U getValue() {
        return value;
    }
}

// Java program for the above approach
import java.io.*;
import java.util.*;

// Trie Node Class
class TrieNode {
    TrieNode nums[] = new TrieNode[2];
    int prefixValue;
}

class sol {

    // Function to find the maximum XOR
    // of X with any array element <= M
    // for each query of the type {X, M}
    public void maximizeXor(
        int[] nums, int[][] queries)
    {
        int queriesLength = queries.length;
        int[] ans = new int[queriesLength];
        int[][] temp = new int[queriesLength][3];

        // Stores the queries
        for (int i = 0; i < queriesLength; i++) {
            temp[i][0] = queries[i][0];
            temp[i][1] = queries[i][1];
            temp[i][2] = i;
        }

        // Sort the query
        Arrays.sort(temp,
                    (a, b) -> {
                        return a[1]
                            - b[1];
                    });
        int index = 0;

        // Sort the array
        Arrays.sort(nums);
        TrieNode root = new TrieNode();

        // Traverse the given query
        for (int query[] : temp) {

            // Traverse the array nums[]
            while (index < nums.length
                   && nums[index]
                          <= query[1]) {

                // Insert the node into the Trie
                insert(root, nums[index]);
                index++;
            }

            // Stores the resultant
            // maximum value
            int tempAns = -1;

            // Find the maximum value
            if (index != 0) {

                // Search the node in the Trie
                tempAns = search(root,
                                 query[0]);
            }

            // Update the result
            // for each query
            ans[query[2]] = tempAns;
        }

        // Print the answer
        for (int num : ans) {
            System.out.print(num + " ");
        }
    }

    // Function to insert the
    // root in the trieNode
    public void insert(TrieNode root,
                       int n)
    {
        TrieNode node = root;

        // Iterate from 31 to 0
        for (int i = 31; i >= 0; i--) {

            // Find the bit at i-th position
            int bit = (n >> i) & 1;
            if (node.nums[bit] == null) {
                node.nums[bit]
                    = new TrieNode();
            }
            node = node.nums[bit];
        }

        // Update the value
        node.prefixValue = n;
    }

    // Function to search the root
    // with the value and perform
    // the Bitwise XOR with N
    public int search(TrieNode root,
                      int n)
    {
        TrieNode node = root;

        // Iterate from 31 to 0
        for (int i = 31; i >= 0; i--) {

            // Find the bit at ith
            // position
            int bit = (n >> i) & 1;
            int requiredBit = bit
                                      == 1
                                  ? 0
                                  : 1;

            if (node.nums[requiredBit]
                != null) {
                node = node.nums[requiredBit];
            }
            else {
                node = node.nums[bit];
            }
        }

        // Return the prefixvalue XORed
        // with N
        return node.prefixValue ^ n;
    }
}

class GFG {

    // Driver Code
    public static void main(String[] args)
    {
        sol tt = new sol();
        int[] nums = { 0, 1, 2, 3, 4 };
        int[][] queries = { { 3, 1 },
                            { 1, 3 },
                            { 5, 6 } };

        tt.maximizeXor(nums, queries);
    }
}