Open in App
Not now

Print array after it is right rotated K times

• Difficulty Level : Easy
• Last Updated : 07 Dec, 2022

Given an Array of size N and a values K, around which we need to right rotate the array. How to 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 mod of K by N (K = K % N) because after every N rotation 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 rightmost Kth element (a[N + i -K]). Otherwise,

• Print 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` `#include` `using` `namespace` `std;`   `// Function to rightRotate array` `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` `           ``cout << a[n + i - k] << ``" "``;` `       ``}` `       ``else` `       ``{` `           `  `           ``// Prints array after` `           ``// 'k' elements` `           ``cout << (a[i - k]) << ``" "``;` `       ``}` `    ``}` `    ``cout << ``"\n"``;` `}` `    `  `// Driver code` `int` `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 times` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;`   `class` `Array_Rotation` `{`   `// Function to rightRotate array` `static` `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 array` `def` `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 code` `Array ``=` `[ ``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 times` `using` `System;` `class` `GFG{`   `// Function to rightRotate array` `static` `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 code` `public` `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 array` `function` `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 code` `let 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

Approach: 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.

Code:

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 times` `import` `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 times` `using` `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).

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/

My Personal Notes arrow_drop_up
Related Articles