# Find the XOR of the elements in the given range [L, R] with the value K for a given set of queries

Given an array arr[] and Q queries, the task is to find the resulting updated array after Q queries. There are two types of queries and the following operation is performed by them:

1. Update(L, R, K): Perform XOR for each element within the range L to R with K.
2. Display(): Display the current state of the given array.

Examples:

Input: arr[] = {1, 2, 3, 4, 5, 6}, Q = 2
Query 1: Update(1, 5, 3)
Query 2: Display()
Output: 2 1 0 7 6 6
Explanation:
The update query performs XOR of all elements in the range [1, 5].
After performing the update query, the above array is displayed for display query because:
1 ^ 3 = 2
2 ^ 3 = 1
3 ^ 3 = 0
4 ^ 3 = 7
5 ^ 3 = 6

Input: arr[] = {2, 4, 6, 8, 10}, Q = 3
Query 1: Update(1, 3, 2)
Query 2: Update(2, 4, 3)
Query 3: Display()
Output: 0 5 7 11 10
Explanation:
There are two update queries.
After performing the first update query, the given array is changed to {0, 6, 4, 8, 10}. This is because:
2 ^ 2 = 0
4 ^ 2 = 6
6 ^ 2 = 4
After obtaining this array, this array further gets changed for the second query as the {0, 5, 7, 11, 10}. This is because:
6 ^ 3 = 5
4 ^ 3 = 7
8 ^ 3 = 11

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

Naive Approach: The naive approach for this problem is for every update query, run a loop from L to R and perform the XOR operation with the given K with all the elements from arr[L] to arr[R]. In order to perform the display query, simply print the array arr[]. The time complexity for this approach is O(NQ) where N is the length of the array and Q is the number of queries.

Efficient Approach: The idea is to use a kadane’s algorithm for this problem.

• An empty array res[] is defined with the same length as the original array.
• For every update query {L, R, K}, the res[] array is modified as:
1. XOR K to res[L]
2. XOR K to res[R + 1]
• Whenever the user gives a display query:
1. Initialize a counter variable ‘i’ to the index 1.
2. Perform the operation:
`res[i] = res[i] ^ res[i - 1]`
3. Initialize a counter variable 'i' to the index 0.
4. For every index in the array's the required answer is:
```arr[i] ^ res[i]
```

Below is the implementation of the above approach:

## C++

 `// C++ implementation to perform the ` `// XOR range updates on an array ` `#include ` `using` `namespace` `std; ` ` `  `// Function to perform the update operation ` `// on the given array ` `void` `update(``int` `res[], ``int` `L, ``int` `R, ``int` `K) ` `{ ` ` `  `    ``// Converting the indices to ` `    ``// 0 indexing. ` `    ``L -= 1; ` `    ``R -= 1; ` ` `  `    ``// Saving the XOR of K from the starting ` `    ``// index in the range [L, R]. ` `    ``res[L] ^= K; ` ` `  `    ``// Saving the XOR of K at the ending index ` `    ``// in the given [L, R]. ` `    ``res[R + 1] ^= K; ` `} ` ` `  `// Function to display the resulting array ` `void` `display(``int` `arr[], ``int` `res[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = 1; i < n; i++) { ` ` `  `        ``// Finding the resultant value in the ` `        ``// result array ` `        ``res[i] = res[i] ^ res[i - 1]; ` `    ``} ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Combining the effects of the updates ` `        ``// with the original array without ` `        ``// changing the initial array. ` `        ``cout << (arr[i] ^ res[i]) << ``" "``; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 4, 6, 8, 10 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``int` `res[N]; ` `    ``memset``(res, 0, ``sizeof``(res)); ` ` `  `    ``// Query 1 ` `    ``int` `L = 1, R = 3, K = 2; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 2 ` `    ``L = 2; ` `    ``R = 4; ` `    ``K = 3; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 3 ` `    ``display(arr, res, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to perform the ` `// XOR range updates on an array ` `class` `GFG{ ` `     `  `// Function to perform the update  ` `// operation on the given array ` `static` `void` `update(``int` `res[], ``int` `L,  ` `                   ``int` `R, ``int` `K) ` `{ ` `     `  `    ``// Converting the indices to ` `    ``// 0 indexing. ` `    ``L -= ``1``; ` `    ``R -= ``1``; ` ` `  `    ``// Saving the XOR of K from the  ` `    ``// starting index in the range [L, R]. ` `    ``res[L] ^= K; ` ` `  `    ``// Saving the XOR of K at the ending  ` `    ``// index in the given [L, R]. ` `    ``res[R + ``1``] ^= K; ` `} ` ` `  `// Function to display the resulting array ` `static` `void` `display(``int` `arr[],  ` `                    ``int` `res[], ``int` `n) ` `{ ` `    ``int` `i; ` `    ``for``(i = ``1``; i < n; i++) ` `    ``{ ` `         `  `       ``// Finding the resultant value  ` `       ``// in the result array ` `       ``res[i] = res[i] ^ res[i - ``1``]; ` `    ``} ` ` `  `    ``for``(i = ``0``; i < n; i++) ` `    ``{ ` `        `  `       ``// Combining the effects of the  ` `       ``// updates with the original array  ` `       ``// without changing the initial array. ` `       ``System.out.print((arr[i] ^ res[i]) + ``" "``); ` `    ``} ` `    ``System.out.println(); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String []args) ` `{ ` `    ``int` `arr[] = { ``2``, ``4``, ``6``, ``8``, ``10` `}; ` `    ``int` `N = arr.length; ` `    ``int` `res[] = ``new` `int``[N]; ` ` `  `    ``// Query 1 ` `    ``int` `L = ``1``, R = ``3``, K = ``2``; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 2 ` `    ``L = ``2``; ` `    ``R = ``4``; ` `    ``K = ``3``; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 3 ` `    ``display(arr, res, N); ` `} ` `} ` ` `  `// This code is contributed by chitranayal `

