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

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:

7

11

1st Query: Level 2 has numbers 2 and 3.

Therefore, 2^5 = 7 and 3^5 = 6.

Hence, the answer is 7.

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 <bits/stdc++.h>` `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] = { { 2, 5 }, { 3, 15 } };` ` ` `int` `q = ` `sizeof` `(queries) / ` `sizeof` `(queries[0]);` ` ` `// Perform queries` ` ` `for` `(` `int` `i = 0; i < q; i++)` ` ` `cout << solveQuery(queries[i][0],` ` ` `queries[i][1])` ` ` `<< 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

`<script>` `// Javascript implementation of the approach` `var` `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` `function` `solveQuery(L, X)` `{` ` ` ` ` `// Initialize result` ` ` `var` `res;` ` ` `// Initialize array to store bits` ` ` `var` `a = Array(MAXN), b = Array(L);` ` ` `// Initialize a copy of X` ` ` `// and size of array` ` ` `var` `ref = X, size_a = 0;` ` ` `// Storing the bits of X` ` ` `// in the array a[]` ` ` `while` `(ref > 0)` ` ` `{` ` ` `a[size_a] = ref % 2;` ` ` `ref = parseInt(ref / 2);` ` ` `size_a++;` ` ` `}` ` ` `// Filling the array b[]` ` ` `for` `(` `var` `i = 0; i < Math.min(size_a, L); i++)` ` ` `{` ` ` `if` `(a[i] == 1)` ` ` `b[i] = 0;` ` ` `else` ` ` `b[i] = 1;` ` ` `}` ` ` `for` `(` `var` `i = Math.min(size_a, L); i < L; i++)` ` ` `b[i] = 1;` ` ` `b[L - 1] = 1;` ` ` `// Initializing variable which gives` ` ` `// maximum xor` ` ` `var` `temp = 0, p = 1;` ` ` `for` `(` `var` `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` `var` `queries = [ [ 2, 5 ], [ 3, 15 ] ];` `var` `q = queries.length;` `// Perform queries` `for` `(` `var` `i = 0; i < q; i++)` ` ` `document.write(solveQuery(queries[i][0],` ` ` `queries[i][1]) + ` `"<br>"` `);` ` ` `// This code is contributed by rutvik_56` `</script>` |

**Output:**

7 11

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.