Array Rotation Techniques in DSA Python - Execution Trace

Concept Flow - Array Rotation Techniques

Start with array

↓

Choose rotation direction

↓

Left Rotate

↓

Shift elements

↓

Wrap around ends

↓

Resulting rotated array

Start with an array, choose left or right rotation, shift elements accordingly, wrap around the ends, and get the rotated array.

Execution Sample

DSA Python

arr = [1, 2, 3, 4, 5]
rotate_by = 2
# Left rotate by 2
rotated = arr[rotate_by:] + arr[:rotate_by]
print(rotated)

This code left rotates the array by 2 positions by slicing and concatenating.

Execution Table

Step	Operation	Array State	Explanation	Visual State
1	Start	[1, 2, 3, 4, 5]	Initial array	1 -> 2 -> 3 -> 4 -> 5 -> null
2	Choose rotation	Left by 2	Decide to rotate left by 2 positions	N/A
3	Slice from index 2 to end	[3, 4, 5]	Take elements from index 2 to end	3 -> 4 -> 5 -> null
4	Slice from start to index 2	[1, 2]	Take elements from start to index 2	1 -> 2 -> null
5	Concatenate slices	[3, 4, 5, 1, 2]	Combine slices to form rotated array	3 -> 4 -> 5 -> 1 -> 2 -> null
6	Print result	[3, 4, 5, 1, 2]	Output the rotated array	3 -> 4 -> 5 -> 1 -> 2 -> null
7	End	Rotation complete	Rotation finished	N/A

💡 Rotation done after slicing and concatenation

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
arr	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]
rotate_by	2	2	2	2	2
rotated (temp slice 1)	N/A	[3, 4, 5]	[3, 4, 5]	[3, 4, 5]	[3, 4, 5]
rotated (temp slice 2)	N/A	N/A	[1, 2]	[1, 2]	[1, 2]
rotated (final)	N/A	N/A	N/A	[3, 4, 5, 1, 2]	[3, 4, 5, 1, 2]

Key Moments - 3 Insights

Why do we slice the array into two parts before concatenating?

Because rotating means moving elements from one end to the other. Slicing splits the array at the rotation point, so we can put the second part first and then the first part, as shown in steps 3, 4, and 5 of the execution_table.

What happens if rotate_by is 0 or equal to array length?

If rotate_by is 0 or equal to the array length, the slices will be the whole array and empty array respectively, so concatenation returns the original array unchanged. This is why the rotation stops without changing the array.

Why do we use arr[rotate_by:] + arr[:rotate_by] for left rotation?

Because arr[rotate_by:] takes elements after the rotation point, and arr[:rotate_by] takes elements before it. Putting the second slice first simulates moving the first part to the end, which is the definition of left rotation.

Visual Quiz - 3 Questions

Look at the execution_table at Step 5, what is the array state after concatenation?

A [5, 4, 3, 2, 1]

B [1, 2, 3, 4, 5]

C [3, 4, 5, 1, 2]

D [2, 3, 4, 5, 1]

💡 Hint

Check the 'Array State' column at Step 5 in the execution_table.

At which step does the array get split into two slices?

A Step 3 and Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Look at the 'Operation' column where slicing happens in the execution_table.

If rotate_by was 0, what would be the final rotated array?

A []

B [1, 2, 3, 4, 5]

C [5, 4, 3, 2, 1]

D [2, 3, 4, 5, 1]

💡 Hint

Refer to the key_moments explanation about rotate_by being 0 or equal to array length.

Concept Snapshot

Array Rotation Techniques:
- Rotate array left or right by shifting elements
- Left rotate by k: arr[k:] + arr[:k]
- Right rotate by k: arr[-k:] + arr[:-k]
- Rotation wraps elements around ends
- Useful for cyclic shifts in arrays

Full Transcript

Array rotation means moving elements in an array to the left or right by a certain number of positions. We do this by slicing the array into two parts at the rotation point and then joining them in swapped order. For example, left rotating by 2 means taking elements from index 2 to end, then from start to index 2, and joining them. This shifts the array elements left by 2 positions, wrapping the first two elements to the end. If the rotation count is zero or equal to the array length, the array stays the same. This technique is simple and efficient for rotating arrays.

Practice

1. What does rotating an array to the left by 1 position do to the elements?

easy

A. Moves each element one step to the right, last element goes to the front

B. Moves each element one step to the left, first element goes to the end

C. Reverses the array

