Array Reversal Techniques in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reversing an array using two-pointer swap

What is the output of the following Go code that reverses an array using two pointers?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1, 2, 3, 4, 5}
    left, right := 0, len(arr)-1
    for left < right {
        arr[left], arr[right] = arr[right], arr[left]
        left++
        right--
    }
    fmt.Println(arr)
}

A [1 5 3 2 4]

B [5 4 3 2 1]

C [5 2 3 4 1]

D [1 2 3 4 5]

💡 Hint

Think about how swapping elements from both ends moves towards the center.

The code swaps elements from the start and end moving inward, reversing the array completely.

❓ Predict Output

intermediate

Output of reversing an array using a new array

What is the output of this Go code that reverses an array by creating a new reversed array?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{10, 20, 30, 40}
    rev := make([]int, len(arr))
    for i := range arr {
        rev[len(arr)-1-i] = arr[i]
    }
    fmt.Println(rev)
}

A [40 20 30 10]

B [10 20 30 40]

C [40 30 20 10]

D [10 40 30 20]

💡 Hint

Indexing from the end of the new array places elements in reverse order.

The code copies elements from the original array into the new array starting from the last index backwards.

🔧 Debug

advanced

Identify the error in this array reversal code

What error does this Go code produce when trying to reverse an array in place?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1, 2, 3, 4}
    for i := 0; i < len(arr)/2; i++ {
        arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i]
    }
    fmt.Println(arr)
}

A [4 3 2 1]

B [4 2 3 1]

C Index out of range runtime error

D [1 2 3 4]

💡 Hint

Check the loop boundary condition carefully.

The loop runs one step too many, causing indices 1 and 2 to be swapped twice, leading to incorrect reversal.

🧠 Conceptual

advanced

Time complexity of array reversal methods

What is the time complexity of reversing an array of size n using the two-pointer swap method?

A O(n)

B O(n^2)

C O(log n)

D O(1)

💡 Hint

Consider how many swaps happen relative to the array size.

Each element is swapped at most once, so the time grows linearly with the array size.

🚀 Application

expert

Reversing a linked list using array reversal logic

Given a singly linked list, which approach below best mimics the array reversal two-pointer swap method to reverse the list?

A Use recursion to reverse the pointers from the end to the start

B Iterate once, changing each node's next pointer to previous node

C Create a new list and append nodes from original list in reverse order

D Use two pointers from start and end, swapping node values until they meet

💡 Hint

Think about how array reversal swaps values at two ends simultaneously.

Using two pointers from start and end swapping values mimics the array two-pointer swap method, though it requires accessing nodes by index.

Practice

1. What does reversing an array mean in simple terms?

easy

A. Changing the order of elements so the last becomes first and first becomes last

B. Sorting the array in ascending order

C. Removing duplicate elements from the array

D. Adding new elements at the end of the array

Solution

1. Step 1: Understand array order

   An array has elements arranged in a sequence from first to last.

2. Step 2: Define reversal

   Reversing means flipping this order so the last element comes first and the first goes last.

3. Final Answer:

   Changing the order of elements so the last becomes first and first becomes last -> Option A

4. Quick Check:

   Reverse = Flip order [OK]

Hint: Reverse means flip the order of elements [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Believing reversal adds elements

2. Which of the following Go code snippets correctly reverses an array named arr of integers?

easy

A. for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] }

B. for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] }

C. for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] }

D. for i := 0; i < len(arr); i++ { arr[i] = arr[i+1] }

Solution

1. Step 1: Identify correct swapping logic

   for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } swaps elements from start and end moving towards the center, which is the correct reversal method.

2. Step 2: Check other options for errors

   for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] } overwrites elements without swapping, losing data. for i := 0; i < len(arr); i++ { arr[i] = arr[i+1] } shifts elements incorrectly. for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] } does nothing effective.

3. Final Answer:

   for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } -> Option C

