Why slices are used in Go - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of slice capacity and length

What is the output of this Go program that uses slices?

Go

package main
import "fmt"
func main() {
  arr := [5]int{10, 20, 30, 40, 50}
  s := arr[1:4]
  fmt.Println(len(s), cap(s))
}

A 4 3

B 3 4

C 4 4

D 3 3

💡 Hint

Remember that length is the number of elements in the slice, capacity is from the start of the slice to the end of the underlying array.

The slice s includes elements at indices 1, 2, 3 of arr, so length is 3. Capacity is from index 1 to the end of arr, which is 4 elements.

🧠 Conceptual

intermediate

Why slices are preferred over arrays in Go

Which reason best explains why slices are used instead of arrays in Go?

A Slices provide dynamic size and can grow or shrink, arrays have fixed size.

B Slices cannot be passed to functions, arrays can.

C Slices are stored on the stack, arrays are stored on the heap.

D Slices do not reference underlying data, arrays do.

💡 Hint

Think about flexibility in size when working with collections.

Slices are wrappers around arrays that allow dynamic resizing and flexible use, while arrays have fixed size determined at compile time.

🔧 Debug

advanced

Identify the runtime error with slices

What error will this Go code produce when run?

Go

package main
import "fmt"
func main() {
  s := []int{1, 2, 3}
  fmt.Println(s[3])
}

A Prints 0

B Compilation error: index out of range

C Index out of range runtime panic

D No error, prints 3

💡 Hint

Check the valid indices for a slice of length 3.

The slice s has indices 0,1,2. Accessing s[3] causes a runtime panic due to index out of range.

❓ Predict Output

advanced

Effect of appending on slice capacity

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
  s := make([]int, 2, 4)
  s[0], s[1] = 10, 20
  s = append(s, 30, 40, 50)
  fmt.Println(len(s), cap(s))
}

A 5 10

B 5 4

C 5 5

D 5 8

💡 Hint

Appending beyond capacity doubles the capacity.

Initial slice has length 2 and capacity 4. Appending 3 elements exceeds capacity, so Go allocates a new underlying array with doubled capacity (8). Length becomes 5.

🧠 Conceptual

expert

Why slices improve memory efficiency in Go

Which statement best explains how slices improve memory efficiency compared to arrays?

A Slices share the underlying array, avoiding copying data when passed to functions.

B Slices always allocate new memory on append, preventing memory leaks.

C Slices store data inline, reducing pointer overhead compared to arrays.

D Slices automatically compress data to save memory.

💡 Hint

Think about how slices reference data and how that affects copying.

Slices are descriptors pointing to an underlying array. Passing slices to functions passes the descriptor, not the whole data, saving memory and time.