Open In App
Related Articles

# Program for array left rotation by d positions.

Given an array of integers arr[] of size N and an integer, the task is to rotate the array elements to the left by d positions.

Examples:

Input:
arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2
Output: 3 4 5 6 7 1 2

Input: arr[] = {3, 4, 5, 6, 7, 1, 2}, d=2
Output: 5 6 7 1 2 3 4

Approach 1 (Using temp array): This problem can be solved using the below idea:

After rotating d positions to the left, the first d elements become the last d elements of the array

• First store the elements from index d to N-1 into the temp array.
• Then store the first d elements of the original array into the temp array.
• Copy back the elements of the temp array into the original array

Illustration:

Suppose the give array is arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2.

First Step:
=> Store the elements from 2nd index to the last.
=> temp[] = [3, 4, 5, 6, 7]

Second Step:
=> Now store the first 2 elements into the temp[] array.
=> temp[] = [3, 4, 5, 6, 7, 1, 2]

Third Steps:
=> Copy the elements of the temp[] array into the original array.
=> arr[] = temp[] So arr[] = [3, 4, 5, 6, 7, 1, 2]

Follow the steps below to solve the given problem.

• Initialize a temporary array(temp[n]) of length same as the original array
• Initialize an integer(k) to keep a track of the current index
• Store the elements from the position d to n-1 in the temporary array
• Now, store 0 to d-1 elements of the original array in the temporary array
• Lastly, copy back the temporary array to the original array

Below is the implementation of the above approach :

## C++

 `#include ``using` `namespace` `std;` `// Function to rotate array``void` `Rotate(``int` `arr[], ``int` `d, ``int` `n)``{``    ``// Storing rotated version of array``    ``int` `temp[n];` `    ``// Keeping track of the current index``    ``// of temp[]``    ``int` `k = 0;` `    ``// Storing the n - d elements of``    ``// array arr[] to the front of temp[]``    ``for` `(``int` `i = d; i < n; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}` `    ``// Storing the first d elements of array arr[]``    ``//  into temp``    ``for` `(``int` `i = 0; i < d; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}` `    ``// Copying the elements of temp[] in arr[]``    ``// to get the final rotated array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``arr[i] = temp[i];``    ``}``}` `// Function to print elements of array``void` `PrintTheArray(``int` `arr[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++) {``        ``cout << arr[i] << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `d = 2;` `    ``// Function calling``    ``Rotate(arr, d, N);``    ``PrintTheArray(arr, N);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``  ` `  ` `// Function to rotate array``static` `void` `Rotate(``int` `arr[], ``int` `d, ``int` `n)``{``    ``// Storing rotated version of array``    ``int` `temp[] = ``new` `int``[n];` `    ``// Keeping track of the current index``    ``// of temp[]``    ``int` `k = ``0``;` `    ``// Storing the n - d elements of``    ``// array arr[] to the front of temp[]``    ``for` `(``int` `i = d; i < n; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}` `    ``// Storing the first d elements of array arr[]``    ``//  into temp``    ``for` `(``int` `i = ``0``; i < d; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}` `    ``// Copying the elements of temp[] in arr[]``    ``// to get the final rotated array``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``arr[i] = temp[i];``    ``}``}` `// Function to print elements of array``static` `void` `PrintTheArray(``int` `arr[], ``int` `n)``{``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``System.out.print(arr[i]+``" "``);``    ``}``}``    ``public` `static` `void` `main (String[] args) {``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7` `};``        ``int` `N = arr.length;``        ``int` `d = ``2``;` `        ``// Function calling``        ``Rotate(arr, d, N);``        ``PrintTheArray(arr, N);``    ``}``}` `// This code is contributed by ishankhandelwals.`

## Python3

 `def` `rotate(L, d, n):``    ``k ``=` `L.index(d)``    ``new_lis ``=` `[]``    ``new_lis ``=` `L[k``+``1``:]``+``L[``0``:k``+``1``]``    ``return` `new_lis`  `if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``]``    ``d ``=` `2``    ``N ``=` `len``(arr)` `    ``# Function call``    ``arr ``=` `rotate(arr, d, N)``    ``for` `i ``in` `arr:``        ``print``(i, end``=``" "``)`

## C#

 `// Include namespace system``using` `System;` `public` `class` `GFG``{``  ``// Function to rotate array``  ``public` `static` `void` `Rotate(``int``[] arr, ``int` `d, ``int` `n)``  ``{``    ``// Storing rotated version of array``    ``int``[] temp = ``new` `int``[n];` `    ``// Keeping track of the current index``    ``// of temp[]``    ``var` `k = 0;``    ``// Storing the n - d elements of``    ``// array arr[] to the front of temp[]``    ``for` `(``int` `i = d; i < n; i++)``    ``{``      ``temp[k] = arr[i];``      ``k++;``    ``}` `    ``// Storing the first d elements of array arr[]``    ``//  into temp``    ``for` `(``int` `i = 0; i < d; i++)``    ``{``      ``temp[k] = arr[i];``      ``k++;``    ``}` `    ``// Copying the elements of temp[] in arr[]``    ``// to get the final rotated array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``arr[i] = temp[i];``    ``}``  ``}``  ``// Function to print elements of array``  ``public` `static` `void` `PrintTheArray(``int``[] arr, ``int` `n)``  ``{``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``Console.Write(arr[i].ToString() + ``" "``);``    ``}``  ``}``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] arr = {1, 2, 3, 4, 5, 6, 7};``    ``var` `N = arr.Length;``    ``var` `d = 2;` `    ``// Function calling``    ``GFG.Rotate(arr, d, N);``    ``GFG.PrintTheArray(arr, N);``  ``}``}` `// This code is contributed by ishankhandelwals.`

## Javascript

 `function` `Rotate_and_Print(arr,d,n)`` ``{``     ``//Initializing array temp with size n``     ``var` `temp=``new` `Array(n);``     ` `    ``let k = 0;` `    ``// Storing the n - d elements of``    ``// array arr[] to the front of temp[]``    ``for` `(let i = d; i < n; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}` `    ``// Storing the first d elements of array arr[]``    ``//  into temp``    ``for` `(let i = 0; i < d; i++) {``        ``temp[k] = arr[i];``        ``k++;``    ``}``    ``//Printing the temp array which stores the result``    ``for` `(let i = 0; i < n; i++) {``        ``console.log(temp[i]+``" "``);``    ``}`` ``}` `let arr = [ 1, 2, 3, 4, 5, 6, 7 ];``let n = arr.length;``let d = 2; ``//number of times rotating the array``Rotate_and_Print(arr, d, n);` `//contributed by keerthikarathan123`

Output

`3 4 5 6 7 1 2 `

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

Approach 2 (Rotate one by one): This problem can be solved using the below idea:

• At each iteration, shift the elements by one position to the left circularly (i.e., first element becomes the last).
• Perform this operation d times to rotate the elements to the left by d position.

Illustration:

Let us take arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2.

First Step:
=> Rotate to left by one position.
=> arr[] = {2, 3, 4, 5, 6, 7, 1}

Second Step:
=> Rotate again to left by one position
=> arr[] = {3, 4, 5, 6, 7, 1, 2}

Rotation is done by 2 times.
So the array becomes arr[] = {3, 4, 5, 6, 7, 1, 2}

Follow the steps below to solve the given problem.

• Rotate the array to left by one position. For that do the following:
• Store the first element of the array in a temporary variable.
• Shift the rest of the elements in the original array by one place.
• Update the last index of the array with the temporary variable.
• Repeat the above steps for the number of left rotations required.

Below is the implementation of the above approach:

## C++

 `// C++ program to rotate an array by``// d elements``#include ``using` `namespace` `std;` `/*Function to left rotate arr[] of size n by d*/``void` `Rotate(``int` `arr[], ``int` `d, ``int` `n)``{``    ``int` `p = 1;``    ``while` `(p <= d) {``        ``int` `last = arr[0];``        ``for` `(``int` `i = 0; i < n - 1; i++) {``            ``arr[i] = arr[i + 1];``        ``}``        ``arr[n - 1] = last;``        ``p++;``    ``}``}` `// Function to print an array``void` `printArray(``int` `arr[], ``int` `size)``{``    ``for` `(``int` `i = 0; i < size; i++)``        ``cout << arr[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `d = 2;``  ` `    ``// Function calling``    ``Rotate(arr, d, N);``    ``printArray(arr, N);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ` `    ``public` `static` `void` `rotate(``int` `arr[], ``int` `d, ``int` `n)``    ``{``        ``int` `p = ``1``;``        ``while` `(p <= d) {``            ``int` `last = arr[``0``];``            ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``                ``arr[i] = arr[i + ``1``];``            ``}``            ``arr[n - ``1``] = last;``            ``p++;``        ``}` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``System.out.print(arr[i] + ``" "``);``        ``}``    ``}``    ` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7` `};``        ``int` `N = arr.length;``        ``// Rotate 2 times``        ``int` `d = ``2``;` `        ``// Function call``        ``rotate(arr, d, N);``    ``}``}``// contributed by keerthikarathan123`

## Python3

 `# Python program to rotate an array by d elements` `# Function to left rotate arr[] of size n by d``def` `Rotate(arr, d, n):``  ``p ``=` `1``  ``while``(p <``=` `d):``    ``last ``=` `arr[``0``]``    ``for` `i ``in` `range` `(n ``-` `1``):``      ``arr[i] ``=` `arr[i ``+` `1``]``    ``arr[n ``-` `1``] ``=` `last``    ``p ``=` `p ``+` `1``    ` `# Function to print an array``def` `printArray(arr, size):``  ``for` `i ``in` `range` `(size):``    ``print``(arr[i] ,end ``=` `" "``)``    ` `# Driver code``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``]``N ``=` `len``(arr)``d ``=` `2` `# Function calling``Rotate(arr, d, N)``printArray(arr, N)` `# This code is contributed by Atul_kumar_Shrivastava`

## C#

 `// Include namespace system``using` `System;`  `public` `class` `GFG``{``    ``public` `static` `void` `rotate(``int``[] arr, ``int` `d, ``int` `n)``    ``{``        ``var` `p = 1;``        ``while` `(p <= d)``        ``{``            ``var` `last = arr[0];``            ``for` `(``int` `i = 0; i < n - 1; i++)``            ``{``                ``arr[i] = arr[i + 1];``            ``}``            ``arr[n - 1] = last;``            ``p++;``        ``}``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``Console.Write(arr[i].ToString() + ``" "``);``        ``}``    ``}``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = {1, 2, 3, 4, 5, 6, 7};``        ``var` `N = arr.Length;``        ``// Rotate 2 times``        ``var` `d = 2;``        ``// Function call``        ``GFG.rotate(arr, d, N);``    ``}``}`

## Javascript

 `function` `printArray(arr,n,d)``{``    ``let p = 1;``        ``while` `(p <= d) {``            ``let last = arr[0];``            ``for` `(let i = 0; i < n - 1; i++) {``                ``arr[i] = arr[i + 1];``            ``}``            ``arr[n - 1] = last;``            ``p++;``        ``}`` ` `        ``for` `(let i = 0; i < n; i++) {``            ``console.log(arr[i] + ``" "``);``        ``}``}``let arr = [ 1, 2, 3, 4, 5, 6, 7 ];``let n = arr.length;``let d=2; ``//number of times rotating the array` `// Function calling``printArray(arr, n,d);` `//contributed by keerthikarathan123`

Output

`3 4 5 6 7 1 2 `

Time Complexity: O(N * d)
Auxiliary Space: O(1)

Approach 3 (A Juggling Algorithm): This is an extension of method 2.

Instead of moving one by one, divide the array into different sets where the number of sets is equal to the GCD of N and d (say X. So the elements which are X distance apart are part of a set) and rotate the elements within sets by 1 position to the left.

• Calculate the GCD between the length and the distance to be moved.
• The elements are only shifted within the sets.
• We start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.

Follow the below illustration for a better understanding

Illustration:

Each steps looks like following:

Let arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14} and d = 10

First step:
=> First set is {0, 5, 10}.
=> Rotate this set by d position in cyclic order
=> arr[0] = arr[0+10]
=> arr[10] = arr[(10+10)%15]
=> arr[5] = arr[0]
=> This set becomes {10,0,5}
=> Array arr[] = {10, 1, 2, 3, 4, 0, 6, 7, 8, 9, 5, 11, 12, 13, 14}

Second step:
=> Second set is {1, 6, 11}.
=> Rotate this set by d position in cyclic order.
=> This set becomes {11, 1, 6}
=> Array arr[] =  {10, 11, 2, 3, 4, 0, 1, 7, 8, 9, 5, 6, 12, 13, 14}

Third step:
=> Second set is {2, 7, 12}.
=> Rotate this set by d position in cyclic order.
=> This set becomes {12, 2, 7}
=> Array arr[] =  {10, 11, 12, 3, 4, 0, 1, 2, 8, 9, 5, 6, 7, 13, 14}

Fourth step:
=> Second set is {3, 8, 13}.
=> Rotate this set by d position in cyclic order.
=> This set becomes {13, 3, 8}
=> Array arr[] =  {10, 11, 12, 13, 4, 0, 1, 2, 3, 9, 5, 6, 7, 8, 14}

Fifth step:
=> Second set is {4, 9, 14}.
=> Rotate this set by d position in cyclic order.
=> This set becomes {14, 4, 9}
=> Array arr[] =  {10, 11, 12, 13, 14, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Follow the steps below to solve the given problem.

• Perform d%n in order to keep the value of d within the range of the array where d is the number of times the array is rotated and N is the size of the array.
• Calculate the GCD(N, d) to divide the array into sets.
• Run a for loop from 0 to the value obtained from GCD.
• Store the value of arr[i] in a temporary variable (the value of i denotes the set number).
• Run a while loop to update the values according to the set.
• After exiting the while loop assign the value of arr[j] as the value of the temporary variable (the value of j denotes the last element of the ith set).

Below is the implementation of the above approach :

## C++

 `// C++ program to rotate an array by``// d elements``#include ``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 size 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;``}`

## C

 `// C program to rotate an array by``// d elements``#include ` `/* function to print an array */``void` `printArray(``int` `arr[], ``int` `size);` `/*Function to get gcd of a and b*/``int` `gcd(``int` `a, ``int` `b);` `/*Function to left rotate arr[] of size 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]);``}` `/*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);``}` `/* 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;``}`

## Java

 `// Java program to rotate an array by``// d elements``import` `java.io.*;``class` `RotateArray {``    ``/*Function to left rotate arr[] of size 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] + ``" "``);``    ``}` `    ``/*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);``    ``}` `    ``// 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`

## 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``=``" "``)` `# Function 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`

## 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] + ``" "``);``    ``}` `    ``/* Function 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`

## Javascript

 ``

Output

`3 4 5 6 7 1 2 `

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

### Approach 4 :

(Using Collections module )

Python module have module named “collections” which provides various data structures. One of them is “deque“.

Deque is also known as double ended queue. Module also provides different in-built methods. One of them is “rotate”.

## C++14

 `#include ``#include ``using` `namespace` `std;` `int` `main() {``    ``deque<``int``> dq {1, 2, 3, 4, 5, 6, 7};``    ``int` `d = 2;``    ` `    ``// Rotate the deque left by d elements``    ``for``(``int` `i=0; i

## Java

 `import` `java.util.ArrayDeque;``import` `java.util.Deque;` `public` `class` `Main {``    ``public` `static` `void` `main(String[] args) {``        ``int``[] inp = {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``};``        ``int` `d = ``2``;` `        ``Deque deq = ``new` `ArrayDeque<>();``        ``for` `(``int` `i : inp) {``            ``deq.add(i);``        ``}` `        ``for` `(``int` `i = ``0``; i < d; i++) {``            ``int` `temp = deq.remove();``            ``deq.addLast(temp);``        ``}` `        ``System.out.println(deq);``    ``}``}``// this code is contributed by devendrasalunke`

## Python3

 `from` `collections ``import` `deque` `#Taking input -- elements``inp``=``[``1``,``2``,``3``,``4``,``5``,``6``,``7``]``#input -- Number of rotations``d``=``2` `#Changing from list to deque structure``deq ``=` `deque(inp)` `#To know the type of data structure``U ``=` `type``(deq)                         ``#If we print-- Output: `  `#Rotating left using rotate function``#To rotate left use (-), Ex: rotate(-3)``#To rotate right by 3 elements Ex: rotate(3)` `deq.rotate(``-``d)``print``(deq)`

## Javascript

 `// Taking input -- elements``let inp = [1, 2, 3, 4, 5, 6, 7];``// input -- Number of rotations``let d = 2;` `// Create a deque as an array``let deque = [...inp];` `// Rotate the deque to the left``for` `(let i = 0; i < d; i++) {``  ``let element = deque.shift(); ``// Remove the first element``  ``deque.push(element); ``// Add it to the end of the deque``}` `console.log(deque);`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG {``    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> inp``            ``= ``new` `List<``int``>{ 1, 2, 3, 4, 5, 6, 7 };``        ``int` `d = 2;``        ``// Changing from list to deque structure``        ``Queue<``int``> deq = ``new` `Queue<``int``>(inp);` `        ``// Rotating left using rotate function``        ``// To rotate left use (-), Ex: rotate(-3)``        ``// To rotate right by 3 elements Ex: rotate(3)``        ``for` `(``int` `i = 0; i < d; i++) {``            ``int` `temp = deq.Dequeue();``            ``deq.Enqueue(temp);``        ``}` `        ``Console.WriteLine(``string``.Join(``" "``, deq));``    ``}``}`

Output

`deque([3, 4, 5, 6, 7, 1, 2])`

Time complexity: The time complexity of the code is O(d*n), where d is the number of rotations and n is the size of the deque.
The auxiliary space is O(n), where n is the size of the deque.

Please see the following posts for other methods of array rotation:
Block swap algorithm for array rotation
Reversal algorithm for array rotation
Please write comments if you find any bugs in the above programs/algorithms.