## Python3

 `# Python3 implementation to perform the  ` `# XOR range updates on an array  ` ` `  `# Function to perform the update operation  ` `# on the given array  ` `def` `update(res, L, R, K):  ` ` `  `    ``# Converting the indices to  ` `    ``# 0 indexing.  ` `    ``L ``=` `L ``-` `1` `    ``R ``=` `R ``-` `1` ` `  `    ``# Saving the XOR of K from the starting  ` `    ``# index in the range [L, R].  ` `    ``res[L] ``=` `res[L] ^ K ` ` `  `    ``# Saving the XOR of K at the ending index  ` `    ``# in the given [L, R].  ` `    ``res[R ``+` `1``] ``=` `res[R ``+` `1``] ^ K ` ` `  `# Function to display the resulting array  ` `def` `display(arr, res, n): ` ` `  `    ``for` `i ``in` `range``(``1``, n): ` ` `  `        ``# Finding the resultant value in the  ` `        ``# result array  ` `        ``res[i] ``=` `res[i] ^ res[i ``-` `1``] ` `         `  `    ``for` `i ``in` `range``(``0``, n): ` ` `  `        ``# Combining the effects of the updates  ` `        ``# with the original array without  ` `        ``# changing the initial array.  ` `        ``print` `(arr[i] ^ res[i], end ``=` `" "``) ` ` `  `# Driver code  ` `arr ``=` `[ ``2``, ``4``, ``6``, ``8``, ``10` `]  ` `N ``=` `len``(arr)  ` `res ``=` `[``0``] ``*` `N ` ` `  `# Query 1  ` `L ``=` `1` `R ``=` `3` `K ``=` `2` `update(res, L, R, K)  ` ` `  `# Query 2  ` `L ``=` `2` `R ``=` `4` `K ``=` `3` `update(res, L, R, K)  ` ` `  `# Query 3  ` `display(arr, res, N) ` ` `  `# This code is contributed by Pratik Basu  `

## C#

 `// C# implementation to perform the ` `// XOR range updates on an array ` `using` `System; ` `class` `GFG{ ` `     `  `// Function to perform the update  ` `// operation on the given array ` `static` `void` `update(``int` `[]res, ``int` `L,  ` `                   ``int` `R, ``int` `K) ` `{ ` `     `  `    ``// Converting the indices to ` `    ``// 0 indexing. ` `    ``L -= 1; ` `    ``R -= 1; ` ` `  `    ``// Saving the XOR of K from the  ` `    ``// starting index in the range [L, R]. ` `    ``res[L] ^= K; ` ` `  `    ``// Saving the XOR of K at the ending  ` `    ``// index in the given [L, R]. ` `    ``res[R + 1] ^= K; ` `} ` ` `  `// Function to display the resulting array ` `static` `void` `display(``int` `[]arr,  ` `                    ``int` `[]res, ``int` `n) ` `{ ` `    ``int` `i; ` `    ``for``(i = 1; i < n; i++) ` `    ``{ ` `         `  `        ``// Finding the resultant value  ` `        ``// in the result array ` `        ``res[i] = res[i] ^ res[i - 1]; ` `    ``} ` ` `  `    ``for``(i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// Combining the effects of the  ` `        ``// updates with the original array  ` `        ``// without changing the initial array. ` `        ``Console.Write((arr[i] ^ res[i]) + ``" "``); ` `    ``} ` `    ``Console.WriteLine(); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]arr = { 2, 4, 6, 8, 10 }; ` `    ``int` `N = arr.Length; ` `    ``int` `[]res = ``new` `int``[N]; ` ` `  `    ``// Query 1 ` `    ``int` `L = 1, R = 3, K = 2; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 2 ` `    ``L = 2; ` `    ``R = 4; ` `    ``K = 3; ` `    ``update(res, L, R, K); ` ` `  `    ``// Query 3 ` `    ``display(arr, res, N); ` `} ` `} ` ` `  `// This code is contributed by Code_Mech `

Output:

```0 5 7 11 10
```

Time Complexity:

• The time complexity for the update is O(1).
• The time complexity for displaying the array is O(N).

Note: This approach works very well when the update queries are very high compared to the display queries.

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.