Array Rotation Techniques in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2 Positions

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

DSA Go

package main
import "fmt"
func main() {
  arr := []int{10, 20, 30, 40, 50}
  n := 2
  rotated := append(arr[n:], arr[:n]...)
  fmt.Println(rotated)
}

A [50 10 20 30 40]

B [20 30 40 50 10]

C [30 40 50 10 20]

D [40 50 10 20 30]

💡 Hint

Think about moving the first n elements to the end of the array.

The code slices the array from index 2 to the end, then appends the first 2 elements at the end, effectively rotating left by 2.

❓ Predict Output

intermediate

Output of Right Rotation by 3 Positions

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

DSA Go

package main
import "fmt"
func main() {
  arr := []int{1, 2, 3, 4, 5, 6}
  n := 3
  length := len(arr)
  rotated := append(arr[length-n:], arr[:length-n]...)
  fmt.Println(rotated)
}

A [6 1 2 3 4 5]

B [4 5 6 1 2 3]

C [5 6 1 2 3 4]

D [3 4 5 6 1 2]

💡 Hint

Right rotation by n means last n elements come to front.

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

🔧 Debug

advanced

Identify the Error in Rotation Code

What error will this Go code produce when trying to rotate an array left by 4 positions?

DSA Go

package main
import "fmt"
func main() {
  arr := []int{7, 8, 9}
  n := 4
  rotated := append(arr[n:], arr[:n]...)
  fmt.Println(rotated)
}

A prints []

B compilation error: invalid slice index

C prints [7 8 9]

D runtime error: slice bounds out of range

💡 Hint

Check if n is larger than the array length.

The code tries to slice beyond the array length because n=4 but array length is 3, causing a runtime panic.

🧠 Conceptual

advanced

Minimum Rotations to Restore Original Array

Given an array of length 6, if you rotate it left by 2 positions three times in a row, what will be the final array compared to the original?

A The array returns to its original order

B The array is rotated left by 6 positions

C The array is rotated left by 2 positions

D The array is rotated left by 4 positions

💡 Hint

Think about total rotation after 3 times 2 positions.

Rotating left by 2 positions three times equals rotating left by 6 positions, which is the array length, so the array returns to original.

🚀 Application

expert

Output After Multiple Mixed Rotations

What is the output of this Go code after performing a left rotation by 1, then a right rotation by 2 on the array?

DSA Go

package main
import "fmt"
func main() {
  arr := []int{100, 200, 300, 400, 500}
  // Left rotate by 1
  n1 := 1
  arr = append(arr[n1:], arr[:n1]...)
  // Right rotate by 2
  n2 := 2
  length := len(arr)
  arr = append(arr[length-n2:], arr[:length-n2]...)
  fmt.Println(arr)
}

A [400 500 200 300 100]

B [300 400 500 100 200]

C [500 100 200 300 400]

D [200 300 400 500 100]

💡 Hint

Perform each rotation step carefully and track the array state.

After left rotation by 1, array is [200 300 400 500 100]. Then right rotation by 2 moves last two elements to front, resulting in [400 500 200 300 100].

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