D. Sorts the array in ascending order

Solution

1. Step 1: Understand left rotation

   Left rotation by 1 means the element at index 0 moves to the end, and all others shift left by one.

2. Step 2: Visualize the movement

   For example, [1, 2, 3] becomes [2, 3, 1] after left rotation by 1.

3. Final Answer:

   Moves each element one step to the left, first element goes to the end -> Option B

4. Quick Check:

   Left rotation = shift left + wrap first element [OK]

Hint: Left rotation shifts left, first element moves to end [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Thinking rotation sorts the array
• Assuming rotation reverses the array

2. Which of the following is the correct Python syntax to rotate an array arr to the right by 2 positions using slicing?

easy

A. arr = arr[-2:] + arr[:-2]

B. arr = arr[2:] + arr[:2]

C. arr = arr[:2] + arr[2:]

D. arr = arr[-2:] - arr[:-2]

Solution

1. Step 1: Understand right rotation with slicing

   Right rotation by 2 means last 2 elements move to front, rest shift right.

2. Step 2: Apply slicing syntax

   arr[-2:] gets last 2 elements, arr[:-2] gets all except last 2. Concatenating gives rotated array.

3. Final Answer:

   arr = arr[-2:] + arr[:-2] -> Option A

4. Quick Check:

   Right rotation by 2 = last 2 + rest [OK]

Hint: Right rotation by k = last k elements + rest [OK]

Common Mistakes:

• Using + operator incorrectly with slices
• Confusing left and right rotation slices
• Using subtraction operator instead of concatenation

3. What is the output of the following code?

arr = [10, 20, 30, 40, 50]
k = 3
rotated = arr[k:] + arr[:k]
print(rotated)

medium

A. [50, 10, 20, 30, 40]

B. [30, 40, 50, 10, 20]

C. [20, 30, 40, 50, 10]

D. [40, 50, 10, 20, 30]

Solution

1. Step 1: Identify rotation type

   arr[k:] + arr[:k] rotates array left by k=3 positions.

2. Step 2: Perform slicing and concatenation

   arr[3:] = [40, 50], arr[:3] = [10, 20, 30], combined = [40, 50, 10, 20, 30]

3. Final Answer:

   [40, 50, 10, 20, 30] -> Option D

4. Quick Check:

   Left rotation by 3 = [40,50] + [10,20,30] [OK]

Hint: arr[k:] + arr[:k] = left rotate by k [OK]

Common Mistakes:

• Mixing left and right rotation logic
• Incorrect slicing indices
• Misreading k value

4. The following code is intended to rotate an array arr to the right by k positions. What is the error?

def rotate_right(arr, k):
    n = len(arr)
    k = k % n
    rotated = arr[k:] + arr[:k]
    return rotated

print(rotate_right([1,2,3,4,5], 2))

medium

A. The slicing indices perform left rotation, not right rotation

B. The modulo operation is incorrect

C. The function does not return anything

D. The print statement is missing parentheses

Solution

1. Step 1: Analyze slicing for rotation

   arr[k:] + arr[:k] rotates array left by k, not right.

2. Step 2: Correct right rotation slicing

   Right rotation by k should be arr[-k:] + arr[:-k].

3. Final Answer:

   The slicing indices perform left rotation, not right rotation -> Option A

4. Quick Check:

   Right rotation needs arr[-k:] + arr[:-k] [OK]

Hint: Right rotation uses negative slicing indices [OK]

Common Mistakes:

• Using left rotation slices for right rotation
• Ignoring modulo to handle k > n
• Forgetting to return the rotated array

5. Given an array arr = [3, 8, 9, 7, 6], how would you rotate it to the right by k = 3 positions using a single Python statement without slicing?

hard

A. Use arr.sort() then reverse

B. Use arr.reverse() three times

C. Use a loop to pop last element and insert at front 3 times

D. Use arr.append(arr.pop()) once

Solution

1. Step 1: Understand rotation without slicing

   Rotating right by 3 means moving last element to front 3 times.

2. Step 2: Use loop with pop and insert

   Loop 3 times: pop last element and insert at index 0 to rotate right.

3. Final Answer:

   Use a loop to pop last element and insert at front 3 times -> Option C

4. Quick Check:

   Pop + insert at front repeated k times = right rotation [OK]

Hint: Pop last and insert front k times for right rotation [OK]

Common Mistakes:

• Using reverse instead of rotation
• Sorting array mistakenly
• Only popping once instead of k times