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.

Practice

1.

Why are slices preferred over arrays in Go?

easy

A. Because arrays cannot store multiple values

B. Because slices use less memory than arrays

C. Because slices can change size dynamically while arrays have fixed size

D. Because slices are slower but more secure

Solution

1. Step 1: Understand array size behavior

   Arrays in Go have a fixed size defined at creation and cannot grow or shrink.

2. Step 2: Understand slice flexibility

   Slices are built on arrays but can dynamically change size, making them more flexible for varying data.

3. Final Answer:

   Because slices can change size dynamically while arrays have fixed size -> Option C

4. Quick Check:

   Slice size flexibility = A [OK]

Hint: Remember: slices grow, arrays don't [OK]

Common Mistakes:

• Thinking arrays can resize dynamically
• Confusing memory usage between slices and arrays
• Believing slices are slower than arrays

2.

Which of the following is the correct way to declare a slice of integers in Go?

var s _____

easy

A. []int

B. [5]int

C. int[]

D. slice int

Solution

1. Step 1: Recall slice syntax

   In Go, slices are declared with square brackets and no size: []type.

2. Step 2: Identify correct option

   []int uses []int which is the correct syntax for a slice of integers.

3. Final Answer:

   []int -> Option A

4. Quick Check:

   Slice declaration = []int [OK]

Hint: Slices use []type without size [OK]

Common Mistakes:

• Using fixed size like [5]int for slices
• Writing type after brackets like int[]
• Using invalid keywords like 'slice int'

3.

What will be the output of this Go code?

arr := [3]int{1, 2, 3}
slice := arr[:2]
slice = append(slice, 4)
fmt.Println(arr)

medium

A. [1 2 4]

B. [1 2 3 4]

C. [1 2 3]

D. Runtime error

Solution

1. Step 1: Understand slice and array relation

   The slice references the first two elements of arr: [1, 2], with length 2 and capacity 3.

2. Step 2: Append behavior on slice

   Appending 4 to slice: since current length 2 < capacity 3, it appends in place to the underlying array, setting arr[2] = 4. Thus, arr becomes [1 2 4].

3. Final Answer:

   [1 2 4] -> Option A

4. Quick Check:

   Append within capacity modifies underlying array = B [OK]

Hint: Append within capacity modifies shared array [OK]

Common Mistakes:

• Thinking append always reallocates a new array
• Expecting arr to grow to 4 elements
• Thinking append causes runtime error

4.

Identify the error in this Go code snippet:

var s []int
s[0] = 10
fmt.Println(s)

medium

A. Syntax error: slice declaration is incorrect

B. Slice s is nil and has no elements, so s[0] assignment causes runtime panic

C. No error, code prints [10]

D. Compile error: cannot assign to slice element

Solution

1. Step 1: Check slice initialization

   Variable s is declared but not initialized; it is nil with length 0.

2. Step 2: Understand assignment to s[0]

   Assigning to s[0] causes runtime panic because no elements exist yet.

3. Final Answer:

   Slice s is nil and has no elements, so s[0] assignment causes runtime panic -> Option B

4. Quick Check:

   Assigning to nil slice index = runtime panic [OK]

Hint: Initialize slice before assigning elements [OK]

Common Mistakes:

• Assuming slice auto-expands on index assignment
• Thinking code compiles with no error
• Confusing compile error with runtime panic

5.

You want to collect an unknown number of user scores efficiently. Which approach best uses slices?

1. Use a fixed-size array
2. Use a slice and append scores as they come
3. Use a map with indexes
4. Use a string to store scores

hard

A. Use a fixed-size array

B. Use a string to store scores

C. Use a map with indexes

D. Use a slice and append scores as they come

Solution

1. Step 1: Consider data size flexibility

   User scores count is unknown, so fixed-size array is not suitable.

2. Step 2: Evaluate slice usage

   Slices can grow dynamically and efficiently handle unknown data sizes by appending.

3. Step 3: Exclude other options

   Maps add overhead and strings are not suitable for numeric data storage.

4. Final Answer:

   Use a slice and append scores as they come -> Option D

5. Quick Check:

   Dynamic data collection = slice append [OK]

Hint: Use slices to grow lists dynamically [OK]

Common Mistakes:

• Choosing fixed arrays for unknown sizes
• Using strings for numeric data
• Overcomplicating with maps when slices suffice