# Print array after it is right rotated K times

Given an Array of size N and a value K, around which we need to right rotate the array. How do you quickly print the right rotated array?
Examples :

Input: Array[] = {1, 3, 5, 7, 9}, K = 2.
Output: 7 9 1 3 5
Explanation:
After 1st rotation – {9, 1, 3, 5, 7}After 2nd rotation – {7, 9, 1, 3, 5}

Input: Array[] = {1, 2, 3, 4, 5}, K = 4.
Output: 2 3 4 5 1

### Approach:

1. We will first take the mod of K by N (K = K % N) because, after every N rotation, the array will become the same as the initial array.
2. Now, we will iterate the array from i = 0 to i = N-1 and check,
• If i < K, Print the rightmost Kth element (a[N + i -K]).
• Otherwise, Print the array after ‘K’ elements (a[i – K]).

Below is the implementation of the above approach.

## C++

 // C++ implementation of right rotation // of an array K number of times#includeusing namespace std; // Function to rightRotate arrayvoid RightRotate(int a[], int n, int k){         // If rotation is greater     // than size of array    k = k % n;     for(int i = 0; i < n; i++)    {       if(i < k)       {                       // Printing rightmost            // kth elements           cout << a[n + i - k] << " ";       }       else       {                       // Prints array after           // 'k' elements           cout << (a[i - k]) << " ";       }    }    cout << "\n";}     // Driver codeint main(){    int Array[] = { 1, 2, 3, 4, 5 };    int N = sizeof(Array) / sizeof(Array[0]);    int K = 2;         RightRotate(Array, N, K);} // This code is contributed by Surendra_Gangwar

## Java

 // Java Implementation of Right Rotation // of an Array K number of timesimport java.util.*;import java.lang.*;import java.io.*; class Array_Rotation{ // Function to rightRotate arraystatic void RightRotate(int a[],                         int n, int k){         // If rotation is greater     // than size of array    k=k%n;     for(int i = 0; i < n; i++)    {        if(i

## Python3

 # Python3 implementation of right rotation # of an array K number of times # Function to rightRotate arraydef RightRotate(a, n, k):     # If rotation is greater     # than size of array    k = k % n;     for i in range(0, n):         if(i < k):             # Printing rightmost             # kth elements            print(a[n + i - k], end = " ");         else:             # Prints array after            # 'k' elements            print(a[i - k], end = " ");     print("\n"); # Driver codeArray = [ 1, 2, 3, 4, 5 ];N = len(Array);K = 2;     RightRotate(Array, N, K); # This code is contributed by Code_Mech

## C#

 // C# implementation of right rotation // of an array K number of timesusing System;class GFG{ // Function to rightRotate arraystatic void RightRotate(int []a,                         int n, int k){     // If rotation is greater     // than size of array    k = k % n;     for(int i = 0; i < n; i++)    {       if(i < k)       {                       // Printing rightmost            // kth elements           Console.Write(a[n + i - k] + " ");       }       else       {                       // Prints array after           // 'k' elements           Console.Write(a[i - k] + " ");       }    }    Console.WriteLine();}     // Driver codepublic static void Main(String []args){    int []Array = { 1, 2, 3, 4, 5 };    int N = Array.Length;    int K = 2;         RightRotate(Array, N, K);}} // This code is contributed by Rohit_ranjan

## Javascript

 // Javascript implementation of right rotation// of an array K number of times // Function to rightRotate arrayfunction RightRotate(a, n, k){     // If rotation is greater    // than size of array    k = k % n;     for (let i = 0; i < n; i++) {        if (i < k) {             // Printing rightmost            // kth elements            document.write(a[n + i - k] + " ");        }        else {             // Prints array after            // 'k' elements            document.write((a[i - k]) + " ");        }    }    document.write("
");} // Driver codelet Array = [1, 2, 3, 4, 5];let N = Array.length;let K = 2; RightRotate(Array, N, K); // This code is contributed by gfgking.

Output
4 5 1 2 3

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

## Method 2: Reversing the array

The approach is simple yet optimized. The idea is to reverse the array three times. For the first time we reverse only the last k elements. Second time we will reverse first n-k(n=size of array) elements. Finally we will get our rotated array by reversing the entire array.

Below is the implementation of the above approach:

## C++

 // C++ program to rotate right an array  by K times#include using namespace std;int main(){    int arr[] = { 1, 3, 5, 7, 9, 11 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 3; //No. of rotations    k = k % n;    int i, j;    // Reverse last k numbers    for (i = n - k, j = n - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }    // Reverse the first n-k terms    for (i = 0, j = n - k - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }    // Reverse the entire array    for (i = 0, j = n - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }     // Print the rotated array    for (int i = 0; i < n; i++) {        cout << arr[i] << " ";    }     return 0;}

