Find a number X such that XOR of given Array after adding X to each element is 0

Last Updated : 17 Dec, 2021

Given an array arr[] of odd length N containing positive integers. The task is to find a positive integer X such that, adding X to all the elements of arr[] and then taking XOR of all the elements gives 0. Return -1 if no such X exists.

Examples:

Input: arr[] = {2, 4, 5}
Output: 1
Explanation: Following are the operations performed in arr[] to get the desired result.
Adding 1 to each element in arr[] updates arr[] to arr[] = {3, 5, 6}
Now XOR of all the elements in arr[] is 3^5^6 = 0.
Therefore, 1 is the required answer.

Input: arr[] = {4, 5, 13}
Output: -1
Explanation: No such x exists for fulfilling the desired conditions.

Approach: XOR of Odd number of 1’s = 1, while even number of 1’s = 0. This idea can be used to solve the given problem. Follow the steps mentioned below:

Initialize variable X = 0.
The binary representations of the array elements will be used for traversal of the elements and determining X.
Start traversing from the 0th bit to 63rd bit.
If at any bit position total number of set bits (1’s) of the array elements are odd, add that power of 2 with X.
If after completion of iteration there is odd number of 1 at any bit position then no such X exists. Otherwise, print X as answer.

See the illustrations below:

Illustration:

Case-1 (X possible): Take arr[] = { 2, 4, 5}

5th 4th 3rd 2nd 1st 0th

arr[0] 0 0 0 0 1 0

arr[1] 0 0 0 1 0 0

arr[2] 0 0 0 1 0 1

X 0 0 0 0 0 0

Initially, X = 0 0 0 0 0 0, at 0th position set(1) bits are odd, so in order to make the set bits even, flip the bits at 0th position. So, for flipping the bits just add (0 0 0 0 0 1) to all the elements of arr[] and in X.

Now, the table will look like the following:

5th 4th 3rd 2nd 1st 0th

arr[0] 0 0 0 0 1 1

arr[1] 0 0 0 1 0 1

arr[2] 0 0 0 1 1 0

XOR 0 0 0 0 0 0

X 0 0 0 0 0 1

Now, the XOR of (arr[0]+x) ^ ( arr[1]+x) ^ arr[2]+x) = 0, result will be 0. So, print res = X.

Take the following when no possible X

Case-2: Take example: arr[] = { 4, 5, 13 }

5th 4th 3rd 2nd 1st 0th

arr[0] 0 0 0 1 0 0

arr[1] 0 0 0 1 0 1

arr[2] 0 0 1 1 0 1

XOR 0 0 1 1 0 0

X 0 0 0 0 0 0

XOR = Arr[0] ^ Arr[1] ^ Arr[2] = 1 1 0 0, Here there are odd number of 1‘s at 2nd and 3rd bits.

So, add 2pow(2nd) to all elements of arr and in X, then again will take the XOR, after this the elements become:

5th 4th 3rd 2nd 1st 0th

arr[0] 0 0 1 0 0 0

arr[1] 0 0 1 0 0 1

arr[2] 0 1 0 0 0 1

XOR 0 1 0 0 0 0

X 0 0 0 1 0 0

If this keeps on going the left most 1 in XOR keeps on moving left.

Below is the implementation of the above approach:

C++

   // C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find required result
long long solve(vector<long long>& a,
                int n)
{
    long long res = 0, j = 0, one = 1;
 
    // For 64 Bit
    while (j < 64) {
        // j is traversing each bit
        long long Xor = 0;
        long long powerOf2 = one << j;
 
        for (auto x : a)
            Xor ^= x;
 
        if (j == 63 && (Xor & powerOf2))
            return -1;
 
        if (Xor & powerOf2) {
            res += powerOf2;
            for (int i = 0; i < n; i++)
                a[i] += powerOf2;
        }
        j++;
    }
    return res;
}
 
