Selection Sort Algorithm in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the outer loop for selection sort.

DSA Go

for i := 0; i < [1]; i++ {
    // find the minimum element in unsorted array
}

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

Alen(arr) - 1

Blen(arr)

Clen(arr) + 1

Dlen(arr) / 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(arr) as loop limit causes index out of range error.

Using len(arr) + 1 is invalid and causes runtime error.

The outer loop runs from 0 to length of array minus 1 because the last element will be sorted by then.

2fill in blank

medium

Complete the code to start the inner loop to find the minimum element.

DSA Go

minIndex := i
for j := i + 1; j < [1]; j++ {
    if arr[j] < arr[minIndex] {
        minIndex = j
    }
}

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

Alen(arr) - 1

Blen(arr) + 1

Ci + 1

Dlen(arr)

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(arr) - 1 misses the last element.

Using i + 1 as upper limit causes no iteration.

The inner loop runs from i+1 to the end of the array to find the minimum element in the unsorted part.

3fill in blank

hard

Fix the error in swapping elements after finding the minimum index.

DSA Go

temp := arr[i]
arr[i] = arr[[1]]
arr[minIndex] = temp

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

AminIndex

B0

Cj

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping with i does nothing.

Swapping with j causes undefined variable error.

We swap arr[i] with arr[minIndex] to place the minimum element at the correct position.

4fill in blank

hard

Fill both blanks to complete the selection sort function header and return statement.

DSA Go

func [1](arr []int) []int {
    // sorting logic here
    return [2]
}

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

ASelectionSort

Barr

CsortedArr

DSort

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a variable not defined causes error.

Using wrong function name confuses readers.

The function is named SelectionSort and returns the sorted array 'arr'.

5fill in blank

hard

Fill all three blanks to complete the selection sort main logic inside the function.

DSA Go

for i := 0; i < [1]; i++ {
    minIndex := i
    for j := i + 1; j < [2]; j++ {
        if arr[j] < arr[[3]] {
            minIndex = j
        }
    }
    arr[i], arr[minIndex] = arr[minIndex], arr[i]
}

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

Alen(arr) - 1

Blen(arr)

CminIndex

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of minIndex in comparison causes wrong results.

Loop limits off by one cause index errors.

The outer loop runs to len(arr)-1, inner loop to len(arr), and comparison uses minIndex to find the smallest element.

Practice

1. What is the main idea behind the Selection Sort algorithm?

easy

A. Repeatedly find the smallest element and move it to the front

B. Divide the list into halves and merge sorted halves

C. Swap adjacent elements if they are in wrong order repeatedly

D. Use a pivot to partition the list into smaller parts

Solution

1. Step 1: Understand selection sort process

   Selection sort finds the smallest element in the unsorted part and swaps it with the first unsorted element.

2. Step 2: Compare with other sorting methods

   Other options describe merge sort, bubble sort, and quicksort, which are different algorithms.

3. Final Answer:

   Repeatedly find the smallest element and move it to the front -> Option A

4. Quick Check:

   Selection sort = find smallest and swap [OK]

Hint: Selection sort always picks the smallest next element [OK]

Common Mistakes:

• Confusing selection sort with bubble sort
• Thinking it divides list like merge sort
• Assuming it uses a pivot like quicksort

2. Which of the following is the correct way to start the outer loop for selection sort in Go for an array arr of length n?

easy

