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

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++ 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][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 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 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# 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.

Article Tags :
Practice Tags :