The Wayback Machine - https://web.archive.org/web/20211205215646/https://www.geeksforgeeks.org/quickly-find-multiple-left-rotations-of-an-array/
Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Quickly find multiple left rotations of an array | Set 1

  • Difficulty Level : Easy
  • Last Updated : 19 May, 2021

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

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Simple Approach: We have already discussed different approaches given in below posts. 
 



  1. Left Rotation of array (Simple and Juggling Algorithms).
  2. Block swap algorithm for array rotation
  3. Reversal algorithm for array rotation

The best of above approaches take O(n) time and O(1) extra space. 
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 temp[0..2n-1] array. 
Step 2: Starting position of 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.
 

C++




// CPP implementation of left rotation of
// an array K number of times
#include<bits/stdc++.h>
using namespace std;
 
// Fills temp[] with two copies of arr[]
void preprocess(int arr[], int n, int temp[])
{
    // Store arr[] elements at i and i + n
    for (int i = 0; i<n; i++)
         temp[i] = temp[i + n] = arr[i];
}
 
// Function to left rotate an array k times
void leftRotate(int arr[], int n, int k, int temp[])
{
    // Starting position of array after k
    // rotations in temp[] will be k % n
    int start = k % n;
 
    // Print array after k rotations
    for (int i = start; i < start + n; i++)
         cout << temp[i] << " ";
 
    cout << endl;
}
 
// Driver program
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



// Java implementation of left rotation of
// an array K number of times
class LeftRotate
{
    // Fills temp[] with two copies of arr[]
    static void preprocess(int arr[], int n,
                                   int temp[])
    {
        // Store arr[] elements at i and i + n
        for (int i = 0; i<n; i++)
             temp[i] = temp[i + n] = arr[i];
    }
  
    // Function to left rotate an array k time
    static void leftRotate(int arr[], int n, int k,
                                    int temp[])
    {
        // Starting position of array after k
        // rotations in temp[] will be k % n
        int start = k % n;
      
        // Print array after k rotations
        for (int i = start; i < start + n; i++)
            System.out.print(temp[i] + " ");
      
        System.out.print("\n");
    }
 
    // Driver program
    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);
    }
}
/*This code is contributed by Prakriti Gupta*/
Python3



# Python3 implementation of left rotation
# of an array K number of times
 
# Fills temp with two copies of arr
def preprocess(arr, n):
    temp = [None] * (2 * n)
     
    # Store arr elements at i and i + n
    for i in range(n):
        temp[i] = temp[i + n] = arr[i]
    return temp
 
# Function to left rotate an array k times
def leftRotate(arr, n, k, temp):
     
    # Starting position of array after k
    # rotations in temp will be k % n
    start = k % n
     
    # Print array after k rotations
    for i in range(start, start + n):
        print(temp[i], end = " ")
    print("")
 
# Driver program
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)
 
# This code is contributed by Sanghamitra Mishra
C#



// C# implementation of left rotation of
// an array K number of times
using System;
class LeftRotate
{
    // Fills temp[] with two copies of arr[]
    static void preprocess(int []arr, int n,
                                int[] temp)
    {
        // Store arr[] elements at i and i + n
        for (int i = 0; i<n; i++)
            temp[i] = temp[i + n] = arr[i];
    }
 
    // Function to left rotate an array k time
    static void leftRotate(int []arr, int n, int k,
                                    int []temp)
    {
        // Starting position of array after k
        // rotations in temp[] will be k % n
        int start = k % n;
     
        // Print array after k rotations
        for (int i = start; i < start + n; i++)
        Console.Write(temp[i] + " ");
        Console.WriteLine();
    }
 
    // Driver program
    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);
    }
}
//This code is contributed by vt_m.
PHP



<?php
// PHP implementation of
// left rotation of an
// array K number of times
 
// Fills $temp with
// two copies of $arr
function preprocess(&$arr, $n,
                    &$temp)
{
    // Store $arr elements
    // at i and i + n
    for ($i = 0; $i < $n; $i++)
        $temp[$i] = $temp[$i + $n] = $arr[$i];
}
 
// Function to left rotate
// an array k times
function leftRotate(&$arr, $n,
                     $k, &$temp)
{
    // Starting position of
    // array after k rotations
    // in temp[] will be k % n
    $start = $k % $n;
 
    // Print array after
    // k rotations
    for ($i = $start;
         $i < $start + $n; $i++)
        echo $temp[$i] . " ";
 
    echo "\n";
}
 
// Driver Code
$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);
 
// This code is contributed
// by ChitraNayal
?>
Javascript



<script>
 
