Related Articles
Queries to update each element in subarray to Bitwise XOR with a given value
• Last Updated : 07 Aug, 2020

Given an array arr[], and queries Q[][] of the form (l, r, val), the task for each query is to update all the elements in the indices [l – 1, r – 1] to Bitwise XOR with val. Print the final array obtained after completing all queries.
Examples:

Input: arr[] = {2, 3, 6, 5, 4}, Q[][] = {{1, 3, 2}, {2, 4, 4}}
Output: 0 5 0 1 4
Explanation:
1st Query: Concerned subarray {2, 3, 6} modifies to {0, 1, 4} after replacing each element with its XOR with val(= 2)
The modified array is {0, 1, 4, 5, 4}
2nd Query: Concerned subarray {1, 4, 5} modifies to {5, 0, 1} after replacing each element with its XOR with val(= 4)
Hence, the final array is {0, 5, 0, 1, 4}

Input: arr[] = {1, 3, 5}, Q[][] = {{1, 2, 8}, {2, 3, 3}}
Output: 9 8 6

Naive Approach:
The simplest approach to solve this problem is to traverse indices [l – 1, r – 1] for each query and replace arr[i] by arr[i]^val. After completing all queries, print the modified array.
Time Complexity: O(N*sizeof(Q))
Auxiliary Space: O(1)

Approach: Follow the steps to solve the problem by processing each query in constant time complexity:

• Initialize an array temp[] with all zeroes.
• For each query of the form (l, r, val), update temp[l – 1] and temp[r] with their respective XOR with val.
• After completing the above step for each query, convert temp[] to a prefix XOR array.
• Finally, perform update arr[] by replacing every ith element with its XOR.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;`` ` `// Function to perform XOR in``// the range [lo, hi]``void` `findxor(``int` `temp[], ``int` `N,``             ``int` `lo, ``int` `hi, ``int` `val)``{``    ``temp[lo] ^= val;``    ``if` `(hi != N - 1)``        ``temp[hi + 1] ^= val;``}`` ` `// Function to generate Prefix``// Xor Array``void` `updateArray(``int` `temp[], ``int` `N)``{``    ``for` `(``int` `i = 1; i < N; i++)``        ``temp[i] ^= temp[i - 1];``}`` ` `// Function to perfrom each Query``// and print the final array``void` `xorQuery(``int` `arr[], ``int` `n,``              ``vector > Q)``{`` ` `    ``int` `temp[n];``    ``// initialize temp array to 0``    ``memset``(temp, 0, ``sizeof``(temp));`` ` `    ``// Perform each Query``    ``for` `(``int` `i = 0; i < Q.size(); i++) {``        ``findxor(temp, n, Q[i] - 1,``                ``Q[i] - 1, Q[i]);``    ``}`` ` `    ``// Modify the array``    ``updateArray(temp, n);`` ` `    ``// Print the final array``    ``for` `(``int` `i = 0; i < n; ++i) {``        ``cout << (arr[i] ^ temp[i]) << ``" "``;``    ``}``}`` ` `// Driver Code``int` `main()``{`` ` `    ``int` `arr[] = { 2, 3, 6, 5, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``vector > Q = { { 1, 3, 2 },``                               ``{ 2, 4, 4 } };`` ` `    ``xorQuery(arr, n, Q);`` ` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;`` ` `class` `GFG{``     ` `// Function to perform XOR in``// the range [lo, hi]``static` `void` `findxor(``int` `temp[], ``int` `N,``                    ``int` `lo, ``int` `hi, ``int` `val)``{``    ``temp[lo] ^= val;``    ``if` `(hi != N - ``1``)``        ``temp[hi + ``1``] ^= val;``}`` ` `// Function to generate Prefix``// Xor Array``static` `void` `updateArray(``int` `temp[], ``int` `N)``{``    ``for``(``int` `i = ``1``; i < N; i++)``        ``temp[i] ^= temp[i - ``1``];``}`` ` `// Function to perfrom each Query``// and print the final array``static` `void` `xorQuery(``int` `arr[], ``int` `n,``                     ``int``[][] Q)``{``    ``int``[] temp = ``new` `int``[n];`` ` `    ``// Perform each Query``    ``for``(``int` `i = ``0``; i < Q.length; i++)``    ``{``        ``findxor(temp, n, Q[i][``0``] - ``1``,``                         ``Q[i][``1``] - ``1``,``                         ``Q[i][``2``]);``    ``}`` ` `    ``// Modify the array``    ``updateArray(temp, n);`` ` `    ``// Print the final array``    ``for``(``int` `i = ``0``; i < n; ++i)``    ``{``        ``System.out.print((arr[i] ^ temp[i]) + ``" "``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `arr[] = { ``2``, ``3``, ``6``, ``5``, ``4` `};``    ``int` `n = arr.length;``     ` `    ``int``[][] Q = { { ``1``, ``3``, ``2` `},``                  ``{ ``2``, ``4``, ``4` `} };``     ` `    ``xorQuery(arr, n, Q);``}``}`` ` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement``# the above approach`` ` `# Function to perform XOR in``# the range [lo, hi]``def` `findxor(temp, N, lo, hi, val):`` ` `    ``temp[lo] ^``=` `val``    ``if` `(hi !``=` `N ``-` `1``):``        ``temp[hi ``+` `1``] ^``=` `val`` ` `# Function to generate Prefix``# Xor Array``def` `updateArray(temp, N):`` ` `    ``for` `i ``in` `range``(``1``, N):``        ``temp[i] ^``=` `temp[i ``-` `1``]`` ` `# Function to perfrom each Query``# and print the final array``def` `xorQuery(arr, n, Q):`` ` `    ``temp ``=``[``0``] ``*` `n`` ` `    ``# Perform each Query``    ``for` `i ``in` `range``(``len``(Q)):``        ``findxor(temp, n, Q[i][``0``] ``-` `1``,``                         ``Q[i][``1``] ``-` `1``, ``                         ``Q[i][``2``])`` ` `    ``# Modify the array``    ``updateArray(temp, n)`` ` `    ``# Print the final array``    ``for` `i ``in` `range``(n):``        ``print``((arr[i] ^ temp[i]), end ``=` `" "``)`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:`` ` `    ``arr ``=` `[ ``2``, ``3``, ``6``, ``5``, ``4` `]``    ``n ``=` `len``(arr)``    ``Q ``=` `[ [ ``1``, ``3``, ``2` `],``          ``[ ``2``, ``4``, ``4` `] ] `` ` `    ``xorQuery(arr, n, Q)`` ` `# This code is contributed by chitranayal`

