Slicing operations in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a slice in Go?

A slice in Go is a flexible, dynamically-sized view into the elements of an array. It lets you work with parts of an array without copying data.

beginner

How do you create a slice from an array or another slice?

You use the slicing syntax: slice := array[start:end]. This creates a new slice from index start up to but not including end.

beginner

What happens if you omit the start or end index in a slice operation?

If you omit start, it defaults to 0 (start of the array). If you omit end, it defaults to the length of the array or slice.

intermediate

What is the difference between length and capacity of a slice?

Length is how many elements the slice currently holds. Capacity is how many elements the slice can hold before it needs to grow (based on the underlying array).

intermediate

How can slicing affect the original array?

Slices share the same underlying array. Changing an element in a slice changes the same element in the original array and other slices sharing it.

What does arr[2:5] return if arr is a slice?

A Elements from index 3 to 5

B Elements from index 2 up to and including 5

C Elements from index 0 to 5

D Elements from index 2 up to but not including 5

Slicing in Go includes the start index but excludes the end index.

What is the length of the slice created by slice := arr[:]?

A Length of arr

B 0

C Capacity of arr

D Undefined

Omitting start and end means the slice includes the whole array, so length equals the array's length.

If you change an element in a slice, what happens to the original array?

A The original array changes at that element

B The original array stays the same

C A new array is created

D The slice becomes invalid

Slices share the underlying array, so changes affect the original array.

What does the capacity of a slice represent?

A Number of slices created from the array

B Current number of elements in the slice

C Maximum number of elements the slice can hold before resizing

D Size of the underlying array

Capacity is how many elements the slice can hold before it needs to allocate a new underlying array.

Which of these is a valid way to create a slice from an array arr?

A slice := arr(1,4)

B slice := arr[1:4]

C slice := arr[1..4]

D slice := arr.slice(1,4)

Go uses the syntax arr[start:end] for slicing.

Explain how slicing works in Go and how it relates to the underlying array.

Think about how slices are views into arrays, not copies.

Describe the difference between the length and capacity of a slice and why it matters.

Consider what happens when you append elements to a slice.

Practice

1. In Go, what does the slice expression arr[2:5] do?

easy

A. Extracts elements from index 2 up to and including index 5

B. Extracts elements from index 2 up to but not including index 5

C. Extracts elements from index 3 to 5

D. Extracts elements from index 0 to 5

Solution

1. Step 1: Understand slice indexing in Go

   Go slices include the start index but exclude the end index.

2. Step 2: Apply to arr[2:5]

   This means elements at indexes 2, 3, and 4 are included, but not index 5.

3. Final Answer:

   Extracts elements from index 2 up to but not including index 5 -> Option B

4. Quick Check:

   Slice = arr[2:5] includes indexes 2,3,4 [OK]

Hint: Remember: start included, end excluded in slices [OK]

Common Mistakes:

• Including the end index element
• Confusing start and end indexes
• Thinking slice includes elements before start

2. Which of the following is the correct syntax to slice a Go slice arr from the beginning up to index 4 (excluding 4), omitting the start index?

easy

A. arr[:4]

B. arr[0:4]

C. arr[1:4]

D. arr[4:]

Solution

1. Step 1: Recall slice syntax for start omitted

   Omitting the start index means slicing from the beginning (index 0).

2. Step 2: Check the options

   arr[:4] omits the start index (defaults to 0), slicing up to but excluding index 4. arr[0:4] explicitly includes the start index.

3. Final Answer:

   arr[:4] -> Option A

4. Quick Check:

   Start omitted means from 0 [OK]

Hint: Omit start to slice from beginning: arr[:end] [OK]

Common Mistakes:

• Using arr[1:4] which skips the first element
• Using arr[4:] which slices from index 4 to end
• Confusing start and end indexes

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

arr := []int{10, 20, 30, 40, 50}
slice := arr[1:4]
fmt.Println(slice)

medium

A. [20 30 40 50]

B. [10 20 30 40]

C. [30 40 50]

D. [20 30 40]

Solution

1. Step 1: Identify slice indexes

   The slice arr[1:4] includes elements at indexes 1, 2, and 3.

2. Step 2: Extract elements from arr

   arr[1] = 20, arr[2] = 30, arr[3] = 40, so the slice is [20 30 40].

3. Final Answer:

   [20 30 40] -> Option D

4. Quick Check:

   Slice arr[1:4] = [20 30 40] [OK]

Hint: Slice excludes end index, so last element is arr[3] here [OK]

Common Mistakes:

• Including arr[4] which is 50
• Starting slice at index 0 instead of 1
• Printing the whole array instead of slice

4. Consider this Go code snippet:

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

What is the issue here?

medium

A. The slice will be empty but no error occurs

B. The slice syntax is invalid and causes a compile error

C. The start index is greater than the end index, causing a runtime panic

D. The slice will include elements from index 2 to 3

Solution

1. Step 1: Check slice indexes

   The slice arr[3:2] has start index 3 and end index 2.

2. Step 2: Understand Go slice rules

   In Go, the start index must be less than or equal to the end index; otherwise, it causes a runtime panic.

3. Final Answer:

   The start index is greater than the end index, causing a runtime panic -> Option C

4. Quick Check:

   Start > end in slice causes panic [OK]

Hint: Start index must not exceed end index in slices [OK]

Common Mistakes:

• Assuming slice is empty without error
• Thinking slice syntax is invalid at compile time
• Confusing start and end indexes

5. Given the slice nums := []int{5, 10, 15, 20, 25, 30}, which expression produces a new slice containing only the last three elements?

hard

A. nums[3:]

B. nums[:3]

C. nums[2:5]

D. nums[4:]

Solution

1. Step 1: Identify last three elements indexes

   The last three elements are at indexes 3, 4, and 5 (20, 25, 30).

2. Step 2: Use slice syntax to get from index 3 to end

   Using nums[3:] slices from index 3 to the end, giving [20 25 30].

3. Final Answer:

   nums[3:] -> Option A

4. Quick Check:

   nums[3:] = last three elements [OK]

Hint: Use nums[start:] to slice from start index to end [OK]

Common Mistakes:

• Using nums[:3] which gives first three elements
• Using nums[2:5] which excludes last element
• Using nums[4:] which gives only last two elements