# Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree

• Last Updated : 17 May, 2021

Given a perfect binary tree of N nodes, with nodes having values from 1 to N as depicted in the image below and Q queries where every query consists of two integers L and X. The task is to find the maximum possible value of X XOR Y where Y can be any node at level L Examples:

Input: Q[] = {{2, 5}, {3, 15}}
Output:

11
1st Query: Level 2 has numbers 2 and 3.
Therefore, 2^5 = 7 and 3^5 = 6.
2nd Query: Level 3 has numbers 4, 5, 6 and 7
and 4^15 = 11 is the maximum possible.

Input: Q[] = {{ 1, 15 }, { 5, 23 }}
Output:
14
15

Approach: The numbers in level L contains L bits, e.g, in level 2 the numbers are 2 and 3 which can be represented using 2 bits in binary. Similarly, in level 3 the numbers are 4, 5, 6 and 7 can be represented with 3 bits.
So we have to find an L bit number which gives maximum xor with X. Store the bits of X in an array a[]. Now, fill an array b[] of size L with elements opposite to that in a[], i.e., if a[i] is equal to 0 then put b[i] equal to 1 and vice-versa.
Note that the L-1 index of b[]must always be 1. If size of a[] is less than b[] then fill the remaining indexes of b[] with 1. The array b[] is filled opposite to that of array a[] so that the number made from the bits of array b[] gives maximum xor value. Lastly, calculate the number made from b[] and return its xor with X as the answer to the query.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define MAXN 60` `// Function to solve queries of the maximum xor value``// between the nodes in a given level L of a``// perfect binary tree and a given value X``int` `solveQuery(``int` `L, ``int` `X)``{``    ``// Initialize result``    ``int` `res;` `    ``// Initialize array to store bits``    ``int` `a[MAXN], b[L];` `    ``// Initialize a copy of X``    ``// and size of array``    ``int` `ref = X, size_a = 0;` `    ``// Storing the bits of X``    ``// in the array a[]``    ``while` `(ref > 0) {``        ``a[size_a] = ref % 2;``        ``ref /= 2;``        ``size_a++;``    ``}` `    ``// Filling the array b[]``    ``for` `(``int` `i = 0; i < min(size_a, L); i++) {``        ``if` `(a[i] == 1)``            ``b[i] = 0;``        ``else``            ``b[i] = 1;``    ``}` `    ``for` `(``int` `i = min(size_a, L); i < L; i++)``        ``b[i] = 1;` `    ``b[L - 1] = 1;` `    ``// Initializing variable which gives``    ``// maximum xor``    ``int` `temp = 0, p = 1;` `    ``for` `(``int` `i = 0; i < L; i++) {``        ``temp += b[i] * p;``        ``p *= 2;``    ``}` `    ``// Getting the maximum xor value``    ``res = temp ^ X;` `    ``// Return the result``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``int` `queries[] = { { 2, 5 }, { 3, 15 } };``    ``int` `q = ``sizeof``(queries) / ``sizeof``(queries);` `    ``// Perform queries``    ``for` `(``int` `i = 0; i < q; i++)``        ``cout << solveQuery(queries[i],``                           ``queries[i])``             ``<< endl;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `class` `GFG``{``    ` `    ``static` `int` `MAXN = ``60``;``    ` `    ``// Function to solve queries of the maximum xor value``    ``// between the nodes in a given level L of a``    ``// perfect binary tree and a given value X``    ``static` `int` `solveQuery(``int` `L, ``int` `X)``    ``{``        ``// Initialize result``        ``int` `res;``    ` `        ``// Initialize array to store bits``        ``int` `[]a = ``new` `int` `[MAXN];``        ``int` `[]b = ``new` `int``[L];``    ` `        ``// Initialize a copy of X``        ``// and size of array``        ``int` `refer = X, size_a = ``0``;``    ` `        ``// Storing the bits of X``        ``// in the array a[]``        ``while` `(refer > ``0``)``        ``{``            ``a[size_a] = refer % ``2``;``            ``refer /= ``2``;``            ``size_a++;``        ``}``    ` `        ``// Filling the array b[]``        ``for` `(``int` `i = ``0``; i < Math.min(size_a, L); i++)``        ``{``            ``if` `(a[i] == ``1``)``                ``b[i] = ``0``;``            ``else``                ``b[i] = ``1``;``        ``}``    ` `        ``for` `(``int` `i = Math.min(size_a, L); i < L; i++)``            ``b[i] = ``1``;``    ` `        ``b[L - ``1``] = ``1``;``    ` `        ``// Initializing variable which gives``        ``// maximum xor``        ``int` `temp = ``0``, p = ``1``;``    ` `        ``for` `(``int` `i = ``0``; i < L; i++)``        ``{``            ``temp += b[i] * p;``            ``p *= ``2``;``        ``}``    ` `        ``// Getting the maximum xor value``        ``res = temp ^ X;``    ` `        ``// Return the result``        ``return` `res;``    ``}``    ` `    ``// Driver code``    ``static` `public` `void` `main (String args[])``    ``{``        ``int` `[][]queries= { { ``2``, ``5` `}, { ``3``, ``15` `} };``        ``int` `q = queries.length;``    ` `        ``// Perform queries``        ``for` `(``int` `i = ``0``; i < q; i++)``            ``System.out.println( solveQuery(queries[i][``0``],``                            ``queries[i][``1``]) );``        ` `    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation of the approach` `MAXN ``=` `60` `# Function to solve queries of the maximum xor value``# between the nodes in a given level L of a``# perfect binary tree and a given value X``def` `solveQuery(L, X):``    ` `    ``# Initialize result``    ``res ``=` `0` `    ``# Initialize array to store bits``    ``a ``=` `[``0` `for` `i ``in` `range``(MAXN)]``    ``b ``=` `[``0` `for` `i ``in` `range``(MAXN)]` `    ``# Initialize a copy of X``    ``# and size of array``    ``ref ``=` `X``    ``size_a ``=` `0` `    ``# Storing the bits of X``    ``# in the array a[]``    ``while` `(ref > ``0``):``        ``a[size_a] ``=` `ref ``%` `2``        ``ref ``/``/``=` `2``        ``size_a``+``=``1` `    ``# Filling the array b[]``    ``for` `i ``in` `range``(``min``(size_a,L)):``        ``if` `(a[i] ``=``=` `1``):``            ``b[i] ``=` `0``        ``else``:``            ``b[i] ``=` `1`  `    ``for` `i ``in` `range``(``min``(size_a, L),L):``        ``b[i] ``=` `1` `    ``b[L ``-` `1``] ``=` `1` `    ``# Initializing variable which gives``    ``# maximum xor``    ``temp ``=` `0``    ``p ``=` `1` `    ``for` `i ``in` `range``(L):``        ``temp ``+``=` `b[i] ``*` `p``        ``p ``*``=` `2` `    ``# Getting the maximum xor value``    ``res ``=` `temp ^ X` `    ``# Return the result``    ``return` `res` `# Driver code``queries``=` `[ [ ``2``, ``5` `], [ ``3``, ``15` `] ]` `q ``=` `len``(queries)` `# Perform queries``for` `i ``in` `range``(q):``    ``print``(solveQuery(queries[i][``0``],queries[i][``1``]))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `    ``static` `int` `MAXN = 60;``    ` `    ``// Function to solve queries of the maximum xor value``    ``// between the nodes in a given level L of a``    ``// perfect binary tree and a given value X``    ``static` `int` `solveQuery(``int` `L, ``int` `X)``    ``{``        ``// Initialize result``        ``int` `res;``    ` `        ``// Initialize array to store bits``        ``int` `[]a = ``new` `int` `[MAXN];``        ``int` `[]b = ``new` `int``[L];``    ` `        ``// Initialize a copy of X``        ``// and size of array``        ``int` `refer = X, size_a = 0;``    ` `        ``// Storing the bits of X``        ``// in the array a[]``        ``while` `(refer > 0)``        ``{``            ``a[size_a] = refer % 2;``            ``refer /= 2;``            ``size_a++;``        ``}``    ` `        ``// Filling the array b[]``        ``for` `(``int` `i = 0; i < Math.Min(size_a, L); i++)``        ``{``            ``if` `(a[i] == 1)``                ``b[i] = 0;``            ``else``                ``b[i] = 1;``        ``}``    ` `        ``for` `(``int` `i = Math.Min(size_a, L); i < L; i++)``            ``b[i] = 1;``    ` `        ``b[L - 1] = 1;``    ` `        ``// Initializing variable which gives``        ``// maximum xor``        ``int` `temp = 0, p = 1;``    ` `        ``for` `(``int` `i = 0; i < L; i++)``        ``{``            ``temp += b[i] * p;``            ``p *= 2;``        ``}``    ` `        ``// Getting the maximum xor value``        ``res = temp ^ X;``    ` `        ``// Return the result``        ``return` `res;``    ``}``    ` `    ``// Driver code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `[,]queries= { { 2, 5 }, { 3, 15 } };``        ``int` `q = queries.Length;``    ` `        ``// Perform queries``        ``for` `(``int` `i = 0; i < q; i++)``            ``Console.WriteLine( solveQuery(queries[i,0],``                            ``queries[i,1]) );``        ` `    ``}``}` `// This code is contributed by anuj_67..`

## Javascript

 ``

Output:

```7
11```

My Personal Notes arrow_drop_up