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: 3
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:
- Check if the given number of operations can be performed on the array or not.
- 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”.
- If the value of M is valid then check if the given index K is valid or not.
- 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”.
- 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[].
- 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<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 |
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 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 |
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 |
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.