// Driver Code
int main()
{
 
    // Size of arr[]
    int N = 3;
    vector<long long> arr = { 2, 4, 5 };
 
    cout << solve(arr, N) << '\n';
 
    return 0;
}
 
  

Java

   // Java program for above approach
class GFG{
 
// Function to find required result
static long solve(int[] a,
                int n)
{
    long res = 0, j = 0, one = 1;
 
    // For 64 Bit
    while (j < 64) 
    {
       
        // j is traversing each bit
        long Xor = 0;
        long powerOf2 = one << j;
 
        for (int x : a)
            Xor ^= x;
 
        if (j == 63 && (Xor & powerOf2)!=0)
            return -1;
 
        if ((Xor & powerOf2)!=0) {
            res += powerOf2;
            for (int i = 0; i < n; i++)
                a[i] += powerOf2;
        }
        j++;
    }
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
 
    // Size of arr[]
    int N = 3;
    int[] arr = { 2, 4, 5 };
 
    System.out.print(solve(arr, N));
}
}
 
// This code is contributed by shikhasingrajput
 
  

Python3

   # python program for above approach
 
# Function to find required result
def solve(a, n):
 
    res = 0
    j = 0
    one = 1
 
    # For 64 Bit
    while (j < 64):
                # j is traversing each bit
        Xor = 0
        powerOf2 = one << j
 
        for x in a:
            Xor ^= x
 
        if (j == 63 and (Xor & powerOf2)):
            return -1
 
        if (Xor & powerOf2):
            res += powerOf2
            for i in range(0, n):
                a[i] += powerOf2
 
        j += 1
 
    return res
 
# Driver Code
if __name__ == "__main__":
 
        # Size of arr[]
    N = 3
    arr = [2, 4, 5]
 
    print(solve(arr, N))
 
    # This code is contributed by rakeshsahni
 
  

C#

   // C# program for above approach
using System;
class GFG
{
 
    // Function to find required result
    static long solve(int[] a, int n)
    {
        int res = 0, j = 0, one = 1;
 
        // For 64 Bit
        while (j < 64)
        {
 
            // j is traversing each bit
            long Xor = 0;
            long powerOf2 = one << j;
 
            foreach (int x in a)
                Xor ^= x;
 
            if (j == 63 && (Xor & powerOf2) != 0)
                return -1;
 
            if ((Xor & powerOf2) != 0)
            {
                res += (int)powerOf2;
                for (int i = 0; i < n; i++)
                    a[i] += (int)powerOf2;
            }
            j++;
        }
        return res;
    }
 
    // Driver Code
    public static void Main()
    {
 
        // Size of arr[]
        int N = 3;
        int[] arr = { 2, 4, 5 };
 
        Console.Write(solve(arr, N));
    }
}
 
// This code is contributed by gfgking
 
  

Javascript

   <script>
 
// JavaScript program for above approach 
 
// Function to find required result
function solve(a, n)
{
    let res = 0, j = 0, one = 1;
     
    // For 64 Bit
    while (j < 64)
    {
         
        // j is traversing each bit
        let Xor = 0;
        let powerOf2 = one << j;
     
        for(let x of a)
            Xor ^= x;
     
        if (j == 63 && (Xor & powerOf2))
            return -1;
     
        if (Xor & powerOf2) 
        {
            res += powerOf2;
            for(let i = 0; i < n; i++)
                a[i] += powerOf2;
        }
        j++;
    }
    return res;
}
 
// Driver Code
 
// Size of arr[]
let N = 3;
let arr = [ 2, 4, 5 ];
 
document.write(solve(arr, N) + '<br>');
 
// This code is contributed by Potta Lokesh
 
</script>
 
  

Output

Time Complexity: O(N*logN)
Auxiliary Space: O(1)

Count numbers in the range [L, R] having only three set bits

madhav_mohan

Improve

Article Tags :

Practice Tags :

Find a number X such that XOR of given Array after adding X to each element is 0

C++

Java

Python3

C#

Javascript

Similar Reads