A. for i := 1; i < n; i++ {

B. for i := 0; i < n-1; i++ {

C. for i := 0; i <= n; i++ {

D. for i := 1; i <= n; i++ {

Solution

1. Step 1: Understand loop range for selection sort

   The outer loop runs from 0 to n-2 because the last element will be sorted automatically after previous passes.

2. Step 2: Check each option's correctness

   for i := 0; i < n-1; i++ { uses i < n-1, which is correct. Others either go out of bounds or start at wrong index.

3. Final Answer:

   for i := 0; i < n-1; i++ { -> Option B

4. Quick Check:

   Outer loop runs 0 to n-2 [OK]

Hint: Outer loop stops at n-2 because last element is sorted [OK]

Common Mistakes:

• Using <= n causing index out of range
• Starting loop at 1 instead of 0
• Loop running too many times

3. What will be the output of the following Go code snippet after applying one full pass of selection sort on the array?

arr := []int{29, 10, 14, 37, 13}
n := len(arr)
minIndex := 0
for j := 1; j < n; j++ {
    if arr[j] < arr[minIndex] {
        minIndex = j
    }
}
arr[0], arr[minIndex] = arr[minIndex], arr[0]
fmt.Println(arr)

medium

A. [10 13 14 37 29]

B. [13 10 14 37 29]

C. [29 10 14 37 13]

D. [10 29 14 37 13]

Solution

1. Step 1: Find minimum element index in full array

   Minimum element is 10 at index 1, so minIndex = 1.

2. Step 2: Swap arr[0] and arr[minIndex]

   Swap arr[0] (29) with arr[1] (10), resulting in [10 29 14 37 13].

3. Final Answer:

   [10 29 14 37 13] -> Option D

4. Quick Check:

   First pass places smallest element at front [OK]

Hint: First pass swaps smallest element to front [OK]

Common Mistakes:

• Not swapping elements after finding minimum
• Confusing minIndex with current index
• Printing array before swap

4. Identify the error in the following Go code implementing selection sort:

func selectionSort(arr []int) {
    n := len(arr)
    for i := 0; i < n; i++ {
        minIndex := i
        for j := i + 1; j <= n; j++ {
            if arr[j] < arr[minIndex] {
                minIndex = j
            }
        }
        arr[i], arr[minIndex] = arr[minIndex], arr[i]
    }
}

medium

A. Swap should be done only if minIndex != i

B. minIndex should be initialized outside the outer loop

C. Inner loop condition should be j < n, not j <= n

D. Outer loop should run from i := 1 to n-1

Solution

1. Step 1: Check inner loop boundary

   Inner loop uses j <= n, which causes index out of range error because valid indices are 0 to n-1.

2. Step 2: Correct inner loop condition

   It should be j < n to stay within array bounds.

3. Final Answer:

   Inner loop condition should be j < n, not j <= n -> Option C

4. Quick Check:

   Array indices go from 0 to n-1 [OK]

Hint: Array indices end at n-1, not n [OK]

Common Mistakes:

• Using <= n causing runtime panic
• Initializing minIndex outside outer loop
• Unnecessary swap checks

5. Given the array arr := []int{64, 25, 12, 22, 11}, after how many swaps will the array be fully sorted using selection sort, and what will be the final sorted array?

hard

A. 4 swaps; [11 12 22 25 64]

B. 5 swaps; [11 12 22 25 64]

C. 4 swaps; [64 25 12 22 11]

D. 3 swaps; [11 12 22 25 64]

Solution

1. Step 1: Count swaps in each selection sort pass

   Pass 1: swap 64 and 11 -> [11 25 12 22 64]
   Pass 2: swap 25 and 12 -> [11 12 25 22 64]
   Pass 3: swap 25 and 22 -> [11 12 22 25 64]
   Pass 4: swap 25 and 25 (no change, but swap counted as 1)
   Total swaps = 4 (last swap is with itself, usually counted as swap)

2. Step 2: Final sorted array

   The array after sorting is [11 12 22 25 64].

3. Final Answer:

   4 swaps; [11 12 22 25 64] -> Option A

4. Quick Check:

   Selection sort swaps once per pass, total n-1 swaps [OK]

Hint: Selection sort swaps once per pass, total n-1 swaps [OK]

Common Mistakes:

• Counting swaps incorrectly when swapping element with itself
• Assuming more swaps than passes
• Confusing sorted array with original