Javascript Program to Find Mth element after K Right Rotations of an Array

Given non-negative integers K, M, and an array arr[ ] consisting of N elements, the task is to find the M^th element of the array after K right rotations.

Examples: 

Input: arr[] = {3, 4, 5, 23}, K = 2, M = 1 
Output: 5 
Explanation: 
The array after first right rotation a1[ ] = {23, 3, 4, 5} 
The array after second right rotation a2[ ] = {5, 23, 3, 4} 
1st element after 2 right rotations is 5.
Input: arr[] = {1, 2, 3, 4, 5}, K = 3, M = 2 
Output: 4 
Explanation: 
The array after 3 right rotations has 4 at its second position. 

Naive Approach: 
The simplest approach to solve the problem is to Perform Right Rotation operation K times and then find the M^th element of the final array.

Algorithm:

1.    Define a function named leftrotate that takes a reference to a vector of integers v and an integer d as input parameters.
2.    Reverse the first d elements of the vector v.
3.    Reverse the remaining elements of the vector v starting from index d to the end.
4.    Reverse the entire vector v.
5.    Define a function named rightrotate that takes a reference to a vector of integers v and an integer d as input parameters.
6.    Call the leftrotate function with the vector v and the length of the vector minus d as input parameters.
7.    Define a function named getFirstElement that takes an array of integers a, its size N, an integer K and an integer M as input parameters.
8.    Declare a vector of integers v.
9.    Add all the elements of the array a to the vector v.
10.    Loop K times.
11.    Call the rightrotate function with the vector v and 1 as input parameters.
12.    Return the Mth element of the vector v minus 1 as the output of the function.
13.    In the main function, define an array of integers a, its size N, an integer K, and an integer M.
14.    Initialize the values of the array a, N, K, and M.
15.    Call the getFirstElement function with the array a, N, K, and M as input parameters and print its output.

Below is the implementation of the approach: 

// JavaScript program to find the Mth element
// of the array after K right rotations.

// Function to left rotate the array by d
function leftrotate(arr, d) {
    arr.push.apply(arr, arr.splice(0, d));
}

// Function to right rotate the array by d
function rightrotate(arr, d) {
    leftrotate(arr, arr.length - d);
}

// Function to return Mth element of
// array after K right rotations
function getFirstElement(arr, N, K, M) {
    let v = [];
    for (let i = 0; i < N; i++)
        v.push(arr[i]);

    // Right rotate K times
    while (K--) {
        rightrotate(v, 1);
    }

    // return Mth element
    return v[M - 1];
}

// Driver code
let a = [ 1, 2, 3, 4, 5 ];
let N = a.length;
let K = 3, M = 2;

// Function call
console.log(getFirstElement(a, N, K, M));

4

Time Complexity: O(N * K) 
Auxiliary Space: O(N)
Efficient Approach: 
To optimize the problem, the following observations need to be made: 

• If the array is rotated N times it returns the initial array again.

 For example, a[ ] = {1, 2, 3, 4, 5}, K=5 
Modified array after 5 right rotation a₅[ ] = {1, 2, 3, 4, 5}.  

• Therefore, the elements in the array after K^th rotation is the same as the element at index K%N in the original array.
• If K >= M, the Mth element of the array after K right rotations is 
   

 { (N-K) + (M-1) } ^th element in the original array.  

• If K < M, the Mth element of the array after K right rotations is: 
   

 (M - K - 1) th  element in the original array.  

Below is the implementation of the above approach:

// C++ program to implement
// the above approach
#include <iostream>
using namespace std;

