# Number whose sum of XOR with given array range is maximum

You are given a sequence of N integers and Q queries. In each query, you are given two parameters L and R. You have to find the smallest integer X such that 0 <= X < 2^31 and the sum of XOR of x with all elements is range [L, R] is maximum possible.

Examples :

```Input  : A = {20, 11, 18, 2, 13}
Three queries as (L, R) pairs
1 3
3 5
2 4
Output : 2147483629
2147483645
2147483645
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The binary representation of each element and X, we can observe that each bit is independent and the problem can be solved by iterating over each bit. Now basically for each bit we need to count the number of 1’s and 0’s in the given range, if the number of 1’s are more then you have to set that bit of X to 0 so that the sum is maximum after xor with X else if number of 0’s are more then you have to set that bit of X to 1. If the number of 1’s and 0’s are equal then we can set that bit of X to any one of 1 or 0 because it will not affect the sum, but we have to minimize the value of X so we will take that bit 0.

Now, to optimize the solution we can pre-calculate the count of 1’s at each bit position of the numbers up to that position by making a prefix array this will take O(n) time. Now for each query number of 1’s will be the number of 1’s up to Rth position – number of 1’s up to (L-1)th position.

## C++

 `// CPP program to find smallest integer X ` `// such that sum of its XOR with range is ` `// maximum. ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 2147483647 ` `int` `one; ` ` `  `// Function to make prefix array which  ` `// counts 1's of each bit up to that number ` `void` `make_prefix(``int` `A[], ``int` `n) ` `{ ` `    ``for` `(``int` `j = 0; j < 32; j++) ` `        ``one[j] = 0; ` ` `  `    ``// Making a prefix array which sums ` `    ``// number of 1's up to that position ` `    ``for` `(``int` `i = 1; i <= n; i++)  ` `    ``{ ` `        ``int` `a = A[i - 1]; ` `        ``for` `(``int` `j = 0; j < 32; j++)  ` `        ``{ ` `            ``int` `x = ``pow``(2, j); ` ` `  `            ``// If j-th bit of a number is set then ` `            ``// add one to previously counted 1's ` `            ``if` `(a & x) ` `                ``one[i][j] = 1 + one[i - 1][j]; ` `            ``else` `                ``one[i][j] = one[i - 1][j]; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to find X ` `int` `Solve(``int` `L, ``int` `R) ` `{ ` `    ``int` `l = L, r = R; ` `    ``int` `tot_bits = r - l + 1; ` ` `  `    ``// Initially taking maximum value all bits 1 ` `    ``int` `X = MAX; ` ` `  `    ``// Iterating over each bit ` `    ``for` `(``int` `i = 0; i < 31; i++)  ` `    ``{ ` ` `  `        ``// get 1's at ith bit between the  ` `        ``// range L-R by subtracting 1's till ` `        ``// Rth number - 1's till L-1th number ` `        ``int` `x = one[r][i] - one[l - 1][i]; ` ` `  `        ``// If 1's are more than or equal to 0's ` `        ``// then unset the ith bit from answer ` `        ``if` `(x >= tot_bits - x)  ` `        ``{ ` `            ``int` `ith_bit = ``pow``(2, i); ` ` `  `            ``// Set ith bit to 0 by doing ` `            ``// Xor with 1 ` `            ``X = X ^ ith_bit; ` `        ``} ` `    ``} ` `    ``return` `X; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``// Taking inputs ` `    ``int` `n = 5, q = 3; ` `    ``int` `A[] = { 210, 11, 48, 22, 133 }; ` `    ``int` `L[] = { 1, 4, 2 }, R[] = { 3, 14, 4 }; ` ` `  `    ``make_prefix(A, n); ` ` `  `    ``for` `(``int` `j = 0; j < q; j++) ` `        ``cout << Solve(L[j], R[j]) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find smallest integer X ` `// such that sum of its XOR with range is ` `// maximum. ` `import` `java.lang.Math; ` ` `  `class` `GFG { ` `     `  `    ``private` `static` `final` `int` `MAX = ``2147483647``; ` `    ``static` `int``[][] one = ``new` `int``[``100001``][``32``]; ` `     `  `    ``// Function to make prefix array which counts ` `    ``// 1's of each bit up to that number ` `    ``static` `void` `make_prefix(``int` `A[], ``int` `n) ` `    ``{ ` `        ``for` `(``int` `j = ``0``; j < ``32``; j++) ` `            ``one[``0``][j] = ``0``; ` ` `  `        ``// Making a prefix array which sums ` `        ``// number of 1's up to that position ` `        ``for` `(``int` `i = ``1``; i <= n; i++)  ` `        ``{ ` `            ``int` `a = A[i - ``1``]; ` `            ``for` `(``int` `j = ``0``; j < ``32``; j++)  ` `            ``{ ` `                ``int` `x = (``int``)Math.pow(``2``, j); ` ` `  `                ``// If j-th bit of a number is set then ` `                ``// add one to previously counted 1's ` `                ``if` `((a & x) != ``0``) ` `                    ``one[i][j] = ``1` `+ one[i - ``1``][j]; ` `                ``else` `                    ``one[i][j] = one[i - ``1``][j]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function to find X ` `    ``static` `int` `Solve(``int` `L, ``int` `R) ` `    ``{ ` `        ``int` `l = L, r = R; ` `        ``int` `tot_bits = r - l + ``1``; ` ` `  `        ``// Initially taking maximum  ` `        ``// value all bits 1 ` `        ``int` `X = MAX; ` ` `  `        ``// Iterating over each bit ` `        ``for` `(``int` `i = ``0``; i < ``31``; i++)  ` `        ``{ ` ` `  `            ``// get 1's at ith bit between the range ` `            ``// L-R by subtracting 1's till ` `            ``// Rth number - 1's till L-1th number ` `            ``int` `x = one[r][i] - one[l - ``1``][i]; ` ` `  `            ``// If 1's are more than or equal to 0's ` `            ``// then unset the ith bit from answer ` `            ``if` `(x >= tot_bits - x)  ` `            ``{ ` `                ``int` `ith_bit = (``int``)Math.pow(``2``, i); ` ` `  `                ``// Set ith bit to 0 by  ` `                ``// doing Xor with 1 ` `                ``X = X ^ ith_bit; ` `            ``} ` `        ``} ` `        ``return` `X; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Taking inputs ` `        ``int` `n = ``5``, q = ``3``; ` `        ``int` `A[] = { ``210``, ``11``, ``48``, ``22``, ``133` `}; ` `        ``int` `L[] = { ``1``, ``4``, ``2` `}, R[] = { ``3``, ``14``, ``4` `}; ` ` `  `        ``make_prefix(A, n); ` ` `  `        ``for` `(``int` `j = ``0``; j < q; j++) ` `            ``System.out.println(Solve(L[j], R[j])); ` `    ``} ` `} ` ` `  `// This code is contributed by Smitha `

