# Program for array rotation

## Program for array rotation

Write a function rotate(ar[], d, n) that rotates arr[] of size n by d elements.

Rotation of the above array by 2 will make array

METHOD 1 (Using temp array)

```Input arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2, n =7
1) Store the first d elements in a temp array
temp[] = [1, 2]
2) Shift rest of the arr[]
arr[] = [3, 4, 5, 6, 7, 6, 7]
3) Store back the d elements
arr[] = [3, 4, 5, 6, 7, 1, 2]```

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

METHOD 2 (Rotate one by one)

```leftRotate(arr[], d, n)
start
For i = 0 to i < d
Left rotate all elements of arr[] by one
end```

To rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[2] to arr[1] …and finally temp to arr[n-1]
Let us take the same example arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2
Rotate arr[] by one 2 times
We get [2, 3, 4, 5, 6, 7, 1] after first rotation and [ 3, 4, 5, 6, 7, 1, 2] after second rotation.
Below is the implementation of the above approach :
[tabby title=”C++”]

```// C++ program to rotate an array by
// d elements
#include <bits/stdc++.h>
using namespace std;

/*Function to left Rotate arr[] of
size n by 1*/
void leftRotatebyOne(int arr[], int n)
{
int temp = arr[0], i;
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];

arr[n-1] = temp;
}

/*Function to left rotate arr[] of size n by d*/
void leftRotate(int arr[], int d, int n)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}

/* utility function to print an array */
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}

/* Driver program to test above functions */
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof(arr) / sizeof(arr[0]);

// Function calling
leftRotate(arr, 2, n);
printArray(arr, n);

return 0;
}
```

[tabby title=”C”]

```// C program to rotate an array by
// d elements
#include <stdio.h>

/* Function to left Rotate arr[] of size n by 1*/
void leftRotatebyOne(int arr[], int n);

/*Function to left rotate arr[] of size n by d*/
void leftRotate(int arr[], int d, int n)
{
int i;
for (i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}

void leftRotatebyOne(int arr[], int n)
{
int temp = arr[0], i;
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n-1] = temp;
}

/* utility function to print an array */
void printArray(int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", arr[i]);
}

/* Driver program to test above functions */
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
return 0;
}
```

[tabby title=”Java”]

```// Java program to rotate an array by
// d elements

class RotateArray {
/*Function to left rotate arr[] of size n by d*/
void leftRotate(int arr[], int d, int n)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}

void leftRotatebyOne(int arr[], int n)
{
int i, temp;
temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n-1] = temp;
}

/* utility function to print an array */
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
System.out.print(arr[i] + " ");
}

// Driver program to test above functions
public static void main(String[] args)
{
RotateArray rotate = new RotateArray();
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
rotate.leftRotate(arr, 2, 7);
rotate.printArray(arr, 7);
}
}

// This code has been contributed by Mayank Jaiswal
```

[tabby title=”Python3″]

```# Python3 program to rotate an array by
# d elements
# Function to left rotate arr[] of size n by d*/
def leftRotate(arr, d, n):
for i in range(d):
leftRotatebyOne(arr, n)

# Function to left Rotate arr[] of size n by 1*/
def leftRotatebyOne(arr, n):
temp = arr[0]
for i in range(n-1):
arr[i] = arr[i + 1]
arr[n-1] = temp

# utility function to print an array */
def printArray(arr, size):
for i in range(size):
print ("% d"% arr[i], end =" ")

# Driver program to test above functions */
arr = [1, 2, 3, 4, 5, 6, 7]
leftRotate(arr, 2, 7)
printArray(arr, 7)

# This code is contributed by Shreyanshi Arun
```