// Function to return Mth element of
// array after k right rotations
int getFirstElement(int a[], int N, int K, int M)
{
  
    // The array comes to original state
    // after N rotations
    K %= N;
    int index;

    // If K is greater or equal to M
    if (K >= M)

        // Mth element after k right
        // rotations is (N-K)+(M-1) th
        // element of the array
        index = (N - K) + (M - 1);

    // Otherwise
    else

        // (M - K - 1) th element
        // of the array
        index = (M - K - 1);

    int result = a[index];

    // Return the result
    return result;
}
int main()
{
    int a[] = { 1, 2, 3, 4, 5 };
    int N = 5;
    int K = 3, M = 2;
    cout << getFirstElement(a, N, K, M);
    return 0;
}

// This code is contributed by nmkiniqw7b.

// Java program to implement
// the above approach
class GFG {

  // Function to return Mth element of
  // array after k right rotations
  static int getFirstElement(int a[], int N, int K, int M)
  {
    // The array comes to original state
    // after N rotations
    K %= N;
    int index;

    // If K is greater or equal to M
    if (K >= M)

      // Mth element after k right
      // rotations is (N-K)+(M-1) th
      // element of the array
      index = (N - K) + (M - 1);

    // Otherwise
    else

      // (M - K - 1) th element
      // of the array
      index = (M - K - 1);

    int result = a[index];

    // Return the result
    return result;
  }

  // Driver Code
  public static void main(String[] args)
  {
    int a[] = { 1, 2, 3, 4, 5 };
    int N = 5;
    int K = 3, M = 2;

    System.out.println(getFirstElement(a, N, K, M));
  }
}

// This code is contributed by nmkiniqw7b.

# python program to implement
# the above approach
# Function to return Mth element of
# array after k right rotations
def getFirstElement(a, N, K, M):
  
    # The array comes to original state
    # after N rotations
    K %= N
    
    # If K is greater or equal to M
    if(K >= M):
      
        # Mth element after k right rotations
        index = (N - K) + (M - 1)
    # otherwise
    else:
        # (M - K - 1) th element
        # of the array
        index = (M - K - 1)
    result = a[index]
    return result

# driver code
a = [1, 2, 3, 4, 5]
N = 5
K = 3
M = 2
print(getFirstElement(a, N, K, M))

# This code is contributed by nmkiniqw7b.

<script>
// JavaScript program to implement 
// the approach

// Function to return Mth element of
// array after k right rotations
function getFirstElement(a, N,
                           K, M)
{
    // The array comes to original state
    // after N rotations
    K %= N;
    let index;
   
    // If K is greater or equal to M
    if (K >= M)
   
        // Mth element after k right
        // rotations is (N-K)+(M-1) th
        // element of the array
        index = (N - K) + (M - 1);
   
    // Otherwise
    else
   
        // (M - K - 1) th element
        // of the array
        index = (M - K - 1);
   
    let result = a[index];
   
    // Return the result
    return result;
} 

// Driver Code    
    
    let a = [ 1, 2, 3, 4, 5 ]; 
     
    let N = 5; 
     
    let K = 3, M = 2; 
     
    document.write(getFirstElement(a, N, K, M)); 
                              
</script>

// C# program to implement
// the above approach

using System;

public class GFG
{
    // Function to return Mth element of
    // array after k right rotations
    public static int GetFirstElement(int[] a, int N, int K, int M)
    {
        // The array comes to original state
        // after N rotations
        K %= N;
        int index;

        // If K is greater or equal to M
        if (K >= M)
        {
            // Mth element after k right
            // rotations is (N-K)+(M-1) th
            // element of the array
            index = (N - K) + (M - 1);
        }
        else
        {
            // (M - K - 1) th element
            // of the array
            index = (M - K - 1);
        }

        int result = a[index];

        // Return the result
        return result;
    }

    public static void Main()
    {
        int[] a = { 1, 2, 3, 4, 5 };
        int N = 5;
        int K = 3;
        int M = 2;
        Console.WriteLine(GetFirstElement(a, N, K, M));
    }
}

4

Time complexity: O(1) 
Auxiliary Space: O(1)
 

Please refer complete article on Mth element after K Right Rotations of an Array for more details!