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:
- 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.
- 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
#include<bits/stdc++.h>
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<k)
{
// Printing rightmost
// kth elements
System.out.print(a[n + i - k]
+ " ");
}
else
{
// Prints array after
// 'k' elements
System.out.print(a[i - k]
+ " ");
}
}
System.out.println();
}
// Driver program
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 M Vamshi Krishna
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("<br>");
}
// 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
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 <iostream>
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 <stdio.h>
// 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).
Approach 3: Recursive Approach
Here is the step-by-step algorithm .
- "rotateArray" function will take an array "arr" , it's size is "n" and the number of rotations "k" as an input.
- To reduce the number of rotations, we compute 'k' modulo 'n' ( k%=n) .
- Using the STL library's "reverse" function, reverse the first portion of the array from the start up to the "n - k" index.
- Using the "reverse" function from the STL library, reverse the second part of the array from the "n - k" index to the end.
- To get the rotated array, reverse the entire array using the "reverse" function in the STL library.
- 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 = 2rotateArray(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 <iostream>
// Function to rotate the array
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
int 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 <stdio.h>
// Function to rotate the array
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
int 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 array
def 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 code
if __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 array
function 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 code
const arr = [1, 3, 5, 7, 9];
const k = 2;
rotateArray(arr, k);
console.log(arr.join(' '));
Output
7 9 1 3 5
Method to Print array after it is right rotated K times:
C++
#include <iostream>
#include <vector>
using namespace std;
// Function to calculate the greatest common divisor (GCD) using Euclid's algorithm
int gcd(int a, int b) {
// Keep dividing until b becomes 0
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
// 'a' holds the GCD
return a;
}
// Function to rotate the array 'nums' by 'k' positions to the right
vector<int> rotate_array(vector<int>& nums, int k) {
int n = nums.size();
k = k % n; // Handle cases where k is larger than the length of the array
if (k == 0) {
return nums; // If k is 0, no rotation needed
}
// Calculate the number of cycles based on the GCD of 'n' and 'k'
int cycles = gcd(n, k);
// Perform rotation for each cycle
for (int i = 0; i < cycles; ++i) {
int start = i; // Start index of the current cycle
int current = start; // Current index being processed
int prev = nums[start]; // Store the value to be replaced
while (true) {
// Calculate the next index after rotation
int next_idx = (current + k) % n;
// Swap the values and update 'prev' with the replaced value
int temp = nums[next_idx];
nums[next_idx] = prev;
prev = temp;
// Update 'current' to the next index
current = next_idx;
// Break if the cycle completes (back to the start index)
if (current == start) {
break;
}
}
}
return nums; // Return the rotated array
}
// Driver code
int main() {
vector<int> nums = {1, 2, 3, 4, 5, 6};
int k = 4;
// Rotate the array 'nums' by 'k' positions
vector<int> rotated_nums = rotate_array(nums, k);
// Print the rotated array
for (int num : rotated_nums) {
cout << num << " ";
}
return 0;
}
Python3
import math
def rotate_array(nums, k):
n = len(nums)
k = k % n # handle cases where k is larger than the length of the array
if k == 0:
return nums
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
cycles = gcd(n, k)
for i in range(cycles):
start = i
current = start
prev = nums[start]
while True:
next_idx = (current + k) % n
nums[next_idx], prev = prev, nums[next_idx]
current = next_idx
if current == start:
break
return nums
# Example usage:
nums = [1, 2, 3, 4, 5, 6]
k = 4
rotated_nums = rotate_array(nums, k)
print(rotated_nums)
Output
[3, 4, 5, 6, 1, 2]
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/amp/