[tabby title=”C#”]

```// C# program for array rotation
using System;

class GFG {
/* Function to left rotate arr[]
of size n by d*/
static void leftRotate(int[] arr, int d,
int n)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}

static void leftRotatebyOne(int[] arr, int n)
{
int i, temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];

arr[n-1] = temp;
}

/* utility function to print an array */
static void printArray(int[] arr, int size)
{
for (int i = 0; i < size; i++)
Console.Write(arr[i] + " ");
}

// Driver code
public static void Main()
{
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}

// This code is contributed by Sam007
```

[tabby title=”PHP”]

```<?php
// PHP program to rotate an array
// by d elements

/*Function to left Rotate arr[]
of size n by 1*/
function leftRotatebyOne(&\$arr, \$n)
{
\$temp = \$arr[0];
for (\$i = 0; \$i < \$n - 1; \$i++)
\$arr[\$i] = \$arr[\$i + 1];

\$arr[\$n-1] = \$temp;
}

/*Function to left rotate arr[]
of size n by d*/
function leftRotate(&\$arr, \$d, \$n)
{
for (\$i = 0; \$i < \$d; \$i++)
leftRotatebyOne(\$arr, \$n);
}

/* utility function to print
an array */
function printArray(&\$arr, \$n)
{
for (\$i = 0; \$i < \$n; \$i++)
echo \$arr[\$i] . " ";
}

// Driver Code
\$arr = array( 1, 2, 3, 4, 5, 6, 7 );
\$n = sizeof(\$arr);

// Function calling
leftRotate(\$arr, 2, \$n);
printArray(\$arr, \$n);

// This code is contributed
// by ChitraNayal
?>

```

[tabby title=”Javascript”]

```<script>

// JavaScript program to rotate an array by
// d elements

/* Function to left rotate arr of size n by d */
function leftRotate(arr , d , n) {
for (i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}

function leftRotatebyOne(arr , n) {
var i, temp;
temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n - 1] = temp;
}

/* utility function to print an array */
function printArray(arr , n) {
for (i = 0; i < n; i++)
document.write(arr[i] + " ");
}

// Driver program to test above functions

var arr = [ 1, 2, 3, 4, 5, 6, 7 ];
leftRotate(arr, 2, 7);
printArray(arr, 7);

// This code is contributed by todaysgaurav

</script>
```

[tabbyending]

Output :

`3 4 5 6 7 1 2`

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

METHOD 3 (A Juggling Algorithm)
This is an extension of method 2. Instead of moving one by one, divide the array in different sets
where number of sets is equal to GCD of n and d and move the elements within sets.
If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
Here is an example for n =12 and d = 3. GCD is 3 and

```Let arr[] be {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

a) Elements are first moved in first set – (See below
diagram for this movement)```

```          arr[] after this step --> {4 2 3 7 5 6 10 8 9 1 11 12}

b)    Then in second set.
arr[] after this step --> {4 5 3 7 8 6 10 11 9 1 2 12}

c)    Finally in third set.
arr[] after this step --> {4 5 6 7 8 9 10 11 12 1 2 3}```

Below is the implementation of the above approach :
[tabby title=”C++”]

```// C++ program to rotate an array by
// d elements
#include <bits/stdc++.h>
using namespace std;

/*Function to get gcd of a and b*/
int gcd(int a, int b)
{
if (b == 0)
return a;

else
return gcd(b, a % b);
}

/*Function to left rotate arr[] of siz n by d*/
void leftRotate(int arr[], int d, int n)
{
/* To handle if d >= n */
d = d % n;
int g_c_d = gcd(d, n);
for (int i = 0; i < g_c_d; i++) {
/* move i-th values of blocks */
int temp = arr[i];
int j = i;

while (1) {
int k = j + d;
if (k >= n)
k = k - n;

if (k == i)
break;

arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}

// Function to print an array
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
cout << arr[i] << " ";
}

/* Driver program to test above functions */
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof(arr) / sizeof(arr[0]);

// Function calling
leftRotate(arr, 2, n);
printArray(arr, n);

return 0;
}
```

[tabby title=”C”]

```// C program to rotate an array by
// d elements
#include <stdio.h>

/* function to print an array */
void printArray(int arr[], int size);

/*Fuction to get gcd of a and b*/
int gcd(int a, int b);

/*Function to left rotate arr[] of siz n by d*/
void leftRotate(int arr[], int d, int n)
{
int i, j, k, temp;
/* To handle if d >= n */
d = d % n;
int g_c_d = gcd(d, n);
for (i = 0; i < g_c_d; i++) {
/* move i-th values of blocks */
temp = arr[i];
j = i;
while (1) {
k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}

/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", arr[i]);
}

/*Fuction to get gcd of a and b*/
int gcd(int a, int b)
{
if (b == 0)
return a;
else
return gcd(b, a % b);
}

/* Driver program to test above functions */
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar();
return 0;
}
```

[tabby title=”Java”]

```// Java program to rotate an array by
// d elements
class RotateArray {
/*Function to left rotate arr[] of siz n by d*/
void leftRotate(int arr[], int d, int n)
{
/* To handle if d >= n */
d = d % n;
int i, j, k, temp;
int g_c_d = gcd(d, n);
for (i = 0; i < g_c_d; i++) {
/* move i-th values of blocks */
temp = arr[i];
j = i;
while (true) {
k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}

/*UTILITY FUNCTIONS*/

/* function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
System.out.print(arr[i] + " ");
}

/*Fuction to get gcd of a and b*/
int gcd(int a, int b)
{
if (b == 0)
return a;
else
return gcd(b, a % b);
}

// Driver program to test above functions
public static void main(String[] args)
{
RotateArray rotate = new RotateArray();
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
rotate.leftRotate(arr, 2, 7);
rotate.printArray(arr, 7);
}
}

// This code has been contributed by Mayank Jaiswal
```

[tabby title=”Python3″]

```# Python3 program to rotate an array by
# d elements
# Function to left rotate arr[] of size n by d
def leftRotate(arr, d, n):
d = d % n
g_c_d = gcd(d, n)
for i in range(g_c_d):

# move i-th values of blocks
temp = arr[i]
j = i
while 1:
k = j + d
if k >= n:
k = k - n
if k == i:
break
arr[j] = arr[k]
j = k
arr[j] = temp

# UTILITY FUNCTIONS
# function to print an array
def printArray(arr, size):
for i in range(size):
print ("% d" % arr[i], end =" ")

# Fuction to get gcd of a and b
def gcd(a, b):
if b == 0:
return a;
else:
return gcd(b, a % b)

# Driver program to test above functions
arr = [1, 2, 3, 4, 5, 6, 7]
n = len(arr)
d = 2
leftRotate(arr, d, n)
printArray(arr, n)

# This code is contributed by Shreyanshi Arun

```

[tabby title=”C#”]

```// C# program for array rotation
using System;

class GFG {
/* Function to left rotate arr[]
of size n by d*/
static void leftRotate(int[] arr, int d,
int n)
{
int i, j, k, temp;
/* To handle if d >= n */
d = d % n;
int g_c_d = gcd(d, n);
for (i = 0; i < g_c_d; i++) {
/* move i-th values of blocks */
temp = arr[i];
j = i;
while (true) {
k = j + d;
if (k >= n)
k = k - n;
if (k == i)
break;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}

/*UTILITY FUNCTIONS*/
/* Function to print an array */
static void printArray(int[] arr, int size)
{
for (int i = 0; i < size; i++)
Console.Write(arr[i] + " ");
}

/* Fuction to get gcd of a and b*/
static int gcd(int a, int b)
{
if (b == 0)
return a;
else
return gcd(b, a % b);
}

// Driver code
public static void Main()
{
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}

// This code is contributed by Sam007
```

[tabby title=”Javascript”]

```<script>

// JavaScript program to rotate an array by
// d elements

/*Fuction to get gcd of a and b*/
function gcd( a, b){
if (b == 0)
return a;
else
return gcd(b, a % b);
}

/*Function to left rotate arr[] of siz n by d*/
function leftRotate(arr, d, n){
/* To handle if d >= n */
d = d % n;
let g_c_d = gcd(d, n);
for (let i = 0; i < g_c_d; i++) {
/* move i-th values of blocks */
let temp = arr[i];
let j = i;

while (1) {
let k = j + d;
if (k >= n)
k = k - n;

if (k == i)
break;

arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}

// Function to print an array
function printArray(arr, size){
for (let i = 0; i < size; i++)
document.write(arr[i] +" ");
}

/* Driver program to test above functions */
let arr = [ 1, 2, 3, 4, 5, 6, 7 ];
let n = arr.length;
// Function calling
leftRotate(arr, 2, n);
printArray(arr, n);

</script>
```

[tabbyending]

Output :

`3 4 5 6 7 1 2`

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

Last Updated on October 16, 2021 by admin

## Arrays in JavaArrays in Java

Java Arrays   An array is a group of like-typed variables that are referred to

## Find the Missing NumberFind the Missing Number

Find the Missing Number You are given a list of n-1 integers and these integers

## Arrays in C/C++Arrays in C/C++

Arrays in C/C++ An array in C/C++ or be it in any programming language is

## Stock Buy Sell to Maximize ProfitStock Buy Sell to Maximize Profit

Stock Buy Sell to Maximize Profit The cost of a stock on each day is

## Linked List vs ArrayLinked List vs Array

Linked List vs Array Arrays store elements in contiguous memory locations, resulting in easily calculable

## Maximum and minimum of an array using minimum number of comparisonsMaximum and minimum of an array using minimum number of comparisons

Maximum and minimum of an array using minimum number of comparisons   Write a C

## Array of Strings in C++Array of Strings in C++

Array of Strings in C++ (All Different Ways to Create) In C and C++, a

## Multidimensional Arrays in JavaMultidimensional Arrays in Java

Multidimensional Arrays in Java Multidimensional Arrays can be defined in simple words as array of