// Javascript implementation of left rotation of
// an array K number of times
 
    // Fills temp with two copies of arr
    function preprocess(arr , n , temp) {
        // Store arr elements at i and i + n
        for (i = 0; i < n; i++)
            temp[i] = temp[i + n] = arr[i];
    }
 
    // Function to left rotate an array k time
    function leftRotate(arr , n , k , temp) {
        // Starting position of array after k
        // rotations in temp will be k % n
        var start = k % n;
 
        // Print array after k rotations
        for (i = start; i < start + n; i++)
            document.write(temp[i] + " ");
 
        document.write("<br/>");
    }
 
    // Driver program
     
        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);
 
// This code contributed by gauravrajput1
 
</script>
Output:  
5 7 9 1 3 
7 9 1 3 5 
9 1 3 5 7 
Note that the task to find starting address of rotation takes O(1) time. It is printing the elements that take O(n) time.
Space optimized Approach: The above method takes extra space. Below given is a space-optimized solution. Thanks to frenzy77 for suggesting this approach.
 
C++



// CPP implementation of left rotation of
// an array K number of times
#include<bits/stdc++.h>
using namespace std;
 
// Function to left rotate an array k times
void leftRotate(int arr[], int n, int k)
{
    // Print array after k rotations
    for (int i = k; i < k + n; i++)
        cout << arr[i%n] << " ";
}
 
// Driver program
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



// Java implementation of
// left rotation of an
// array K number of times
 
import java.io.*;
 
class GFG
{
 
// Function to left rotate
// an array k times
static void leftRotate(int arr[],
                       int n, int k)
{
    // Print array after
    // k rotations
    for (int i = k; i < k + n; i++)
        System.out.print(arr[i % n] + " ");
}
 
// Driver Code
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();
}
}
 
// This code is contributed by ajit
Python 3



# Python3 implementation of
# left rotation of an array
# K number of times
 
# Function to left rotate
# an array k times
def leftRotate(arr, n, k):
     
    # Print array
    # after k rotations
    for i in range(k, k + n):
        print(str(arr[i % n]),
                   end = " ")
 
# Driver Code
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()
 
# This code is contributed
# by ChitraNayal
C#



// C# implementation of
// left rotation of an
// array K number of times
using System;
 
class GFG
{
 
// Function to left rotate
// an array k times
static void leftRotate(int []arr,
                       int n, int k)
{
    // Print array after
    // k rotations
    for (int i = k; i < k + n; i++)
        Console.Write(arr[i % n] + " ");
}
 
// Driver Code
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();
}
}
 
// This code is contributed
// by akt_mit
PHP



<?php
 
// PHP implementation of left rotation of
// an array K number of times
 
// Function to left rotate an array k times
function leftRotate($arr, $n, $k)
{
     
    // Print array after k rotations
    for ($i = $k; $i < $k + $n; $i++)
        echo $arr[$i % $n] ," ";
}
 
// Driver program
$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";
 
// This code is contributed by aj_36
?>
Javascript



<script>
 
// JavaScript implementation of
// left rotation of an
// array K number of times
 
 
// Function to left rotate
// an array k times
function leftRotate(arr, n, k)
{
    // Print rray after
    // k rotations
    for (let i = k; i < k + n; i++)
        document.write(arr[i % n] + " ");
}
 
// Driver Code
 
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 
 
 
This article is contributed by nuclode and Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
 
 
 



My Personal Notes
arrow_drop_up
Previous
Find the Rotation Count in Rotated Sorted array
Next

Find the minimum element in a sorted and rotated array
Recommended Articles
Page :
Find the Mth element of the Array after K left rotations
23, Jul 20
Find maximum value of Sum( i*arr[i]) with only rotations on given array allowed
17, Sep 15
Count clockwise array rotations required to maximize count of array elements present at indices same as their value
24, Nov 20
Find element at given index after a number of rotations
24, Sep 17
Check if strings are rotations of each other or not | Set 2
04, Jun 18
Minimum circular rotations to obtain a given numeric string by avoiding a set of given strings
22, May 20
Count of elements such that difference between sum of left and right sub arrays is equal to a multiple of k
17, Jan 20
Maximum sum of i*arr[i] among all rotations of a given array
27, Jul 16
Range sum queries for anticlockwise rotations of Array by K indices
14, May 20
Print all possible rotations of a given Array
25, Jun 20
Mth element after K Right Rotations of an Array
25, Jul 20
Count rotations required to sort given array in non-increasing order
09, Dec 20
Count of rotations required to generate a sorted array
20, Jun 20
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Find Array formed by adding each element of given array with largest element in new array to its left
24, Mar 20
A Program to check if strings are rotations of each other or not
26, May 09
Check if all rows of a matrix are circular rotations of each other
14, Jan 17
Count rotations divisible by 4
28, Mar 17
Minimum rotations required to get the same string
17, Jul 17
Count rotations in sorted and rotated linked list
26, Sep 17
Count rotations divisible by 8
09, Dec 17
Generating numbers that are divisor of their right-rotations
14, Oct 18
Maximum contiguous 1 possible in a binary string after k rotations
20, Oct 18
Check whether all the rotations of a given number is greater than or equal to the given number or not
14, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!