## C#

 `// C# program for the above approach``using` `System;`` ` `class` `GFG{``     ` `// Function to perform XOR in``// the range [lo, hi]``static` `void` `findxor(``int` `[]temp, ``int` `N,``                    ``int` `lo, ``int` `hi, ``int` `val)``{``    ``temp[lo] ^= val;``     ` `    ``if` `(hi != N - 1)``        ``temp[hi + 1] ^= val;``}`` ` `// Function to generate Prefix``// Xor Array``static` `void` `updateArray(``int` `[]temp, ``int` `N)``{``    ``for``(``int` `i = 1; i < N; i++)``        ``temp[i] ^= temp[i - 1];``}`` ` `// Function to perfrom each Query``// and print the readonly array``static` `void` `xorQuery(``int` `[]arr, ``int` `n,``                     ``int``[,] Q)``{``    ``int``[] temp = ``new` `int``[n];`` ` `    ``// Perform each Query``    ``for``(``int` `i = 0; i < Q.GetLength(0); i++)``    ``{``        ``findxor(temp, n, Q[i, 0] - 1,``                         ``Q[i, 1] - 1,``                         ``Q[i, 2]);``    ``}`` ` `    ``// Modify the array``    ``updateArray(temp, n);`` ` `    ``// Print the readonly array``    ``for``(``int` `i = 0; i < n; ++i)``    ``{``        ``Console.Write((arr[i] ^ temp[i]) + ``" "``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 2, 3, 6, 5, 4 };``    ``int` `n = arr.Length;``     ` `    ``int``[,] Q = { { 1, 3, 2 },``                 ``{ 2, 4, 4 } };``     ` `    ``xorQuery(arr, n, Q);``}``}`` ` `// This code is contributed by 29AjayKumar`
Output:
```0 5 0 1 4
```

Time Complexity: O(N)
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.

My Personal Notes arrow_drop_up