Array Rotation Techniques in DSA Go - Build from Scratch

Array Rotation Techniques

📖 Scenario: You are working on a simple program that helps a store manager rotate the order of products on display shelves. This rotation helps to show different products at the front each day.

🎯 Goal: Build a Go program that rotates an array of product IDs to the right by a given number of steps and then prints the rotated array.

📋 What You'll Learn

Create an array called products with the exact values 101, 102, 103, 104, 105

Create a variable called steps and set it to 2

Write code to rotate the products array to the right by steps positions

Print the rotated array in the format: [104 105 101 102 103]

💡 Why This Matters

🌍 Real World

Rotating arrays is useful in scheduling, gaming, and UI where elements need to cycle positions.

💼 Career

Understanding array manipulation is fundamental for software developers working with data transformations and algorithms.

1

Create the initial array of product IDs

Create an array called products with the exact values 101, 102, 103, 104, 105.

DSA Go

# Create the products array with values 101, 102, 103, 104, 105
# Your code here

Hint

Use a slice of integers with the exact values given.

2

Add the number of rotation steps

Create a variable called steps and set it to 2.

DSA Go

package main

import "fmt"

func main() {
    products := []int{101, 102, 103, 104, 105}
    // Create the steps variable and set it to 2
    // Your code here
}

Hint

Use a simple integer variable named steps and assign it the value 2.

3

Rotate the array to the right by the given steps

Write code to rotate the products array to the right by steps positions. Use slicing and concatenation to create the rotated array and store it back in products.

DSA Go

package main

import "fmt"

func main() {
    products := []int{101, 102, 103, 104, 105}
    steps := 2
    // Rotate the products array to the right by steps
    // Your code here
}

Hint

Use modulo to handle steps larger than array length. Then use slicing and append to rotate.

4

Print the rotated array

Write a fmt.Println statement to print the rotated products array.

DSA Go

package main

import "fmt"

func main() {
    products := []int{101, 102, 103, 104, 105}
    steps := 2
    n := len(products)
    steps = steps % n
    products = append(products[n-steps:], products[:n-steps]...)
    // Print the rotated products array
    // Your code here
}

Hint

Use fmt.Println(products) to print the rotated array.

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