Array Rotation Techniques in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to rotate the array to the left by one position.

DSA Python

def rotate_left_by_one(arr):
    first = arr[0]
    for i in range(len(arr) - 1):
        arr[i] = arr[i[1]1]
    arr[-1] = first
    return arr

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

Drag options to blanks, or click blank then click option'

A+

B-

C*

D//

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes wrong indexing.

Using '*' or '//' causes syntax or runtime errors.

We add 1 to the current index to shift elements left by one.

2fill in blank

medium

Complete the code to rotate the array to the right by one position.

DSA Python

def rotate_right_by_one(arr):
    last = arr[-1]
    for i in range(len(arr) - 1, 0, [1]):
        arr[i] = arr[i - 1]
    arr[0] = last
    return arr

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

Drag options to blanks, or click blank then click option'

A1

B-1

C0

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using positive step causes infinite loop or wrong rotation.

Using 0 as step causes error.

We use -1 to move backward through the array indices.

3fill in blank

hard

Fix the error in the code to rotate the array left by d positions using slicing.

DSA Python

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

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

Drag options to blanks, or click blank then click option'

A]

B[

C[-

D[:

Attempts:

3 left

💡 Hint

Common Mistakes

Missing ':' causes syntax error.

Using wrong slice indices causes wrong output.

The slice arr[:d] selects the first d elements to move to the end.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each element to its rotated position after left rotation by 1.

DSA Python

arr = [10, 20, 30, 40]
rotated_dict = {arr[i]: arr[(i [1] 1) [2] len(arr)] for i in range(len(arr))}
print(rotated_dict)

Drag options to blanks, or click blank then click option'

A+

B-

C%

D//

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes wrong mapping.

Using '//' instead of '%' causes wrong index wrapping.

We add 1 to index i and use modulo to wrap around the array length.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase elements to their rotated values after right rotation by 2.

DSA Python

arr = ['a', 'b', 'c', 'd', 'e']
rotated_dict = {{
    arr[i].[1](): arr[(i [2] 2) [3] len(arr)]
    for i in range(len(arr))
}}
print(rotated_dict)

Drag options to blanks, or click blank then click option'

Aupper

B+

C%

Dlower

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'lower' instead of 'upper' changes key case incorrectly.

Using '-' instead of '+' causes wrong rotation direction.

Using '//' instead of '%' causes wrong index wrapping.

Use upper() to capitalize keys, add 2 to index, and use modulo for wrapping.

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