Quickly find multiple left rotations of an array | Set 1
Last Updated :
19 Sep, 2023
Given an array of size n and multiple values around which we need to left rotate the array. How to quickly find multiple left rotations?
Examples:
Input: arr[] = {1, 3, 5, 7, 9}
k1 = 1
k2 = 3
k3 = 4
k4 = 6
Output: 3 5 7 9 1
7 9 1 3 5
9 1 3 5 7
3 5 7 9 1
Input: arr[] = {1, 3, 5, 7, 9}
k1 = 14
Output: 9 1 3 5 7
Simple Approach: We have already discussed different approaches given in the below posts.
- Left Rotation of array (Simple and Juggling Algorithms).
- Block swap algorithm for array rotation
- Reversal algorithm for array rotation
The best of the above approaches take O(n) time and O(1) extra space.
Simple Approach: We are using the reverse algorithm but this time for multiple k values – you can click on the above link to understand this approach.
Implementation:
C++
#include <iostream>
using namespace std;
int * rotateArray( int A[], int start, int end)
{
while (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
start++;
end--;
}
return A;
}
void leftRotate( int A[], int a, int k)
{
int c = k % a;
int D[a];
for ( int i = 0; i < a; i++)
D[i] = A[i];
rotateArray(D, 0, c - 1);
rotateArray(D, c, a - 1);
rotateArray(D, 0, a - 1);
for ( int i = 0; i < a; i++)
cout << D[i] << " " ;
cout << "\n" ;
}
int main()
{
int A[] = { 1, 3, 5, 7, 9 };
int n = sizeof (A) / sizeof (A[0]);
int k = 2;
leftRotate(A, n, k);
k = 3;
leftRotate(A, n, k);
k = 4;
leftRotate(A, n, k);
return 0;
}
|
Java
import java.io.*;
import java.util.Arrays;
class GFG {
public static void leftRotate( int [] A, int a, int k)
{
int c = k % a;
int [] D = A.clone();
rotateArray(D, 0 , c - 1 );
rotateArray(D, c, a - 1 );
rotateArray(D, 0 , a - 1 );
System.out.print(Arrays.toString(D));
System.out.println();
}
public static int [] rotateArray( int [] A, int start,
int end)
{
while (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
start++;
end--;
}
return A;
}
public static void main(String[] args)
{
int A[] = { 1 , 3 , 5 , 7 , 9 };
int n = A.length;
int k = 2 ;
leftRotate(A, n, k);
k = 3 ;
leftRotate(A, n, k);
k = 4 ;
leftRotate(A, n, k);
}
}
|
Python3
def rotateArray(A, start, end):
while start < end:
temp = A[start]
A[start] = A[end]
A[end] = temp
start + = 1
end - = 1
return A
def leftRotate(arr, a, k):
c = k % a
D = arr.copy()
rotateArray(D, 0 , c - 1 )
rotateArray(D, c, a - 1 )
rotateArray(D, 0 , a - 1 )
print (D)
arr = [ 1 , 3 , 5 , 7 , 9 ]
n = len (arr)
k = 2
leftRotate(arr, n, k)
k = 3
leftRotate(arr, n, k)
k = 4
leftRotate(arr, n, k)
|
C#
using System;
public class GFG {
public static void leftRotate( int [] A, int a, int k)
{
int c = k % a;
int [] D = A.Clone() as int [];
rotateArray(D, 0, c - 1);
rotateArray(D, c, a - 1);
rotateArray(D, 0, a - 1);
Console.Write( "[" );
for ( int i = 0; i < D.Length - 1; i++) {
Console.Write(D[i] + " " );
}
Console.WriteLine(D[D.Length - 1] + "]" );
}
public static int [] rotateArray( int [] A, int start,
int end)
{
while (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
start++;
end--;
}
return A;
}
static public void Main()
{
int [] A = { 1, 3, 5, 7, 9 };
int n = A.Length;
int k = 2;
leftRotate(A, n, k);
k = 3;
leftRotate(A, n, k);
k = 4;
leftRotate(A, n, k);
}
}
|
Javascript
class GFG
{
static leftRotate(A, a, k)
{
var c = k % a;
var D = [...A];
GFG.rotateArray(D, 0, c - 1);
GFG.rotateArray(D, c, a - 1);
GFG.rotateArray(D, 0, a - 1);
console.log(D);
console.log();
}
static rotateArray(A, start, end)
{
while (start < end)
{
var temp = A[start];
A[start] = A[end];
A[end] = temp;
start++;
end--;
}
return A;
}
static main(args)
{
var A = [1, 3, 5, 7, 9];
var n = A.length;
var k = 2;
GFG.leftRotate(A, n, k);
k = 3;
GFG.leftRotate(A, n, k);
k = 4;
GFG.leftRotate(A, n, k);
}
}
GFG.main([]);
|
Output
5 7 9 1 3
7 9 1 3 5
9 1 3 5 7
Time Complexity: O(n)
Auxiliary Space: O(n)
Efficient Approach:
The above approaches work well when there is a single rotation required. The approaches also modify the original array. To handle multiple queries of array rotation, we use a temp array of size 2n and quickly handle rotations.
- Step 1: Copy the entire array two times in the temp[0..2n-1] array.
- Step 2: Starting position of the array after k rotations in temp[] will be k % n. We do k
- Step 3: Print temp[] array from k % n to k % n + n.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void preprocess( int arr[], int n, int temp[])
{
for ( int i = 0; i < n; i++)
temp[i] = temp[i + n] = arr[i];
}
void leftRotate( int arr[], int n, int k, int temp[])
{
int start = k % n;
for ( int i = start; i < start + n; i++)
cout << temp[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int temp[2 * n];
preprocess(arr, n, temp);
int k = 2;
leftRotate(arr, n, k, temp);
k = 3;
leftRotate(arr, n, k, temp);
k = 4;
leftRotate(arr, n, k, temp);
return 0;
}
|
Java
class LeftRotate {
static void preprocess( int arr[], int n, int temp[])
{
for ( int i = 0 ; i < n; i++)
temp[i] = temp[i + n] = arr[i];
}
static void leftRotate( int arr[], int n, int k,
int temp[])
{
int start = k % n;
for ( int i = start; i < start + n; i++)
System.out.print(temp[i] + " " );
System.out.print( "\n" );
}
public static void main(String[] args)
{
int arr[] = { 1 , 3 , 5 , 7 , 9 };
int n = arr.length;
int temp[] = new int [ 2 * n];
preprocess(arr, n, temp);
int k = 2 ;
leftRotate(arr, n, k, temp);
k = 3 ;
leftRotate(arr, n, k, temp);
k = 4 ;
leftRotate(arr, n, k, temp);
}
}
|
Python3
def preprocess(arr, n):
temp = [ None ] * ( 2 * n)
for i in range (n):
temp[i] = temp[i + n] = arr[i]
return temp
def leftRotate(arr, n, k, temp):
start = k % n
for i in range (start, start + n):
print (temp[i], end = " " )
print ("")
arr = [ 1 , 3 , 5 , 7 , 9 ]
n = len (arr)
temp = preprocess(arr, n)
k = 2
leftRotate(arr, n, k, temp)
k = 3
leftRotate(arr, n, k, temp)
k = 4
leftRotate(arr, n, k, temp)
|
C#
using System;
class LeftRotate {
static void preprocess( int [] arr, int n, int [] temp)
{
for ( int i = 0; i < n; i++)
temp[i] = temp[i + n] = arr[i];
}
static void leftRotate( int [] arr, int n, int k,
int [] temp)
{
int start = k % n;
for ( int i = start; i < start + n; i++)
Console.Write(temp[i] + " " );
Console.WriteLine();
}
public static void Main()
{
int [] arr = { 1, 3, 5, 7, 9 };
int n = arr.Length;
int [] temp = new int [2 * n];
preprocess(arr, n, temp);
int k = 2;
leftRotate(arr, n, k, temp);
k = 3;
leftRotate(arr, n, k, temp);
k = 4;
leftRotate(arr, n, k, temp);
}
}
|
PHP
<?php
function preprocess(& $arr , $n ,
& $temp )
{
for ( $i = 0; $i < $n ; $i ++)
$temp [ $i ] = $temp [ $i + $n ] = $arr [ $i ];
}
function leftRotate(& $arr , $n ,
$k , & $temp )
{
$start = $k % $n ;
for ( $i = $start ;
$i < $start + $n ; $i ++)
echo $temp [ $i ] . " " ;
echo "\n" ;
}
$arr = array (1, 3, 5, 7, 9);
$n = sizeof( $arr );
$temp [2 * $n ] = array ();
preprocess( $arr , $n , $temp );
$k = 2;
leftRotate( $arr , $n , $k , $temp );
$k = 3;
leftRotate( $arr , $n , $k , $temp );
$k = 4;
leftRotate( $arr , $n , $k , $temp );
?>
|
Javascript
<script>
function preprocess(arr , n , temp) {
for (i = 0; i < n; i++)
temp[i] = temp[i + n] = arr[i];
}
function leftRotate(arr , n , k , temp) {
var start = k % n;
for (i = start; i < start + n; i++)
document.write(temp[i] + " " );
document.write( "<br/>" );
}
var arr = [ 1, 3, 5, 7, 9 ];
var n = arr.length;
var temp = Array(2 * n).fill(0);
preprocess(arr, n, temp);
var k = 2;
leftRotate(arr, n, k, temp);
k = 3;
leftRotate(arr, n, k, temp);
k = 4;
leftRotate(arr, n, k, temp);
</script>
|
Output
5 7 9 1 3
7 9 1 3 5
9 1 3 5 7
Time Complexity: O(n)
Note that the task to find starting address of rotation takes O(1) time. It is printing the elements that take O(n) time.
Auxiliary Space: O(n)
Space-optimized Approach: The above method takes extra space. Below given is a space-optimized solution. Thanks to frenzy77 for suggesting this approach.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void leftRotate( int arr[], int n, int k)
{
for ( int i = k; i < k + n; i++)
cout << arr[i % n] << " " ;
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, n, k);
cout << endl;
k = 3;
leftRotate(arr, n, k);
cout << endl;
k = 4;
leftRotate(arr, n, k);
cout << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static void leftRotate( int arr[], int n, int k)
{
for ( int i = k; i < k + n; i++)
System.out.print(arr[i % n] + " " );
}
public static void main(String[] args)
{
int arr[] = { 1 , 3 , 5 , 7 , 9 };
int n = arr.length;
int k = 2 ;
leftRotate(arr, n, k);
System.out.println();
k = 3 ;
leftRotate(arr, n, k);
System.out.println();
k = 4 ;
leftRotate(arr, n, k);
System.out.println();
}
}
|
Python 3
def leftRotate(arr, n, k):
for i in range (k, k + n):
print ( str (arr[i % n]),
end = " " )
arr = [ 1 , 3 , 5 , 7 , 9 ]
n = len (arr)
k = 2
leftRotate(arr, n, k)
print ()
k = 3
leftRotate(arr, n, k)
print ()
k = 4
leftRotate(arr, n, k)
print ()
|
C#
using System;
class GFG {
static void leftRotate( int [] arr, int n, int k)
{
for ( int i = k; i < k + n; i++)
Console.Write(arr[i % n] + " " );
}
static public void Main()
{
int [] arr = { 1, 3, 5, 7, 9 };
int n = arr.Length;
int k = 2;
leftRotate(arr, n, k);
Console.WriteLine();
k = 3;
leftRotate(arr, n, k);
Console.WriteLine();
k = 4;
leftRotate(arr, n, k);
Console.WriteLine();
}
}
|
PHP
<?php
function leftRotate( $arr , $n , $k )
{
for ( $i = $k ; $i < $k + $n ; $i ++)
echo $arr [ $i % $n ] , " " ;
}
$arr = array (1, 3, 5, 7, 9);
$n = sizeof( $arr );
$k = 2;
leftRotate( $arr , $n , $k );
echo "\n" ;
$k = 3;
leftRotate( $arr , $n , $k );
echo "\n" ;
$k = 4;
leftRotate( $arr , $n , $k );
echo "\n" ;
?>
|
Javascript
<script>
function leftRotate(arr, n, k)
{
for (let i = k; i < k + n; i++)
document.write(arr[i % n] + " " );
}
let arr = [1, 3, 5, 7, 9];
n = arr.length;
k = 2;
leftRotate(arr, n, k);
document.write( "<br>" );
k = 3;
leftRotate(arr, n, k);
document.write( "<br>" );
k = 4;
leftRotate(arr, n, k);
document.write( "<br>" );
</script>
|
Output
5 7 9 1 3
7 9 1 3 5
9 1 3 5 7
Time Complexity: O(n)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...