Reduce the given Array of [1, N] by rotating left or right based on given conditions
Given a sorted array arr[] of the first N Natural Numbers and an integer X, the task is to print the last remaining element after performing the below operations (N – 1) times:
- If the value of X is 1, then right rotate the array by 1 unit and delete the last element.
- If the value of X is 2, then left rotate the array by 1 unit and delete the first element.
Examples:
Input: N = 5, arr[] = {1, 2, 3, 4, 5}, X = 1
Output: 3
Explanation:
The operations are performed as follows:
- Rotating the array right by 1 unit modifies the array to {5, 1, 2, 3, 4}. Deleting the array element modifies the array to {5, 1, 2, 3}.
- Rotating the array right by 1 unit modifies the array to {3, 5, 1, 2}. Deleting the array element modifies the array to {3, 5, 1}.
- Rotating the array right by 1 unit modifies the array to {1, 3, 5}. Deleting the array element modifies the array to {1, 3}.
- Rotating the array right by 1 unit modifies the array to {3, 1}. Deleting the array element modifies the array to {3}.
Therefore, the last remaining element is 3.
Input: N = 5, arr[] = {1, 2, 3, 4, 5}, X = 2
Output: 3
Naive Approach: The simplest approach to solve the given problem is to push all the numbers of the range [1, N] in a deque and perform the given operations (N – 1) times according to the given value of X and then print the last remaining element.
Time Complexity: O(N)
Auxiliary Space: O(1)
Efficient Approach: The given problem can be optimized based on the following observations:
- If the value of X is 1, then the last left element will be the difference between the smallest power of 2 greater N and N.
- If the value of X is 2, then the last left element will be 2*(N – D) + 1, where D represents the largest power of 2 less than or equal to N.
Follow the steps below to solve the problem:
- Store the power of 2 greater than N in a variable, say nextPower.
- If the value of X is 1, then print the value (nextPower – N) as the result.
- Otherwise, print the value 2*(N – nextPower / 2) + 1 as the result.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include <bits/stdc++.h> using namespace std; // Function to find the last element // left after performing N - 1 queries // of type X int rotate( int arr[], int N, int X) { // Stores the next power of 2 long long int nextPower = 1; // Iterate until nextPower is at most N while (nextPower <= N) nextPower *= 2; // If X is equal to 1 if (X == 1) return nextPower - N; // Stores the power of 2 less than or // equal to N long long int prevPower = nextPower / 2; // Return the final value return 2 * (N - prevPower) + 1; } // Driver Code int main() { int arr[] = { 1, 2, 3, 4, 5 }; int X = 1; int N = sizeof (arr) / sizeof (arr[0]); cout << rotate(arr, N, X); return 0; } |
Java
// Java program for the above approach import java.io.*; class GFG { // Function to find the last element // left after performing N - 1 queries // of type X static int rotate( int arr[], int N, int X) { // Stores the next power of 2 long nextPower = 1 ; // Iterate until nextPower is at most N while (nextPower <= N) nextPower *= 2 ; // If X is equal to 1 if (X == 1 ) return ( int ) nextPower - N; // Stores the power of 2 less than or // equal to N long prevPower = nextPower / 2 ; // Return the final value return 2 * (N - ( int )prevPower) + 1 ; } // Driver Code public static void main (String[] args) { int arr[] = { 1 , 2 , 3 , 4 , 5 }; int X = 1 ; int N =arr.length; System.out.println(rotate(arr, N, X)); } } // This code is contributed by Potta Lokesh |
Python3
# Python3 program for the above approach # Function to find the last element # left after performing N - 1 queries # of type X def rotate(arr, N, X): # Stores the next power of 2 nextPower = 1 # Iterate until nextPower is at most N while (nextPower < = N): nextPower * = 2 # If X is equal to 1 if (X = = 1 ): ans = nextPower - N return ans # Stores the power of 2 less than or # equal to N prevPower = nextPower / / 2 # Return the final value return 2 * (N - prevPower) + 1 # Driver Code arr = [ 1 , 2 , 3 , 4 , 5 ] X = 1 N = len (arr) print (rotate(arr, N, X)) # This code is contributed by amreshkumar3. |
C#
// C# program for the above approach using System; using System.Collections.Generic; class GFG{ // Function to find the last element // left after performing N - 1 queries // of type X static int rotate( int []arr, int N, int X) { // Stores the next power of 2 int nextPower = 1; // Iterate until nextPower is at most N while (nextPower <= N) nextPower *= 2; // If X is equal to 1 if (X == 1) return nextPower - N; // Stores the power of 2 less than or // equal to N int prevPower = nextPower / 2; // Return the final value return 2 * (N - prevPower) + 1; } // Driver Code public static void Main() { int []arr = { 1, 2, 3, 4, 5 }; int X = 1; int N = arr.Length; Console.Write(rotate(arr, N, X)); } } // This code is contributed by SURENDRA_GANGWAR |
Javascript
<script> // JavaScript program for the above approach // Function to find the last element // left after performing N - 1 queries // of type X function rotate(arr, N, X) { // Stores the next power of 2 let nextPower = 1; // Iterate until nextPower is at most N while (nextPower <= N) nextPower *= 2; // If X is equal to 1 if (X == 1) return nextPower - N; // Stores the power of 2 less than or // equal to N let prevPower = nextPower / 2; // Return the final value return 2 * (N - prevPower) + 1; } // Driver Code let arr = [1, 2, 3, 4, 5]; let X = 1; let N = arr.length; document.write(rotate(arr, N, X)); // This code is contributed by Potta Lokesh </script> |
3
Time Complexity: O(log N)
Auxiliary Space: O(1)