Print left rotation of array in O(n) time and O(1) space
Last Updated :
14 Oct, 2023
Given an array of size n and multiple values around which we need to left rotate the array. How to quickly print 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
We have discussed a solution in the below post.
Quickly find multiple left rotations of an array | Set 1
Method I: The solution discussed above requires extra space. In this post, an optimized solution is discussed that doesn’t require extra space.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void leftRotate( int arr[], int n, int k)
{
int mod = k % n;
for ( int i = 0; i < n; i++)
cout << (arr[(mod + i) % n]) << " " ;
cout << "\n" ;
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, n, k);
k = 3;
leftRotate(arr, n, k);
k = 4;
leftRotate(arr, n, k);
return 0;
}
|
C
#include <stdio.h>
void leftRotate( int arr[], int n, int k)
{
int mod = k % n;
for ( int i = 0; i < n; i++)
printf ( "%d " , arr[(mod + i) % n]);
printf ( "\n" );
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, n, k);
k = 3;
leftRotate(arr, n, k);
k = 4;
leftRotate(arr, n, k);
return 0;
}
|
Java
import java.util.*;
import java.lang.*;
import java.io.*;
class arr_rot {
static void leftRotate( int arr[], int n, int k)
{
int mod = k % n;
for ( int i = 0 ; i < n; ++i)
System.out.print(arr[(i + mod) % n] + " " );
System.out.println();
}
public static void main(String[] args)
{
int arr[] = { 1 , 3 , 5 , 7 , 9 };
int n = arr.length;
int k = 2 ;
leftRotate(arr, n, k);
k = 3 ;
leftRotate(arr, n, k);
k = 4 ;
leftRotate(arr, n, k);
}
}
|
Python
def leftRotate(arr, n, k):
mod = k % n
s = ""
for i in range (n):
print str (arr[(mod + i) % n]),
print
return
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;
class GFG {
static void leftRotate( int [] arr, int n, int k)
{
int mod = k % n;
for ( int i = 0; i < n; ++i)
Console.Write(arr[(i + mod) % n] + " " );
Console.WriteLine();
}
static public void Main()
{
int [] arr = { 1, 3, 5, 7, 9 };
int n = arr.Length;
int k = 2;
leftRotate(arr, n, k);
k = 3;
leftRotate(arr, n, k);
k = 4;
leftRotate(arr, n, k);
}
}
|
Javascript
<script>
function leftRotate(arr, n, k){
let mod = k % n;
for (let i = 0; i < n; i++)
document.write((arr[(mod + i) % n]) + " " );
document.write( "\n" );
}
let arr = [ 1, 3, 5, 7, 9 ];
let n = arr.length;
let k = 2;
leftRotate(arr, n, k);
document.write( "<br>" );
k = 3;
leftRotate(arr, n, k);
document.write( "<br>" );
k = 4;
leftRotate(arr, n, k);
</script>
|
PHP
<?php
function leftRotate( $arr , $n , $k )
{
$mod = $k % $n ;
for ( $i = 0; $i < $n ; $i ++)
echo ( $arr [( $mod +
$i ) % $n ]) , " " ;
echo "\n" ;
}
$arr = array (1, 3, 5, 7, 9);
$n = sizeof( $arr );
$k = 2;
leftRotate( $arr , $n , $k );
$k = 3;
leftRotate( $arr , $n , $k );
$k = 4;
leftRotate( $arr , $n , $k );
?>
|
Output
5 7 9 1 3
7 9 1 3 5
9 1 3 5 7
Time Complexity: O(N), as we are using a loop to traverse N times.
Auxiliary Space: O(1), as we are not using any extra space.
Method II: In the below implementation we will use Standard Template Library (STL) which will be making the solution more optimize and easy to Implement.
Implementation:
C++
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
void leftRotate( int arr[], int k, int n)
{
rotate(arr, arr + (k % n), arr + n);
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
cout << "\n" ;
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, k, n);
return 0;
}
|
C
#include <stdio.h>
void leftRotate( int arr[], int k, int n)
{
int i, temp;
for (i = 0; i < k; i++) {
temp = arr[0];
for ( int j = 0; j < n - 1; j++) {
arr[j] = arr[j + 1];
}
arr[n - 1] = temp;
}
for (i = 0; i < n; i++) {
printf ( "%d " , arr[i]);
}
printf ( "\n" );
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, k, n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static void leftRotate(Integer arr[], int k,
int n)
{
Collections.rotate(Arrays.asList(arr), n - k);
for ( int i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
}
public static void main(String[] args)
{
Integer arr[] = { 1 , 3 , 5 , 7 , 9 };
int n = arr.length;
int k = 2 ;
leftRotate(arr, k, n);
}
}
|
Python3
from collections import deque
def leftRotate(arr, k, n):
arr = deque(arr)
arr.rotate( - k)
arr = list (arr)
for i in range (n):
print (arr[i], end = " " )
if __name__ = = '__main__' :
arr = [ 1 , 3 , 5 , 7 , 9 ]
n = len (arr)
k = 2
leftRotate(arr, k, n)
|
C#
using System;
class GFG
{
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;
}
static void printArray( int [] arr, int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
}
public static void Main()
{
int [] arr = { 1, 3, 5, 7, 9 };
int n = arr.Length;
int k = 2;
leftRotate(arr, k, n);
printArray(arr, n);
}
}
|
Javascript
<script>
function leftRotate(arr, d, n)
{
for (let i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}
function leftRotatebyOne(arr, n)
{
let i, temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n - 1] = temp;
}
function printArray(arr, size)
{
for (let i = 0; i < size; i++)
document.write(arr[i] + " " );
}
let arr = [ 1, 3, 5, 7, 9 ];
let n = arr.length;
let k = 2;
leftRotate(arr, k, n);
printArray(arr, n);
</script>
|
Note: the array itself gets updated after the rotation.
Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.
Method III(Using Reversal):
To left rotate an array by “k” units we will perform 3 simple reversals-
- Reverse the first “k” elements
- Reverse the last “n-k” elements where n is the size of the array
- Reverse the whole array
Code-
C++
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
void leftRotate( int arr[], int k, int n)
{
k = (k%n);
reverse(arr,arr+k);
reverse(arr+k,arr+n);
reverse(arr,arr+n);
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
cout << "\n" ;
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, k, n);
return 0;
}
|
C
#include <stdio.h>
void leftRotate( int arr[], int k, int n)
{
k = (k % n);
for ( int i = 0, j = k - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
for ( int i = k, j = n - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
for ( int i = 0, j = n - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
for ( int i = 0; i < n; i++) {
printf ( "%d " , arr[i]);
}
printf ( "\n" );
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
leftRotate(arr, k, n);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void leftRotate( int [] arr, int k)
{
k%=arr.length;
reverseArray(arr, 0 , k - 1 );
reverseArray(arr, k, arr.length - 1 );
reverseArray(arr, 0 , arr.length - 1 );
String result = Arrays.toString(arr).replaceAll( "\\[|\\]|,|\\s" , " " );
System.out.println(result);
}
public static void reverseArray( int [] arr, int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
public static void main(String[] args) {
int [] arr = { 1 , 3 , 5 , 7 , 9 };
int k = 2 ;
leftRotate(arr, k);
}
}
|
Python3
def leftRotate(arr, k):
k % len (arr)
arr = reverseArray(arr, 0 , k - 1 )
arr = reverseArray(arr, k, len (arr) - 1 )
arr = reverseArray(arr, 0 , len (arr) - 1 )
print ( " " .join( map ( str ,arr)))
def reverseArray(arr, start, end):
while start < end:
temp = arr[start]
arr[start] = arr[end]
arr[end] = temp
start + = 1
end - = 1
return arr
arr = [ 1 , 3 , 5 , 7 , 9 ]
k = 2
leftRotate(arr, k)
|
C#
using System;
using System.Collections.Generic;
class Program
{
static void Main( string [] args)
{
int [] arr = { 1, 3, 5, 7, 9 };
int n = arr.Length;
int k = 2;
leftRotate(arr, k, n);
Console.ReadKey();
}
static void leftRotate( int [] arr, int k, int n)
{
k%=n;
Array.Reverse(arr, 0, k);
Array.Reverse(arr, k, n - k);
Array.Reverse(arr, 0, n);
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
}
|
Javascript
function leftRotate(arr, k) {
k%=arr.length
arr = reverseArray(arr, 0, k - 1);
arr = reverseArray(arr, k, arr.length - 1);
arr = reverseArray(arr, 0, arr.length - 1);
console.log(arr.join( " " ));
}
function reverseArray(arr, start, end) {
while (start < end) {
let temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
return arr;
}
let arr = [1, 3, 5, 7, 9 ];
let n = arr.length;
let k = 2;
leftRotate(arr, k, n);
|
Kotlin
fun leftRotate(arr: IntArray, k: Int, n: Int) {
val rotation = k % n
for (i in 0 until rotation / 2 ) {
val temp = arr[i]
arr[i] = arr[rotation - i - 1 ]
arr[rotation - i - 1 ] = temp
}
for (i in 0 until (n - rotation) / 2 ) {
val temp = arr[rotation + i]
arr[rotation + i] = arr[n - i - 1 ]
arr[n - i - 1 ] = temp
}
for (i in 0 until n / 2 ) {
val temp = arr[i]
arr[i] = arr[n - i - 1 ]
arr[n - i - 1 ] = temp
}
for (i in arr) {
print( "$i " )
}
println()
}
fun main() {
val arr = intArrayOf( 1 , 3 , 5 , 7 , 9 )
val n = arr.size
val k = 2
leftRotate(arr, k, n)
}
fun leftRotate(arr: IntArray, k: Int, n: Int) {
val rotation = k % n
for (i in 0 until rotation / 2 ) {
val temp = arr[i]
arr[i] = arr[rotation - i - 1 ]
arr[rotation - i - 1 ] = temp
}
for (i in 0 until (n - rotation) / 2 ) {
val temp = arr[rotation + i]
arr[rotation + i] = arr[n - i - 1 ]
arr[n - i - 1 ] = temp
}
for (i in 0 until n / 2 ) {
val temp = arr[i]
arr[i] = arr[n - i - 1 ]
arr[n - i - 1 ] = temp
}
for (i in arr) {
print( "$i " )
}
println()
}
fun main() {
val arr = intArrayOf( 1 , 3 , 5 , 7 , 9 )
val n = arr.size
val k = 2
leftRotate(arr, k, n)
}
|
Note: the array itself gets updated after the rotation.
Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.
Share your thoughts in the comments
Please Login to comment...