# Queries to update each element in subarray to Bitwise XOR with a given value

• Last Updated : 08 Sep, 2021

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 perform 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][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) {` `        ``cout << (arr[i] ^ temp[i]) << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `arr[] = { 2, 3, 6, 5, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``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 perform 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 perform 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 perform 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`

## Javascript

 ``

Output:

`0 5 0 1 4`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :