# Program to cyclically rotate an array by one

• Difficulty Level : Basic
• Last Updated : 29 Nov, 2022

Given an array, cyclically rotate the array clockwise by one.

Examples:

```Input:  arr[] = {1, 2, 3, 4, 5}
Output: arr[] = {5, 1, 2, 3, 4}```

Following are steps.
1) Store last element in a variable say x.
2) Shift all elements one position ahead.
3) Replace first element of array with x.

## C++

 `// C++ code for program ` `// to cyclically rotate` `// an array by one` `# include ` `using` `namespace` `std;`   `void` `rotate(``int` `arr[], ``int` `n)` `{` `    ``int` `x = arr[n - 1], i;` `    ``for` `(i = n - 1; i > 0; i--){` `        ``arr[i] = arr[i - 1]; ` `    ``}` `    ``arr[0] = x;` `}`   `// Driver code` `int` `main() ` `{` `    ``int` `arr[] = {1, 2, 3, 4, 5}, i;` `    ``int` `n = ``sizeof``(arr) / ` `            ``sizeof``(arr[0]);`   `    ``cout << ``"Given array is \n"``;` `    ``for` `(i = 0; i < n; i++)` `        ``cout << arr[i] << ``' '``;`   `    ``rotate(arr, n);`   `    ``cout << ``"\nRotated array is\n"``;` `    ``for` `(i = 0; i < n; i++)` `        ``cout << arr[i] << ``' '``;`   `    ``return` `0;` `}`   `// This code is contributed by jit_t`

## C

 `#include `   `void` `rotate(``int` `arr[], ``int` `n)` `{` `   ``int` `x = arr[n-1], i;` `   ``for` `(i = n-1; i > 0; i--)` `      ``arr[i] = arr[i-1];` `   ``arr[0] = x;` `}`   `int` `main()` `{` `    ``int` `arr[] = {1, 2, 3, 4, 5}, i;` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);`   `    ``printf``(``"Given array is\n"``);` `    ``for` `(i = 0; i < n; i++)` `        ``printf``(``"%d "``, arr[i]);`   `    ``rotate(arr, n);`   `    ``printf``(``"\nRotated array is\n"``);` `    ``for` `(i = 0; i < n; i++)` `        ``printf``(``"%d "``, arr[i]);`   `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`   `public` `class` `Test` `{` `    ``static` `int` `arr[] = ``new` `int``[]{``1``, ``2``, ``3``, ``4``, ``5``};` `    `  `    ``// Method for rotation` `    ``static` `void` `rotate()` `    ``{` `       ``int` `x = arr[arr.length-``1``], i;` `       ``for` `(i = arr.length-``1``; i > ``0``; i--)` `          ``arr[i] = arr[i-``1``];` `       ``arr[``0``] = x;` `    ``}` `    `  `    ``/* Driver program */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``System.out.println(``"Given Array is"``);` `        ``System.out.println(Arrays.toString(arr));` `        `  `        ``rotate();` `        `  `        ``System.out.println(``"Rotated Array is"``);` `        ``System.out.println(Arrays.toString(arr));` `    ``}` `}`

## Python3

 `# Python3 code for program to ` `# cyclically rotate an array by one`   `# Method for rotation` `def` `rotate(arr, n):` `    ``x ``=` `arr[n ``-` `1``]` `    `  `    ``for` `i ``in` `range``(n ``-` `1``, ``0``, ``-``1``):` `        ``arr[i] ``=` `arr[i ``-` `1``];` `        `  `    ``arr[``0``] ``=` `x;`     `# Driver function` `arr``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `n ``=` `len``(arr)` `print` `(``"Given array is"``)` `for` `i ``in` `range``(``0``, n):` `    ``print` `(arr[i], end ``=` `' '``)`   `rotate(arr, n)`   `print` `(``"\nRotated array is"``)` `for` `i ``in` `range``(``0``, n):` `    ``print` `(arr[i], end ``=` `' '``)`   `# This article is contributed ` `# by saloni1297`

## C#

 `// C# code for program to cyclically` `// rotate an array by one` `using` `System;`   `public` `class` `Test` `{` `    ``static` `int` `[]arr = ``new` `int``[]{1, 2, 3, 4, 5};` `    `  `    ``// Method for rotation` `    ``static` `void` `rotate()` `    ``{` `    ``int` `x = arr[arr.Length - 1], i;` `    `  `    ``for` `(i = arr.Length - 1; i > 0; i--)` `        ``arr[i] = arr[i-1];` `    ``arr[0] = x;` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main() ` `    ``{` `        ``Console.WriteLine(``"Given Array is"``);` `        ``string` `Original_array = ``string``.Join(``" "``, arr);` `        ``Console.WriteLine(Original_array);` `         `  `        ``rotate();` `        `  `        ``Console.WriteLine(``"Rotated Array is"``);` `        ``string` `Rotated_array = ``string``.Join(``" "``, arr);` `        ``Console.WriteLine(Rotated_array);` `    ``}` `}`   `// This code is contributed by vt_m.`

## PHP

 ` 0; ``\$i``--)` `    ``\$arr``[``\$i``] = ``\$arr``[``\$i` `- 1]; ` `    ``\$arr``[0] = ``\$x``;` `}`   `// Driver code` `\$arr` `= ``array``(1, 2, 3, 4, 5);` `\$n` `= sizeof(``\$arr``);`   `echo` `"Given array is \n"``;` `for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)` `    ``echo` `\$arr``[``\$i``] . ``" "``;`   `rotate(``\$arr``, ``\$n``);`   `echo` `"\nRotated array is\n"``;` `for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)` `    ``echo` `\$arr``[``\$i``] . ``" "``;`   `// This code is contributed` `// by ChitraNayal` `?>`

## Javascript

 ``

Output

```Given array is
1 2 3 4 5

Rotated array is
5 1 2 3 4 ```

Time Complexity: O(n), as we need to iterate through all the elements. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.
The above question can also be solved by using reversal algorithm.

Another approach:

We can use two pointers, say i and j which point to first and last element of array respectively. As we know in cyclic rotation we will bring last element to first and shift rest in forward direction, so start swapping arr[i] and arr[j] and keep j fixed and i moving towards j.  Repeat till i is not equal to j.

## C++

 `#include ` `using` `namespace` `std;`   `void` `rotate(``int` `arr[], ``int` `n)` `{` `    ``int` `i = 0, j = n-1; ``// i and j pointing to first and last element respectively` `      ``while``(i != j){` `      ``swap(arr[i], arr[j]);` `      ``i++;` `    ``}` `}`   `// Driver code` `int` `main() ` `{` `    ``int` `arr[] = {1, 2, 3, 4, 5}, i;` `    ``int` `n = ``sizeof``(arr) / ` `            ``sizeof``(arr[0]);`   `    ``cout << ``"Given array is \n"``;` `    ``for` `(i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;`   `    ``rotate(arr, n);`   `    ``cout << ``"\nRotated array is\n"``;` `    ``for` `(i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;`   `    ``return` `0;` `}`