## C

 // C program to rotate right an array  by K times#include // using namespace std;int main(){    int arr[] = { 1, 3, 5, 7, 9, 11 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 3; //No. of rotations    k = k % n;    int i, j;    // Reverse last k numbers    for (i = n - k, j = n - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }    // Reverse the first n-k terms    for (i = 0, j = n - k - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }    // Reverse the entire array    for (i = 0, j = n - 1; i < j; i++, j--) {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }     // Print the rotated array    for (int i = 0; i < n; i++) {        printf("%d ", arr[i]);    }     return 0;}

## Java

 // JAVA program to rotate right an array  by K timesimport java.io.*;class GFG {    public static void main(String[] args)    {        int arr[] = new int[] { 1, 3, 5, 7, 9, 11 };        int n = arr.length;        int k = 3; // No. of rotations        k = k % n;        int i, j;        // Reverse last k numbers        for (i = n - k, j = n - 1; i < j; i++, j--) {            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;        }        // Reverse the first n-k terms        for (i = 0, j = n - k - 1; i < j; i++, j--) {            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;        }        // Reverse the entire array        for (i = 0, j = n - 1; i < j; i++, j--) {            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;        }         // Print the rotated array        for (int t = 0; t < n; t++) {            System.out.print(arr[t] + " ");        }    }} // This code is contributed by Taranpreet

## Python3

 class GFG :    @staticmethod    def main( args) :        arr = [1, 3, 5, 7, 9, 11]        n = len(arr)        k = 3        # No. of rotations        k = k % n        i = 0        j = 0        # Reverse last k numbers        i = n - k        j = n - 1        while (i < j) :            temp = arr[i]            arr[i] = arr[j]            arr[j] = temp            i += 1            j -= 1        # Reverse the first n-k terms        i = 0        j = n - k - 1        while (i < j) :            temp = arr[i]            arr[i] = arr[j]            arr[j] = temp            i += 1            j -= 1        # Reverse the entire array        i = 0        j = n - 1        while (i < j) :            temp = arr[i]            arr[i] = arr[j]            arr[j] = temp            i += 1            j -= 1        # Print the rotated array        t = 0        while (t < n) :            print(str(arr[t]) + " ", end ="")            t += 1      if __name__=="__main__":    GFG.main([])         # This code is contributed by aadityaburujwale.

## C#

 // C# program to rotate right an array by K timesusing System; public class GFG{  public static void Main(String []args)  {    int []arr = { 1, 3, 5, 7, 9, 11 };    int n = arr.Length;    int k = 3; // No. of rotations    k = k % n;    int i, j;     // Reverse last k numbers    for (i = n - k, j = n - 1; i < j; i++, j--) {      int temp = arr[i];      arr[i] = arr[j];      arr[j] = temp;    }    // Reverse the first n-k terms    for (i = 0, j = n - k - 1; i < j; i++, j--) {      int temp = arr[i];      arr[i] = arr[j];      arr[j] = temp;    }    // Reverse the entire array    for (i = 0, j = n - 1; i < j; i++, j--) {      int temp = arr[i];      arr[i] = arr[j];      arr[j] = temp;    }     // Print the rotated array    for (int t = 0; t < n; t++) {      Console.Write(arr[t] + " ");    }  }} // This code is contributed by Pushpesh Raj.

## Javascript

 // Javascript program to rotate right an array by K times    let arr = [ 1, 3, 5, 7, 9, 11 ];    let n = arr.length;    let k = 3; //No. of rotations    k = k % n;    let i, j;         // Reverse last k numbers    for (i = n - k, j = n - 1; i < j; i++, j--) {        let temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }         // Reverse the first n-k terms    for (i = 0, j = n - k - 1; i < j; i++, j--) {        let temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }    // Reverse the entire array    for (i = 0, j = n - 1; i < j; i++, j--) {        let temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }     // Print the rotated array    for (let i = 0; i < n; i++) {        console.log(arr[i]+ " ");    }     // This code is contributed by Aman Kumar

Output
7 9 11 1 3 5

Complexity Analysis:

Time Complexity: O(N).
Auxiliary Space: O(1).

### Approach 3: Recursive Approach

Here is the step-by-step algorithm .

1. “rotateArray” function will take an array “arr” ,  it’s size is “n”  and the number of rotations “k” as an input.
2.  To reduce the number of rotations, we compute ‘k’ modulo ‘n’ ( k%=n) .
3. Using the STL library’s “reverse” function, reverse the first portion of the array from the start up to the “n – k” index.
4. Using the “reverse” function from the STL library, reverse the second part of the array from the “n – k” index to the end.
5. To get the rotated array, reverse the entire array using the “reverse” function in the STL library.
6. Then ,we’ll return the rotated array.

### Here is the pseudocode for the above algorithm:

function rotateArray(arr, n, k):
// Reduce the number of rotations
k = k % n

// Reverse the first part of the array
reverse(arr, arr + n – k)

