Array Rotation Techniques in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after rotating array left by 2 positions

What is the output of the following Python code that rotates an array to the left by 2 positions?

DSA Python

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

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

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

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

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

💡 Hint

Think about how slicing works for left rotation.

The code slices the array from index 2 to the end, then adds the first two elements at the end. This results in the array rotated left by 2 positions.

❓ Predict Output

intermediate

Output after rotating array right by 3 positions

What is the output of this Python code that rotates an array to the right by 3 positions?

DSA Python

arr = [1, 2, 3, 4, 5, 6]
rotations = 3
rotated = arr[-rotations:] + arr[:-rotations]
print(rotated)

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

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

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

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

💡 Hint

Right rotation means taking last elements to front.

The code takes the last 3 elements and places them at the front, then adds the rest after.

🔧 Debug

advanced

Identify the error in this array rotation code

What error does this code raise when trying to rotate an array left by n positions?

DSA Python

def rotate_left(arr, n):
    n = n % len(arr)
    return arr[n:] + arr[n]

print(rotate_left([1, 2, 3, 4], 2))

A SyntaxError: invalid syntax

B IndexError: list index out of range

C TypeError: can only concatenate list (not "int") to list

D No error, output: [3, 4, 1, 2]

💡 Hint

Look at what arr[n] returns and what is being concatenated.

arr[n] returns a single element (an int), but arr[n:] is a list. Adding a list and an int causes a TypeError.

❓ Predict Output

advanced

Output after rotating array right by length of array

What is the output of this code that rotates an array right by its own length?

DSA Python

arr = [7, 8, 9]
rotations = len(arr)
rotated = arr[-rotations:] + arr[:-rotations]
print(rotated)

A [7, 8, 9]

B []

C [8, 9, 7]

D [9, 7, 8]

💡 Hint

Rotating by array length should return the original array.

Rotating an array by its length results in the same array because the elements cycle back to original positions.

🧠 Conceptual

expert

Minimum rotations to restore original array

Given an array of length 6, what is the minimum number of right rotations needed to restore the array to its original order?

A 0

B 1

C 3

D 6

💡 Hint

Think about how many rotations bring the array back to start.

Rotating right by the array length (6) returns the array to its original order. Smaller rotations do not restore it fully.

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