XOR of Array Elements Except Itself in Java

It is a problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to discuss XOR of array elements except itself in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

We have given an array that contains only non-negative elements. The task is to create another array (say output[]) such that output[i] contains XOR of all the elements of the input array except input[i]. The following examples illustrates the same.

Let's understand it through examples.

Example 1:

Input: int input[] = {4, 7, 9, 3, 2, 5, 6}

Output: output[] = {12, 15, 1, 11, 10, 13, 14}

Explanation: If we exclude the current element and apply the XOR operation on rest of the elements, we get the mentioned output. Observe the following.

output[0] = 7 ^ 9 ^ 3 ^ 2 ^ 5 ^ 6 = 12

output[1] = 4 ^ 9 ^ 3 ^ 2 ^ 5 ^ 6 = 15

output[2] = 4 ^ 7 ^ 3 ^ 2 ^ 5 ^ 6 = 1

output[3] = 4 ^ 7 ^ 9 ^ 2 ^ 5 ^ 6 = 11

output[4] = 4 ^ 7 ^ 9 ^ 3 ^ 5 ^ 6 = 10

output[5] = 4 ^ 7 ^ 9 ^ 3 ^ 2 ^ 6 = 13

output[6] = 4 ^ 7 ^ 9 ^ 3 ^ 2 ^ 5 = 14

Example 2:

Input: int input[] = {0, 6, 2, 9}

Output: output[] = {13, 11, 15, 4}

Explanation:

output[0] = 6 ^ 2 ^ 9 = 13

output[1] = 0 ^ 2 ^ 9 = 11

output[2] = 0 ^ 6 ^ 9 = 15

output[3] = 0 ^ 6 ^ 2 = 4

Solution to the Problem

Naive Approach

In this approach, we will use a nested for loop for computing the XOR of all the elements except itself.

FileName: XorArrElements.java

public class XorArrElements 
{
// a method that compute the xor of all the elements 
// except the current element of the array arr[]
public int[] findXor(int arr[])
{
int size = arr.length;
int output[] = new int[size];
for(int j = 0; j < size; j++)
{
    // for storing the xor of all the elements
    // except arr[j]
    int xor = 0;
    for(int k = 0; k < size; k++)
    {
        // excluding the element arr[j]
        if(j != k)
        {
            xor = xor ^ arr[k];
        }
    }
    // updating the output array
    output[j] = xor;
}
return output;
}
// main method
public static void main(String[] argvs)
{
// creating an object of the class XorArrElements
XorArrElements obj = new XorArrElements();
int input[] = {4, 7, 9, 3, 2, 5, 6}; 
int size = input.length;
int output[] = obj.findXor(input);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(input[i] + " ");
}
System.out.println();
System.out.println("The output array is: ");

for(int i = 0; i < size; i++)
{
System.out.print(output[i] + " ");
}
System.out.println("\n" );
// input 2
int input1[] = {0, 6, 2, 9}; 
// computing the size
size = input1.length;
int output1[] = obj.findXor(input1);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(input1[i] + " ");
}
System.out.println();
System.out.println("The output array is: ");

for(int i = 0; i < size; i++)
{
System.out.print(output1[i] + " ");
}
}
}

Output:

For the input array: 
4 7 9 3 2 5 6 
The output array is: 
12 15 1 11 10 13 14 

For the input array: 
0 6 2 9 
The output array is: 
13 11 15 4

Complexity Analysis: The program uses the nested for-loop. Hence, the time complexity of the above program is O(n²), where n is the total number of elements present in the input array. The program is not using any extra space. Thus, the space complexity of the program is constant, i.e., O(1).

The time complexity of the program can be reduced further. The following approach shows the same.

Computing XOR of All The Elements

We know that the XOR of the two numbers is always zero if both numbers are equal. Thus, we can compute the XOR of all the elements, and to exclude any element, do the XOR of all the elements with that element. Let's understand it with the help of an example.

int arr[] = {a1, a2, a3, a4, a5, a6}, size = 6

Thus, output[0] = (a1 ^ a2 ^ a3 ^ a4 ^ a5 ^ a6) ^ a1,

We know that the XOR operation is commutative. Therefore, we can group a1 together

output[0] = (a1 ^ a1 ^ a2 ^ a3 ^ a4 ^ a5 ^ a6) = 0 ^ a2 ^ a3 ^ a4 ^ a5 ^ a6 (as a1 ^ a1 = 0)

which is nothing but the XOR of all the elements except the element itself. The following program used the same concept.

FileName: XorArrElements1.java

public class XorArrElements1 
{
// a method that compute the xor of all the elements 
// except the current element of the array arr[]
public int[] findXor(int arr[])
{
int size = arr.length;
int output[] = new int[size];
// for storing the xor of all the elements
int xor = 0;
for(int j = 0; j < size; j++)
{
    xor = xor ^ arr[j];
}
for(int k = 0; k < size; k++)
{
// updating the output array
// excluding the arr[k] from XOR for the 
// element output[k]
output[k] = xor ^ arr[k];
}
return output;
}
// main method
public static void main(String[] argvs)
{
// creating an object of the class XorArrElements1
XorArrElements1 obj = new XorArrElements1();
// input 1
int input[] = {4, 7, 9, 3, 2, 5, 6}; 
// computing the size
int size = input.length;
int output[] = obj.findXor(input);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(input[i] + " ");
}
System.out.println();
System.out.println("The output array is: ");

for(int i = 0; i < size; i++)
{
System.out.print(output[i] + " ");
}
System.out.println("\n" );
// input 2
int input1[] = {0, 6, 2, 9}; 
// computing the size
size = input1.length;
int output1[] = obj.findXor(input1);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(input1[i] + " ");
}
System.out.println();
System.out.println("The output array is: ");
for(int i = 0; i < size; i++)
{
System.out.print(output1[i] + " ");
}
}
}

Output:

For the input array: 
4 7 9 3 2 5 6 
The output array is: 
12 15 1 11 10 13 14 

For the input array: 
0 6 2 9 
The output array is: 
13 11 15 4

Complexity Analysis: The time complexity of the program is O(n), where n is the total number of elements present in the input array. The space complexity of the program is the same as the above.

Next TopicNth Node from The End of a Linked List in Java

← prev next →