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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to perform the
// XOR range updates on an array
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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.

competitive-programming-img




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.