Kth array element after M replacements of array elements by XOR of adjacent pairs

Given an array arr[] of size N and two integers M and K, the task is to find the array element at the Kth index after performing following M operations on the given array.

In a single operation, a new array is formed whose elements have the Bitwise XOR values of the adjacent elements of the current array.

If the number of operations M or the value of K after M operations is invalid then print -1.

Examples:

Input: arr[] = {1, 4, 5, 6, 7}, M = 1, K = 2 
Output:
Explanation: 
Since M = 1, therefore, the operation has to be performed only once on the array. 
The array is modified to {1^4, 4^5, 5^6, 6^7} = {5, 1, 3, 1}. 
The value of the element at index K = 2 in the updated array is 3.



Input: arr[] = {3, 2, 6}, M = 2, K = 1 
Output: -1 
Explanation: 
Since M = 2, operation has be performed twice. 
On performing 1st operation on the array {3, 2, 6} it is modified as {3^2, 2^6} = {1, 4}. 
On performing 2nd operation on the array {1, 4}, it is modified as {1^4} = {5}. 
After performing 2 operations, the size of the array is reduced to 1. This implies that the index K = 1 doesn’t exist after 2 operations. 
Hence, the given input is invalid. So the output is -1.

Approach: The idea is to generate the array after every operation and check-in each iteration whether it is possible to do the operation further or not. If it is not possible, then return “-1”. Below are the steps:

  1. Check if the given number of operations can be performed on the array or not.
  2. After every iteration, the length of the array is reduced by 1 which means if M is greater than or equal to N, then it is not possible to perform the operation. Hence, print “-1”.
  3. If the value of M is valid then check if the given index K is valid or not.
  4. After M operations, (N – M) elements are left in the array. So, if the index value is greater than or equal to the value of (N – M), then print “-1”.
  5. If both M and K values are valid, then iterate a loop M times and do the following: 
    • In each iteration, create a temporary array temp[] which stores the values obtained by performing operation on the adjacent values of the original array.
    • Traverse the array arr[] and calculate the Bitwise XOR values of adjacent elements and save these calculated values in the temporary array temp[].
    • Update the current array arr[] with temp[].
  6. After the M iterations, return the value of arr[K], which is the required output.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Method that returns the
// corresponding output by
// taking the given inputs.
int xor_operations(int N, int arr[], 
                   int M, int K)
{
     
    // If this condition is satisfied,
    // value of M is invalid
    if (M < 0 or M >= N)
        return -1;
     
    // Check if index K is valid
    if (K < 0 or K >= N - M)
        return -1;
     
    // Loop to perform M operations
    for(int p = 0; p < M; p++)
    {
         
        // Creating a temporary list
        vector<int>temp;
     
        // Traversing the array
        for(int i = 0; i < N; i++)
        {
             
            // Calculate XOR values
            // of adjacent elements
            int value = arr[i] ^ arr[i + 1];
             
            // Adding this value to
            // the temporary list
            temp.push_back(value);
             
            // Update the original array
            arr[i] = temp[i];
        }
    }
     
    // Getting value at index K
    int ans = arr[K];
     
    return ans;
}
 
// Driver Code
int main()
{
    // Number of elements
    int N = 5;
     
    // Given array arr[]
    int arr[] = {1, 4, 5, 6, 7};
    int M = 1, K = 2;
     
    // Function call
    cout << xor_operations(N, arr, M, K);
    return 0;
}
 
// This code is contributed by gauravrajput1
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Method that returns the
// corresponding output by
// taking the given inputs.
static int xor_operations(int N, int arr[],
                          int M, int K)
{
     
    // If this condition is satisfied,
    // value of M is invalid
    if (M < 0 || M >= N)
        return -1;
     
    // Check if index K is valid
    if (K < 0 || K >= N - M)
        return -1;
     
    // Loop to perform M operations
    for(int p = 0; p < M; p++)
    {
         
        // Creating a temporary list
        Vector<Integer>temp = new Vector<Integer>();
     
        // Traversing the array
        for(int i = 0; i < N - 1; i++)
        {
             
            // Calculate XOR values
            // of adjacent elements
            int value = arr[i] ^ arr[i + 1];
             
            // Adding this value to
            // the temporary list
            temp.add(value);
             
            // Update the original array
            arr[i] = temp.get(i);
        }
    }
     
    // Getting value at index K
    int ans = arr[K];
     
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Number of elements
    int N = 5;
     
    // Given array arr[]
    int arr[] = { 1, 4, 5, 6, 7 };
    int M = 1, K = 2;
     
    // Function call
    System.out.print(xor_operations(N, arr, M, K));
}
}
 
// This code is contributed by Amit Katiyar
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
 
# Method that returns the
# corresponding output by
# taking the given inputs.
def xor_operations(N, arr, M, K):
     
    # If this condition is satisfied,
    # value of M is invalid
    if M < 0 or M >= N:
        return -1
     
    # Check if index K is valid
    if K < 0 or K >= N-M:
        return -1
     
 
    # Loop to perform M operations
    for _ in range(M):
     
        # Creating a temporary list
        temp = []
     
        # Traversing the array
        for i in range(len(arr)-1):
             
            # Calculate XOR values
            # of adjacent elements
            value = arr[i]^arr[i + 1]
             
            # Adding this value to
            # the temporary list
            temp.append(value)
         
        # Update the original array
        arr = temp[:]
     
    # Getting value at index K
    ans = arr[K]
    return ans
 
# Driver Code
 
# Number of elements
N = 5
 
# Given array arr[]
arr = [1, 4, 5, 6, 7]
M = 1
K = 2
 
# Function Call
print(xor_operations(N, arr, M, K))
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Method that returns the
// corresponding output by
// taking the given inputs.
static int xor_operations(int N, int []arr,
                          int M, int K)
{
  // If this condition is satisfied,
  // value of M is invalid
  if (M < 0 || M >= N)
    return -1;
 
  // Check if index K is valid
  if (K < 0 || K >= N - M)
    return -1;
 
  // Loop to perform M operations
  for(int p = 0; p < M; p++)
  {
    // Creating a temporary list
    List<int>temp = new List<int>();
 
    // Traversing the array
    for(int i = 0; i < N - 1; i++)
    {
      // Calculate XOR values
      // of adjacent elements
      int value = arr[i] ^ arr[i + 1];
 
      // Adding this value to
      // the temporary list
      temp.Add(value);
 
      // Update the original array
      arr[i] = temp[i];
    }
  }
 
  // Getting value at index K
  int ans = arr[K];
 
  return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Number of elements
  int N = 5;
 
  // Given array []arr
  int []arr = {1, 4, 5, 6, 7};
  int M = 1, K = 2;
 
  // Function call
  Console.Write(xor_operations(N, arr,
                               M, K));
}
}
 
// This code is contributed by Rajput-Ji
chevron_right

Output: 
3


Time Complexity: O(M * N) 
Auxiliary Space: O(N)

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.




Recommended Posts:

This article is contributed by Mohan. 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.



Article Tags :