Skip to content
Related Articles
Kth array element after M replacements of array elements by XOR of adjacent pairs
• Difficulty Level : Easy
• Last Updated : 19 Mar, 2021

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:

## C++

 `// C++ program for the above approach``#include``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`

## Java

 `// 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``        ``Vectortemp = ``new` `Vector();``    ` `        ``// 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`

## Python3

 `# 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))`

## C#

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

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up