## C

 `#include `   `void` `swap(``int` `*x, ``int` `*y)` `{` `  ``int` `temp = *x;` `  ``*x = *y;` `  ``*y = temp;` `}` `void` `rotate(``int` `arr[], ``int` `n)` `{` `  ``int` `i = 0, j = n - 1;` `  ``while``(i != j)` `  ``{` `    ``swap(&arr[i], &arr[j]);` `    ``i++;` `  ``}` `}`   `int` `main()` `{` `    ``int` `arr[] = {1, 2, 3, 4, 5}, i;` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);`   `    ``printf``(``"Given array is\n"``);` `    ``for` `(i = 0; i < n; i++)` `        ``printf``(``"%d "``, arr[i]);`   `    ``rotate(arr, n);`   `    ``printf``(``"\nRotated array is\n"``);` `    ``for` `(i = 0; i < n; i++)` `        ``printf``(``"%d "``, arr[i]);`   `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`   `public` `class` `Test` `{` `    ``static` `int` `arr[] = ``new` `int``[]{``1``, ``2``, ``3``, ``4``, ``5``};` `    `  `   `  `    ``static` `void` `rotate()` `    ``{` `       ``int` `i = ``0``, j = arr.length - ``1``;` `       ``while``(i != j)` `       ``{` `         ``int` `temp = arr[i];` `         ``arr[i] = arr[j];` `         ``arr[j] = temp;` `         ``i++;` `       ``}` `    ``}` `    `  `    ``/* Driver program */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``System.out.println(``"Given Array is"``);` `        ``System.out.println(Arrays.toString(arr));` `        `  `        ``rotate();` `        `  `        ``System.out.println(``"Rotated Array is"``);` `        ``System.out.println(Arrays.toString(arr));` `    ``}` `}`

## Python3

 `def` `rotate(arr, n):` `    ``i ``=` `0` `    ``j ``=` `n ``-` `1` `    ``while` `i !``=` `j:` `      ``arr[i], arr[j] ``=` `arr[j], arr[i]` `      ``i ``=` `i ``+` `1` `    ``pass`     `# Driver function` `arr``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `n ``=` `len``(arr)` `print` `(``"Given array is"``)` `for` `i ``in` `range``(``0``, n):` `    ``print` `(arr[i], end ``=` `' '``)`   `rotate(arr, n)`   `print` `(``"\nRotated array is"``)` `for` `i ``in` `range``(``0``, n):` `    ``print` `(arr[i], end ``=` `' '``)`

## C#

 `// C# code for program to cyclically` `// rotate an array by one` `using` `System;`   `class` `GFG{` `    `  `static` `int` `[]arr = ``new` `int``[]{ 1, 2, 3, 4, 5 };`   `// Method for rotation` `static` `void` `rotate()` `{` `    ``int` `n = arr[arr.Length - 1];` `    `  `    ``// i and j pointing to first and ` `    ``// last element respectively` `    ``int` `i = 0, j = n - 1; ` `    ``while``(i != j)` `    ``{` `        ``{` `            ``int` `temp = arr[i];` `            ``arr[i] = arr[j];` `            ``arr[j] = temp;` `        ``}` `    ``i++;` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main() ` `{` `    ``Console.WriteLine(``"Given Array is"``);` `    ``string` `Original_array = ``string``.Join(``" "``, arr);` `    ``Console.WriteLine(Original_array);` `     `  `    ``rotate();` `    `  `    ``Console.WriteLine(``"Rotated Array is"``);` `    ``string` `Rotated_array = ``string``.Join(``" "``, arr);` `    ``Console.WriteLine(Rotated_array);` `}` `}`   `// This code is contributed by annianni`

## Javascript

 ``

Output

```Given array is
1 2 3 4 5
Rotated array is
5 1 2 3 4 ```

Time Complexity: O(n), as we need to iterate through all the elements. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.

Another approach(Using Slicing ):

We can also solve this problem using slicing in python.

Implementation for the above approach:-

## Python3

 `def` `rotateArray(array):` `    ``'''` `    ``array[-1:] taking last element` `    ``array[:-1] taking elements from start to last second element` `    ``array[:] changing array from starting to end` `    ``'''` `    ``array[:] ``=` `array[``-``1``:]``+``array[:``-``1``]`     `# create array` `array ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `# send array to rotateArray function` `rotateArray(array)`   `print``(``*``array)  ``# 5 1 2 3 4`

Output

`5 1 2 3 4`

Time Complexity: O(n), as we are reversing the array. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.

My Personal Notes arrow_drop_up
Related Articles