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

• Difficulty Level : Medium
• Last Updated : 22 Apr, 2022

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 1:

Observation:

Let the Array be [1 ,2 ,3 ,4 5,6,7,8,9,10]

After One operation   :   [1^2, 2^3, 3^4, 4^5, 5^6, 6^7, 7^8 , 8^9 , 9^10]

After Two operation   :  [1^2^2^3, 2^3^3^4, 3^4^4^5, 4^5^5^6, ,5^6^6^7, 6^7^7^8 , 7^8^8^9  , 8^9 ^9^10] ==>[ 1^3, 2^4, 3^5, 4^6, 5^7 , 6^8 , 7^9 , 8^10 ]

After Three operation:   [ 1^3^2^4, 2^4^3^5, 3^5^4^6 , 4^6^5^7 , 5^7^6^8 , 6^8^7^9 , 7^9^8^10 ]

After Four operation  :   [1^3^2^4^2^4^3^5 , 2^4^3^5^3^5^4^6 , 3^5^4^6^4^6^5^7 , 4^6^5^7 ^5^7^6^8 , 5^7^6^8^6^8^7^9 ,          6^8^7^9^7^9^8^10 ] ==> [ 1^5, 2^6 , 3^7 , 4^8 , 5^9 , 6^10 ]

After Five operation   :   [1^5^2^6 , 2^6^3^7 ,  3^7^4^8 , 4^8^5^9 , 5^9^6^10 ]

After Six operation   :      [1^5^3^7 , 2^6^4^8 ,  3^7^5^9 , 4^8^6^10]

After Seven operation   :  [1^5^3^7^2^6^4^8 , 2^6^4^8^3^7^5^9 ,  3^7^5^9^4^8^6^10]

After eight operation   :   [1^9 , 2^10]

So from Observation we can see that on ever 2^k th operation a[i]=a[i]^a[i+(2^k)]  for : i<n-2^k

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 after M operation size of array will be N-M,           if the index which we need to return is greater than or equal to size of the array after M operation (ie K>=N-M) ,hence we cannot perform operation and return -1.
3. If it is valid than we need to return the Kth index in updated array after M operation.
4. Now we need to perform operation M times
• As we know the relation  a[i]=a[i]^a[i+(2^k)] .So, Just we need to Make M as sum of number which are in form of 2^k and makes jumps to this number only.
• To do this we can iterate on the Bit that is set in M in its binary form and perform update according to Above relation to all index  ( index < n-2^k) .
5. Now we have to return the Kth element of the updated array .

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `m_step_xor(vector<``int``> a, ``int` `m, ``int` `k)``{``    ``int` `n = a.size();` `    ``// the total number of element remain after m operation``    ``// is n-m so the index that are greater than or equal to``    ``// n-m in zero-based indexing will be not present``    ``if` `(k >= n - m)``        ``return` `-1;` `    ``// considering m<2^18` `    ``for` `(``int` `i = 0; i < 18; i++) {``        ``// check whether ith bit is on or not in m``        ``if` `(m & (1 << i)) {``            ``m -= (1 << i);` `            ``// as the bit is on``            ``// Updating index that exist with the relation``            ``// a[i]=a[i]^a[i+2^j]``            ``for` `(``int` `j = 0; j < n - (1 << i); j++) {``                ``a[j] = a[j] ^ a[j + (1 << i)];``            ``}``        ``}``    ``}` `    ``// returning the Kth index in updated array after M``    ``// operation``    ``return` `a[k];``}` `int` `main()``{` `    ``vector<``int``> a = { 1, 4, 5, 6, 7 };` `    ``int` `m = 1, k = 2;``  ` `    ``// Function call``    ``int` `ans = m_step_xor(a, m, k);``    ` `    ``cout << ans << ``"\n"``;` `    ``return` `0;``}` `// This code is contributed by swaraj jain`

