Different Methods of Array Rotation in Python

In this tutorial, we will learn how we can rotate the array using the Python program. We will write a function for rotation (arry[], E, K) which will be used for rotating arry[] of size K = 8 by E = 4 elements.

We will get the following the array after rotating array by 4 elements:

Methods for Array Rotation:

In this session, we will discuss different methods users can use for rotation the array according to their requirements.

Method 1: By using temp array

In this method, we will use the following approach:

Step 1: We will store "E" elements in a temp array

Temp[] = [1, 3, 5, 7]

Step 2: we will shift the rest of the arry[]

arry[] = [9, 11, 13, 15]

Step 3: We will store the "E" elements

arry[] = [9, 11, 13, 15, 1, 3, 5, 7]

Example:

def rotate_array1(arry, K, E):
    temp_1 = []
    J = 0
    while (J < E):
        temp_1.append(arry[J])
        J = J + 1
    J = 0
    while (E < K):
        arry[J] = arry[E]
        J = J + 1
        E = E + 1
    arry[:] = arry[: J] + temp_1
    return arry
 
 
# Driver function to test above function
arry = [1, 3, 5, 7, 9, 11, 13, 15]
print ("Array after Rotation by 4 elements is: ", end = ' ')
print (rotate_array1(arry, len(arry), 4))

Output:

Array after Rotation by 4 elements is: [9, 11, 13, 15, 1, 3, 5, 7]

In the above method:

Time Complexity: O(K)                      [K = size of array]
Auxiliary Space: O(E)                         [E = number of elements to be rotated]

Method 2: By rotation elements one by one

In this method, we will use the following approach:

rotate_array1(arry[], E, K)

we will put the "for" condition that if J is equal to 0 and less than E, then the rotate_array1 function will rotate all elements by one

We have to store arry[0] for rotating elements by one in a temporary variable, "temp_1". Then we will more arry[1] to arry[0], arry[2] to arry[1] and so on. At last, we will have temp_1 on arry[n-1].

Example:

def rotate_array1(arry, K, E):
    for J in range(E):
        rotate_by_one(arry, K)
 
#Now, we will define a function to rotate arry[] of size K by 1
def rotate_by_one(arry, K):
    temp_1 = arry[0]
    for J in range(K - 1):
        arry[J] = arry[J + 1]
    arry[K - 1] = temp_1
         
 
# Then, we will define a utility function for printing an array
def print_array(arry, size_1):
    for J in range(size_1):
        print ("%d" % arry[J], end = " ")
 
  
# At last, we will write a driver program for testing the above functions 
arry = [1, 3, 5, 7, 9, 11, 13, 15]
rotate_array1(arry, 4, 8)
print ("The array after rotation: ") 
print_array(arry, 8)

Output:

The array after rotation: 
1 3 5 7 9 11 13 15

In the above method:

Time Complexity: O(K * E)                      [K = size of array]
						[E = number of elements to be rotated]
Auxiliary Space: O(1)                         

Method 3: By using a Juggling Algorithm

In this method, we will be dividing the array into different sets instead of moving elements one by one.

When the number of sets is equal to the greatest common divider of "K" and "E", the code will mode the elements into the sets.

If the greatest common divider is equal to 1, then the elements will move into one set only. Here, we will start with temp_1 = arry[0], and it will keep moving arry[J + E] to arry[J], and at last, it will store the temp_1 at the right place.

Let's see an example in which, K = 16 and E = 4. Greatest Common Divider (G_C_D) = 4

Steps -

At first, the elements will be moved into the first set - as shown in the following diagram:

After completion of this set, arry[] will be equal to [15, 12, 13, 14, 19, 16, 17, 18, 23, 20, 21, 22, 11, 23, 24, 25, 26]

Then in second set: arry will be [15, 16, 13, 14, 19, 20, 17, 18, 23, 24, 21, 22, 11, 12, 24, 25, 26]
In the third set: arry will be [15, 16, 17, 14, 19, 20, 21, 18, 23, 24, 25, 11, 12, 13, 26]
Finally, in the fourth set: arry will be [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 11, 12, 13, 14]

Example:

def rotate_array1(arry, K, E):
    for J in range(G_C_D(E, K)):
         
        # now, we will move the J-th values of blocks
        temp_1 = arry[J]
        S = J
        while 1:
            F = S + E
            if F >= K:
                F = F - K
            if F == J:
                break
            arry[S] = arry[F]
            S = F
        arry[S] = temp_1
 
# Then, we will define a utility function for printing an array

def print_array(arry, size_1):
    for J in range(size_1):
        print ("%d" % arry[J], end = " ")
  
#Here, we will define a Function for getting G_C_D of Sets
def G_C_D(X, Y):
    if Y == 0:
        return X;
    else:
        return G_C_D(Y, X % Y)
  
# Driver program to test above functions
arry = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
rotate_array1(arry, 4, 16)
print ("The array after rotation: ") 
print_array(arry, 16)

Output:

The array after rotation:
[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 11, 12, 13, 14]

In the above method:

Time Complexity: O(K )                      [K = size of array]
Auxiliary Space: O(1)                         

Method 4: By using List Slicing

In this method, we will use list slicing for rotating the elements of an array.

Example:

def rotate_List1(arry, E, K):
  arry[:] = arry[E:K] + arry[0:E]
  return arry
# We will write a driver program for testing the above functions 
arry = [11, 12, 13, 14, 15, 16, 17, 18]
print ("The List is: ", arry)
print ("The rotated list is: ")
print (rotate_List1(arry, 4, len(arry)))

Output:

The List is: [11, 12, 13, 14, 15, 16, 17, 18]
The rotated list is: 
[15, 16, 17, 18, 11, 12, 13, 14]

If we want to rotate the array by more than its length, we can use the mod method.

Suppose the array that we want to rotate by "E" is of "K" size and "E" is greater than "K". In this case, we have to calculate (E%K) and then we can rotate by the output after mod calculation.