## Python3

 `# Python3 program to find smallest integer X ` `# such that sum of its XOR with range is ` `# maximum. ` `import` `math ` ` `  `one ``=` `[[``0` `for` `x ``in` `range``(``32``)]  ` `      ``for` `y ``in` `range``(``100001``)]  ` `MAX` `=` `2147483647` ` `  `# Function to make prefix array  ` `# which counts 1's of each bit  ` `# up to that number ` `def` `make_prefix(A, n) : ` `    ``global` `one, ``MAX` `     `  `    ``for` `j ``in` `range``(``0` `, ``32``) : ` `        ``one[``0``][j] ``=` `0` ` `  `    ``# Making a prefix array which  ` `    ``# sums number of 1's up to  ` `    ``# that position ` `    ``for` `i ``in` `range``(``1``, n``+``1``) :  ` `        ``a ``=` `A[i ``-` `1``] ` `        ``for` `j ``in` `range``(``0` `, ``32``) : ` `         `  `            ``x ``=` `int``(math.``pow``(``2``, j)) ` ` `  `            ``# If j-th bit of a number  ` `            ``# is set then add one to ` `            ``# previously counted 1's ` `            ``if` `(a & x) : ` `                ``one[i][j] ``=` `1` `+` `one[i ``-` `1``][j] ` `            ``else` `: ` `                ``one[i][j] ``=` `one[i ``-` `1``][j] ` `         `  `# Function to find X ` `def` `Solve(L, R) : ` ` `  `    ``global` `one, ``MAX` `    ``l ``=` `L  ` `    ``r ``=` `R ` `    ``tot_bits ``=` `r ``-` `l ``+` `1` ` `  `    ``# Initially taking maximum ` `    ``# value all bits 1 ` `    ``X ``=` `MAX` ` `  `    ``# Iterating over each bit ` `    ``for` `i ``in` `range``(``0``, ``31``) : ` `     `  `        ``# get 1's at ith bit between the  ` `        ``# range L-R by subtracting 1's till ` `        ``# Rth number - 1's till L-1th number ` `         `  `        ``x ``=` `one[r][i] ``-` `one[l ``-` `1``][i] ` ` `  `        ``# If 1's are more than or equal  ` `        ``# to 0's then unset the ith bit ` `        ``# from answer ` `        ``if` `(x >``=` `(tot_bits ``-` `x)) : ` `             `  `            ``ith_bit ``=` `pow``(``2``, i) ` ` `  `            ``# Set ith bit to 0 by ` `            ``# doing Xor with 1 ` `            ``X ``=` `X ^ ith_bit ` `    ``return` `X ` ` `  `# Driver Code ` `n ``=` `5` `q ``=` `3` `A ``=` `[ ``210``, ``11``, ``48``, ``22``, ``133` `] ` `L ``=` `[ ``1``, ``4``, ``2` `]  ` `R ``=` `[ ``3``, ``14``, ``4` `] ` ` `  `make_prefix(A, n) ` ` `  `for` `j ``in` `range``(``0``, q) : ` `    ``print` `(Solve(L[j], R[j]),end``=``"\n"``) ` `     `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

