Array Rotation Techniques in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Go

func rotateLeftByOne(arr []int) []int {
    first := arr[0]
    for i := 0; i < len(arr)-1; i++ {
        arr[i] = arr[[1]]
    }
    arr[len(arr)-1] = first
    return arr
}

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

Alen(arr)-1

Bi-1

Ci+1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using i-1 instead of i+1 causes index out of range error.

Assigning arr[i] = arr[0] copies the first element repeatedly.

We move each element to the position of the previous element, so arr[i] = arr[i+1].

2fill in blank

medium

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

DSA Go

func rotateRightByOne(arr []int) []int {
    last := arr[len(arr)-1]
    for i := len(arr)-1; i > 0; i-- {
        arr[i] = arr[[1]]
    }
    arr[0] = last
    return arr
}

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

Ai-1

Bi+1

C0

Dlen(arr)-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using i+1 causes index out of range error.

Not updating arr[0] with the last element.

We move each element to the position of the next element, so arr[i] = arr[i-1].

3fill in blank

hard

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

DSA Go

func reverse(arr []int, start int, end int) {
    for start < end {
        arr[start], arr[end] = arr[end], arr[start]
        start++
        end--
    }
}

func rotateLeft(arr []int, d int) []int {
    n := len(arr)
    d = d % n
    reverse(arr, 0, d-1)
    reverse(arr, d, n-1)
    reverse(arr, 0, [1])
    return arr
}

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

An-1

Bd-1

Cn-d-1

Dd

Attempts:

3 left

💡 Hint

Common Mistakes

Using d-1 or d as the end index causes incorrect rotation.

Not taking modulo of d with n causes index errors.

After reversing the first d elements and the rest, we reverse the whole array from 0 to n-1 to complete the rotation.

4fill in blank

hard

Fill both blanks to complete the code that rotates the array right by d positions using the reversal algorithm.

DSA Go

func rotateRight(arr []int, d int) []int {
    n := len(arr)
    d = d % n
    reverse(arr, 0, [1])
    reverse(arr, n-d, n-1)
    reverse(arr, 0, n-1)
    return arr
}

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

An-1

Bd-1

C0

Dn-d-1

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the indices for the two reverse calls.

Not taking modulo of d with n.

To rotate right by d, first reverse the first n-d elements (0 to n-d-1), then last d elements, then the whole array.

5fill in blank

hard

Fill all three blanks to complete the code that rotates the array left by d positions using a temporary slice.

DSA Go

func rotateLeftTemp(arr []int, d int) []int {
    n := len(arr)
    d = d % n
    temp := make([]int, d)
    copy(temp, arr[[1]:[2]])
    for i := 0; i < n-d; i++ {
        arr[i] = arr[i+[3]]
    }
    for i := 0; i < d; i++ {
        arr[n-d+i] = temp[i]
    }
    return arr
}

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

A0

Bd

Cn

Dn-d

Attempts:

3 left

💡 Hint

Common Mistakes

Copying wrong slice range to temp.

Incorrectly shifting elements causing overwrite.

We copy the first d elements (0 to d) to temp, shift the rest left by d, then copy temp to the end.

Practice

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

easy

A. Reverses the entire array

B. Moves the last element to the front and shifts others right by one

C. Moves the first element to the end and shifts others left by one

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.

2. Step 2: Effect on array elements

   All other elements shift one position to the left.

3. Final Answer:

   Moves the first element to the end and shifts others left by one -> Option C

4. Quick Check:

   Left rotate 1 = first element to end [OK]

Hint: Left rotate by 1 moves front element to back [OK]

Common Mistakes:

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

2. Which of the following Go code snippets correctly rotates an array arr to the right by 1 position?

easy

A. arr = append(arr[len(arr)-1:], arr[:len(arr)-1])

B. arr = append(arr[1:], arr[0])

C. arr = append(arr[:len(arr)-1], arr[len(arr)-1])

D. arr = append([]int{arr[len(arr)-1]}, arr[:len(arr)-1]...)

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 moves last element to front.

2. Step 2: Check code correctness

   arr = append([]int{arr[len(arr)-1]}, arr[:len(arr)-1]...) prepends last element to the rest correctly using slicing and append.

3. Final Answer:

   arr = append([]int{arr[len(arr)-1]}, arr[:len(arr)-1]...) -> Option D

4. Quick Check:

   Right rotate 1 = last element front [OK]

Hint: Right rotate by 1 prepends last element [OK]

Common Mistakes:

• Using wrong slice indices
• Appending single element without slice expansion
• Confusing left and right rotation code

3. What is the output of the following Go code?

arr := []int{10, 20, 30, 40, 50}
k := 2
n := len(arr)
k = k % n
rotated := append(arr[n-k:], arr[:n-k]...)
fmt.Println(rotated)

medium

A. [40 50 10 20 30]

B. [30 40 50 10 20]

C. [20 30 40 50 10]

D. [50 10 20 30 40]

Solution

1. Step 1: Calculate effective rotation

   k=2, n=5, so k%5=2 means rotate right by 2.

2. Step 2: Perform rotation

   arr[n-k:] = arr[3:] = [40,50], arr[:n-k] = arr[:3] = [10,20,30]. Append gives [40,50,10,20,30].

3. Final Answer:

   [40 50 10 20 30] -> Option A

4. Quick Check:

   Right rotate 2 = last 2 front [OK]

Hint: Right rotate by k = last k elements front [OK]

Common Mistakes:

• Not using modulo for k
• Swapping slice indices incorrectly
• Confusing left and right rotation

4. Identify the error in this Go code that attempts to left rotate an array by 3 positions:

arr := []int{1, 2, 3, 4, 5}
k := 3
rotated := append(arr[k:], arr[k:]...)
fmt.Println(rotated)

medium

A. The slice is appended twice from the same index, missing first part

B. The variable k is not used correctly for rotation

C. The array length is not considered for rotation

D. The append function is used incorrectly without slice expansion

Solution

1. Step 1: Analyze append arguments

   Both slices are arr[k:], so elements from index 3 to end repeated twice.

2. Step 2: Identify missing part

   Left rotation requires appending arr[:k] after arr[k:], but code repeats arr[k:] instead.

3. Final Answer:

   The slice is appended twice from the same index, missing first part -> Option A

4. Quick Check:

   Left rotate needs arr[k:] + arr[:k] [OK]

Hint: Append arr[k:] then arr[:k] for left rotation [OK]

Common Mistakes:

• Appending same slice twice
• Ignoring first k elements in rotation
• Not using slice expansion operator

5. Given an array arr = []int{5, 10, 15, 20, 25, 30}, how would you rotate it left by 4 positions using Go slices? Choose the correct code snippet.

hard

A. rotated := append(arr[:4], arr[4:]...)

B. rotated := append(arr[4:], arr[:4]...)

C. rotated := append(arr[len(arr)-4:], arr[:len(arr)-4]...)

D. rotated := append(arr[len(arr)-4:], arr[len(arr)-4:]...)

Solution

1. Step 1: Understand left rotation by 4

   Left rotation by 4 moves first 4 elements to the end.

2. Step 2: Use slicing correctly

   arr[4:] gives elements from index 4 to end, arr[:4] gives first 4 elements. Append arr[4:] + arr[:4] rotates left by 4.

3. Final Answer:

   rotated := append(arr[4:], arr[:4]...) -> Option B

4. Quick Check:

   Left rotate 4 = arr[4:] + arr[:4] [OK]

Hint: Left rotate k = arr[k:] + arr[:k] [OK]

Common Mistakes:

• Swapping slice order
• Using wrong slice indices
• Confusing left and right rotation