// Reverse the second part of the array
reverse(arr + n – k, arr + n)

// Reverse the entire array
reverse(arr, arr + n)

// Driver code
arr = {1, 3, 5, 7, 9}
n = size(arr)
k = 2

rotateArray(arr, n, k)

for i = 0 to n-1:
print arr[i]

// This  is contributed by  Vaibhav Saroj

Below is the implementation of above approach:

## C++

 #include  // Function to rotate the arrayvoid rotateArray(int arr[], int n, int k) {    if (k == 0) {        return;    }     // rotate the array to the right by one position    int temp = arr[n - 1];    for (int i = n - 1; i > 0; i--) {        arr[i] = arr[i - 1];    }    arr[0] = temp;     // recursively rotate the remaining elements k-1 times    rotateArray(arr, n, k - 1);} // Driver codeint main() {    int arr[] = {1, 3, 5, 7, 9};    int n = sizeof(arr) / sizeof(arr[0]);    int k = 2;     rotateArray(arr, n, k);     for (int i = 0; i < n; i++) {        std::cout << arr[i] << " ";    }    std::cout << std::endl;     return 0;}

## C

 #include  // Function to rotate the arrayvoid rotateArray(int arr[], int n, int k) {    if (k == 0) {        return;    }     // rotate the array to the right by one position    int temp = arr[n-1];    for (int i = n-1; i > 0; i--) {        arr[i] = arr[i-1];    }    arr[0] = temp;     // recursively rotate the remaining elements k-1 times    rotateArray(arr, n, k-1);} // Driver codeint main() {    int arr[] = {1, 3, 5, 7, 9};    int n = sizeof(arr)/sizeof(arr[0]);    int k = 2;     rotateArray(arr, n, k);     for (int i = 0; i < n; i++) {        printf("%d ", arr[i]);    }    printf("\n");     return 0;} // This code is contributed by  Vaibhav Saroj

## Java

 public class RotateArray {     // Function to rotate the array    static void rotateArray(int[] arr, int n, int k) {        if (k == 0) {            return;        }         // Rotate the array to the right by one position        int temp = arr[n - 1];        for (int i = n - 1; i > 0; i--) {            arr[i] = arr[i - 1];        }        arr[0] = temp;         // Recursively rotate the remaining elements k-1 times        rotateArray(arr, n, k - 1);    }     // Driver code    public static void main(String[] args) {        int[] arr = {1, 3, 5, 7, 9};        int n = arr.length;        int k = 2;         rotateArray(arr, n, k);         // Print the rotated array        for (int i = 0; i < n; i++) {            System.out.print(arr[i] + " ");        }        System.out.println();    }}

## Python3

 # Function to rotate the arraydef rotate_array(arr, n, k):    if k == 0:        return     # Rotate the array to the right by one position    temp = arr[n - 1]    for i in range(n - 1, 0, -1):        arr[i] = arr[i - 1]    arr[0] = temp     # Recursively rotate the remaining elements k-1 times    rotate_array(arr, n, k - 1) # Driver codeif __name__ == "__main__":    arr = [1, 3, 5, 7, 9]    n = len(arr)    k = 2     rotate_array(arr, n, k)     for i in range(n):        print(arr[i], end=" ")    print()#This code is contribuited by utkarsh

## C#

 using System; class MainClass {    // Function to rotate the array    static void RotateArray(int[] arr, int n, int k)    {        if (k == 0) {            return;        }         // Rotate the array to the right by one position        int temp = arr[n - 1];        for (int i = n - 1; i > 0; i--) {            arr[i] = arr[i - 1];        }        arr[0] = temp;         // Recursively rotate the remaining elements k-1        // times        RotateArray(arr, n, k - 1);    }     // Driver code    public static void Main(string[] args)    {        int[] arr = { 1, 3, 5, 7, 9 };        int n = arr.Length;        int k = 2;         RotateArray(arr, n, k);         for (int i = 0; i < n; i++) {            Console.Write(arr[i] + " ");        }        Console.WriteLine();    }}

## Javascript

 // Function to rotate the arrayfunction rotateArray(arr, k) {    const n = arr.length;    if (k === 0) {        return;    }     // Rotate the array to the right by one position    const temp = arr[n - 1];    for (let i = n - 1; i > 0; i--) {        arr[i] = arr[i - 1];    }    arr[0] = temp;     // Recursively rotate the remaining elements k-1 times    rotateArray(arr, k - 1);} // Driver codeconst arr = [1, 3, 5, 7, 9];const k = 2; rotateArray(arr, k); console.log(arr.join(' '));

Output
7 9 1 3 5

Time Complexity: O(N).
Auxiliary Space: O(1).

Please see following posts for other methods of array rotation: https://www.geeksforgeeks.org/print-array-after-it-is-right-rotated-k-times-set-2/

Previous
Next