# Queries to find the XOR of an Array after replacing all occurrences of X by Y

Given an array arr[] consisting of N distinct integers and queries Q[][] of the type {X, Y}, the task for each query is to find the bitwise XOR of all the array elements after replacing X by Y in the array.

Examples:

Input: arr[] = {1, 2, 3, 4, 5} Q = {(1, 4) (3, 6) (2, 3)}
Output:4 1 0
Explanation:
Query 1: The array modifies to {4, 2, 3, 4, 5} and XOR = 4
Query 2: The array modifies to {4, 2, 6, 4, 5} and XOR = 1
Query 3: The array modifies to {4, 3, 6, 4, 5} and XOR = 0

Input: arr[] = {5, 7, 8, 9, } Q = {(5, 6) (8, 1)}
Output: 0 9
Explanation:
Query 1: The array modifies to {6, 7, 8, 9} and XOR = 0
Query 2: The array modifies to {6, 7, 1, 9} and XOR = 9

Approach:
The approach is to use the Bitwise XOR property:

• Suppose, there are three elements A, B, and and X, and their Xor is, total_xor = A ^ B ^ X.
• To remove the contribution of X from total_xor, perform total_xor ^ X. It can be verified from the fact that A ^ B ^ X ^ X = A ^ B (XOR of an element with itself is 0).
• To add the contribution of Y in the total_xor, simply perform total_xor ^ Y.

Below is the implementation of the above approach:

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Stores the bitwise XOR ` `// of array elements ` `int` `total_xor; ` ` `  `// Function to find the total xor ` `void` `initialize_xor(``int` `arr[], ``int` `n) ` `{ ` `    ``// Loop to find the xor ` `    ``// of all the elements ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``total_xor = total_xor ^ arr[i]; ` `    ``} ` `} ` ` `  `// Function to find the XOR ` `// after replacing all occurrences ` `// of X by Y for Q queries ` `void` `find_xor(``int` `X, ``int` `Y) ` `{ ` `    ``// Remove contribution of ` `    ``// X from total_xor ` `    ``total_xor = total_xor ^ X; ` ` `  `    ``// Adding contribution of ` `    ``// Y to total_xor ` `    ``total_xor = total_xor ^ Y; ` ` `  `    ``// Print total_xor ` `    ``cout << total_xor << ``"\n"``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 7, 8, 9 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``initialize_xor(arr, n); ` ` `  `    ``vector > Q = { { 5, 6 }, { 8, 1 } }; ` ` `  `    ``for` `(``int` `i = 0; i < Q.size(); i++) { ` `        ``find_xor(Q[i], Q[i]); ` `    ``} ` `    ``return` `0; ` `} `

 `// Java Program to implement ` `// the above approach ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `// Stores the bitwise XOR ` `// of array elements ` `static` `int` `total_xor; ` ` `  `// Function to find the total xor ` `static` `void` `initialize_xor(``int` `arr[], ` `                           ``int` `n) ` `{ ` `    ``// Loop to find the xor ` `    ``// of all the elements ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``total_xor = total_xor ^ arr[i]; ` `    ``} ` `} ` ` `  `// Function to find the XOR ` `// after replacing all occurrences ` `// of X by Y for Q queries ` `static` `void` `find_xor(``int` `X, ``int` `Y) ` `{ ` `    ``// Remove contribution of ` `    ``// X from total_xor ` `    ``total_xor = total_xor ^ X; ` ` `  `    ``// Adding contribution of ` `    ``// Y to total_xor ` `    ``total_xor = total_xor ^ Y; ` ` `  `    ``// Print total_xor ` `    ``System.out.print(total_xor + ``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``5``, ``7``, ``8``, ``9` `}; ` `    ``int` `n = arr.length; ` ` `  `    ``initialize_xor(arr, n); ` ` `  `    ``int` `[][]Q = { { ``5``, ``6` `}, { ``8``, ``1` `} }; ` ` `  `    ``for` `(``int` `i = ``0``; i < Q.length; i++) ` `    ``{ ` `        ``find_xor(Q[i][``0``], Q[i][``1``]); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by Rohit_ranjan`

 `# Python3 program to implement ` `# the above approach ` ` `  `# Stores the bitwise XOR ` `# of array elements ` `global` `total_xor ` `total_xor ``=` `0` ` `  `# Function to find the total xor ` `def` `initialize_xor(arr, n): ` ` `  `    ``global` `total_xor ` ` `  `    ``# Loop to find the xor ` `    ``# of all the elements ` `    ``for` `i ``in` `range``(n): ` `        ``total_xor ``=` `total_xor ^ arr[i] ` ` `  `# Function to find the XOR ` `# after replacing all occurrences ` `# of X by Y for Q queries ` `def` `find_xor(X, Y): ` `     `  `    ``global` `total_xor ` ` `  `    ``# Remove contribution of ` `    ``# X from total_xor ` `    ``total_xor ``=` `total_xor ^ X ` ` `  `    ``# Adding contribution of ` `    ``# Y to total_xor ` `    ``total_xor ``=` `total_xor ^ Y ` ` `  `    ``# Print total_xor  ` `    ``print``(total_xor) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``arr ``=` `[ ``5``, ``7``, ``8``, ``9` `] ` `    ``n ``=` `len``(arr) ` ` `  `    ``initialize_xor(arr, n) ` ` `  `    ``Q ``=` `[ [ ``5``, ``6` `], [ ``8``, ``1` `] ] ` ` `  `    ``# Function call ` `    ``for` `i ``in` `range``(``len``(Q)): ` `        ``find_xor(Q[i][``0``], Q[i][``1``]) ` ` `  `# This code is contributed by Shivam Singh `

 `// C# program to implement ` `// the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Stores the bitwise XOR ` `// of array elements ` `static` `int` `total_xor; ` ` `  `// Function to find the total xor ` `static` `void` `initialize_xor(``int` `[]arr, ` `                           ``int` `n) ` `{ ` `     `  `    ``// Loop to find the xor ` `    ``// of all the elements ` `    ``for``(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``total_xor = total_xor ^ arr[i]; ` `    ``} ` `} ` ` `  `// Function to find the XOR ` `// after replacing all occurrences ` `// of X by Y for Q queries ` `static` `void` `find_xor(``int` `X, ``int` `Y) ` `{ ` `     `  `    ``// Remove contribution of ` `    ``// X from total_xor ` `    ``total_xor = total_xor ^ X; ` ` `  `    ``// Adding contribution of ` `    ``// Y to total_xor ` `    ``total_xor = total_xor ^ Y; ` ` `  `    ``// Print total_xor ` `    ``Console.Write(total_xor + ``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { 5, 7, 8, 9 }; ` `    ``int` `n = arr.Length; ` ` `  `    ``initialize_xor(arr, n); ` ` `  `    ``int` `[,]Q = { { 5, 6 }, { 8, 1 } }; ` ` `  `    ``for``(``int` `i = 0; i < Q.GetLength(0); i++) ` `    ``{ ` `        ``find_xor(Q[i, 0], Q[i, 1]); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar`

Output:
```0
9
```

Time Complexity: O(N + sizeof(Q))
Auxiliary Space: O(1)

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.

Computer Science Student || Competitive Coder || Machine Learning Enthusiast || Open to internship opportunities

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.