## C#

 `// C# program to find smallest integer X ` `// such that sum of its XOR with range is ` `// maximum. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` `    ``static` `int` `MAX = 2147483647; ` `    ``static` `int` `[,]one = ``new` `int``[100001,32]; ` `     `  `    ``// Function to make prefix  ` `    ``// array which counts 1's  ` `    ``// of each bit up to that number ` `    ``static` `void` `make_prefix(``int` `[]A, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `j = 0; j < 32; j++) ` `            ``one[0,j] = 0; ` `     `  `        ``// Making a prefix array which sums ` `        ``// number of 1's up to that position ` `        ``for` `(``int` `i = 1; i <= n; i++)  ` `        ``{ ` `            ``int` `a = A[i - 1]; ` `            ``for` `(``int` `j = 0; j < 32; j++)  ` `            ``{ ` `                ``int` `x = (``int``)Math.Pow(2, j); ` `     `  `                ``// If j-th bit of a number is set then ` `                ``// add one to previously counted 1's ` `                ``if` `((a & x) != 0) ` `                    ``one[i, j] = 1 + one[i - 1, j]; ` `                ``else` `                    ``one[i,j] = one[i - 1, j]; ` `            ``} ` `        ``} ` `    ``} ` `     `  `    ``// Function to find X ` `    ``static` `int` `Solve(``int` `L, ``int` `R) ` `    ``{ ` `        ``int` `l = L, r = R; ` `        ``int` `tot_bits = r - l + 1; ` `     `  `        ``// Initially taking maximum ` `        ``// value all bits 1 ` `        ``int` `X = MAX; ` `     `  `        ``// Iterating over each bit ` `        ``for` `(``int` `i = 0; i < 31; i++)  ` `        ``{ ` `     `  `            ``// get 1's at ith bit between the  ` `            ``// range L-R by subtracting 1's till ` `            ``// Rth number - 1's till L-1th number ` `            ``int` `x = one[r, i] - one[l - 1, i]; ` `     `  `            ``// If 1's are more than or  ` `            ``// equal to 0's then unset ` `            ``// the ith bit from answer ` `            ``if` `(x >= tot_bits - x)  ` `            ``{ ` `                ``int` `ith_bit = (``int``)Math.Pow(2, i); ` `     `  `                ``// Set ith bit to 0 by doing ` `                ``// Xor with 1 ` `                ``X = X ^ ith_bit; ` `            ``} ` `        ``} ` `        ``return` `X; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `         `  `        ``// Taking inputs ` `        ``int` `n = 5, q = 3; ` `        ``int` `[]A = {210, 11, 48, 22, 133}; ` `        ``int` `[]L = {1, 4, 2}; ` `        ``int` `[]R = {3, 14, 4}; ` `     `  `        ``make_prefix(A, n); ` `     `  `        ``for` `(``int` `j = 0; j < q; j++) ` `            ``Console.WriteLine(Solve(L[j], R[j])); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw (manishshaw1) `

## PHP

 `= (``\$tot_bits` `- ``\$x``))  ` `        ``{ ` `            ``\$ith_bit` `= pow(2, ``\$i``); ` ` `  `            ``// Set ith bit to 0 by ` `            ``// doing Xor with 1 ` `            ``\$X` `= ``\$X` `^ ``\$ith_bit``; ` `        ``} ` `    ``} ` `    ``return` `\$X``; ` `} ` ` `  `// Driver Code ` `\$n` `= 5; ``\$q` `= 3; ` `\$A` `= [ 210, 11, 48, 22, 133 ]; ` `\$L` `= [ 1, 4, 2 ];  ` `\$R` `= [ 3, 14, 4 ]; ` ` `  `make_prefix(``\$A``, ``\$n``); ` ` `  `for` `(``\$j` `= 0; ``\$j` `< ``\$q``; ``\$j``++) ` `    ``echo` `(Solve(``\$L``[``\$j``], ``\$R``[``\$j``]). ``"\n"``); ` `     `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) ` `?> `

Output :

```2147483629
2147483647
2147483629
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.