4. Quick Check:

   Swap pairs from ends to center = for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } [OK]

Hint: Swap pairs from start and end until middle [OK]

Common Mistakes:

• Not swapping but overwriting elements
• Looping over full array instead of half
• Ignoring index bounds causing errors

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

arr := []int{1, 2, 3, 4, 5}
for i := 0; i < len(arr)/2; i++ {
    arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i]
}
fmt.Println(arr)

medium

A. [5 4 3 2 1]

B. [1 2 3 4 5]

C. [5 2 3 4 1]

D. [1 5 3 2 4]

Solution

1. Step 1: Trace swaps in loop

   Loop runs i=0 and i=1 (since len=5, half=2). - i=0: swap arr[0] and arr[4] -> arr becomes [5 2 3 4 1] - i=1: swap arr[1] and arr[3] -> arr becomes [5 4 3 2 1]

2. Step 2: Check final array after loop

   After both swaps, array is [5 4 3 2 1]. But the code prints after loop, so output is [5 4 3 2 1].

3. Final Answer:

   [5 4 3 2 1] -> Option A

4. Quick Check:

   Swapped ends inward = reversed array [OK]

Hint: Swap pairs from ends, middle stays same if odd length [OK]

Common Mistakes:

• Only swapping first and last once
• Not swapping pairs correctly
• Confusing output with original array

4. Find the error in this Go code that tries to reverse an array arr:

for i := 0; i <= len(arr)/2; i++ {
    arr[i] = arr[len(arr)-1-i]
}

medium

A. The loop should run only till i < len(arr)/2, not <=

B. It overwrites elements without swapping, losing data

C. The code swaps elements correctly, no error

D. The index len(arr)-1-i is out of range

Solution

1. Step 1: Analyze loop and assignment

   The code assigns arr[i] = arr[len(arr)-1-i] without swapping, so original arr[i] is lost.

2. Step 2: Understand consequence

   Without swapping, the array is partially overwritten and not reversed correctly.

3. Final Answer:

   It overwrites elements without swapping, losing data -> Option B

4. Quick Check:

   Overwrite without swap loses data [OK]

Hint: Always swap pairs, don't overwrite [OK]

Common Mistakes:

• Using <= instead of < in loop
• Not swapping both elements
• Ignoring data loss from overwrite

5. Given a slice arr := []int{1, 2, 3, 4, 5, 6}, write a Go function that reverses the slice in place and returns it. Which of the following is the correct implementation?

hard

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

B. func reverse(arr []int) []int {
for i := 0; i <= len(arr)/2; i++ {
arr[i] = arr[len(arr)-1-i]
}
return arr
}

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

D. func reverse(arr []int) []int {
for i := 0; i < len(arr)/2; i++ {
arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i]
}
return arr
}

Solution

1. Step 1: Check correct swapping logic

   func reverse(arr []int) []int { for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } return arr } swaps elements from start and end moving inward, correctly reversing the slice in place.

2. Step 2: Verify other options

   func reverse(arr []int) []int { for i := 0; i < len(arr); i++ { arr[i] = arr[len(arr)-1-i] } return arr } overwrites without swapping, losing data. func reverse(arr []int) []int { for i := len(arr)-1; i >= 0; i-- { arr[i] = arr[i] } return arr } does nothing effective. func reverse(arr []int) []int { for i := 0; i <= len(arr)/2; i++ { arr[i] = arr[len(arr)-1-i] } return arr } overwrites without swapping and uses <= causing index issues.

3. Final Answer:

   func reverse(arr []int) []int { for i := 0; i < len(arr)/2; i++ { arr[i], arr[len(arr)-1-i] = arr[len(arr)-1-i], arr[i] } return arr } -> Option D

4. Quick Check:

   Swap pairs from ends to center and return [OK]

Hint: Swap pairs up to half length, then return [OK]

Common Mistakes:

• Overwriting elements without swapping
• Looping beyond half length
• Not returning the modified slice