## Java

 `// Java code to implement the above approach``import` `java.io.*;` `class` `GFG {``    `  `  ``static` `public` `int` `m_step_xor(``int``[] a, ``int` `m, ``int` `k)``  ``{``    ``int` `n = a.length;` `    ``// the total number of element remain after m operation``    ``// is n-m so the index that are greater than or equal to``    ``// n-m in zero-based indexing will be not present``    ``if` `(k >= n - m)``      ``return` `-``1``;` `    ``// considering m<2^18` `    ``for` `(``int` `i = ``0``; i < ``18``; i++) {``      ``// check whether ith bit is on or not in m``      ``if` `((m & (``1` `<< i)) !=``0``) {``        ``m -= (``1` `<< i);` `        ``// as the bit is on``        ``// Updating index that exist with the relation``        ``// a[i]=a[i]^a[i+2^j]``        ``for` `(``int` `j = ``0``; j < n - (``1` `<< i); j++) {``          ``a[j] = a[j] ^ a[j + (``1` `<< i)];``        ``}``      ``}``    ``}` `    ``// returning the Kth index in updated array after M``    ``// operation``    ``return` `a[k];``  ``}` `  ``public` `static` `void` `main (String[] args)``  ``{` `    ``int``[] a = { ``1``, ``4``, ``5``, ``6``, ``7` `};` `    ``int` `m = ``1``, k = ``2``;` `    ``// Function call``    ``int` `ans = m_step_xor(a, m, k);` `    ``System.out.println(ans);``  ``}``}` `// This code is contributed by Shubham Singh`

## Python3

 `def` `m_step_xor(a, m, k):``    ` `    ``n ``=` `len``(a)``    ` `    ``# the total number of element remain after m operation``    ``# is n-m so the index that are greater than or equal to``    ``# n-m in zero-based indexing will be not present``    ``if` `(k >``=` `n ``-` `m):``        ``return` `-``1``        ` `    ``# considering m<2^18``    ``for` `i ``in` `range``(``18``):``        ` `        ``# check whether ith bit is on or not in m``        ``if` `(m & (``1` `<< i)):``            ``m ``-``=` `(``1` `<< i)``            ` `            ``# as the bit is on``            ``# Updating index that exist with the relation``            ``# a[i]=a[i]^a[i+2^j]``            ``for` `j ``in` `range``(n ``-` `(``1` `<< i)):``                ``a[j] ``=` `a[j] ^ a[j ``+` `(``1` `<< i)]``                ` `    ``# returning the Kth index in updated array after M``    ``# operation``    ``return` `a[k]` `a ``=` `[``1``, ``4``, ``5``, ``6``, ``7``]` `m ``=` `1``k ``=` `2` `# Function call``ans ``=` `m_step_xor(a, m, k)` `print``(ans)` `# This code is contributed by Shubham Singh`

## C#

 `// C# code to implement the above approach``using` `System;` `public` `class` `GFG{` `  ``static` `public` `int` `m_step_xor(``int``[] a, ``int` `m, ``int` `k)``  ``{``    ``int` `n = a.Length;` `    ``// the total number of element remain after m operation``    ``// is n-m so the index that are greater than or equal to``    ``// n-m in zero-based indexing will be not present``    ``if` `(k >= n - m)``      ``return` `-1;` `    ``// considering m<2^18` `    ``for` `(``int` `i = 0; i < 18; i++) {``      ``// check whether ith bit is on or not in m``      ``if` `((m & (1 << i)) !=0) {``        ``m -= (1 << i);` `        ``// as the bit is on``        ``// Updating index that exist with the relation``        ``// a[i]=a[i]^a[i+2^j]``        ``for` `(``int` `j = 0; j < n - (1 << i); j++) {``          ``a[j] = a[j] ^ a[j + (1 << i)];``        ``}``      ``}``    ``}` `    ``// returning the Kth index in updated array after M``    ``// operation``    ``return` `a[k];``  ``}` `  ``static` `public` `void` `Main ()``  ``{` `    ``int``[] a = { 1, 4, 5, 6, 7 };` `    ``int` `m = 1, k = 2;` `    ``// Function call``    ``int` `ans = m_step_xor(a, m, k);` `    ``Console.WriteLine(ans);``  ``}``}` `// This code is contributed by Shubham Singh`

## Javascript

 ``
Output
`3`

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

Approach 2: 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)

My Personal Notes arrow_drop_up