Common slice operations in Go - Step-by-Step Execution

Concept Flow - Common slice operations

Create slice

↓

Access elements

↓

Modify elements

↓

Append elements

↓

Slice sub-slices

↓

Delete elements (via slicing)

↓

Use slice length and capacity

This flow shows how to create, access, modify, append, slice, delete elements, and check length/capacity of slices in Go.

Execution Sample

Go

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

Creates a slice, appends an element, and prints the second element.

Execution Table

Step	Action	Slice s	Output
1	Create slice s with [1, 2, 3]	[1 2 3]
2	Append 4 to s	[1 2 3 4]
3	Access s[1]	[1 2 3 4]	2
4	End of program	[1 2 3 4]	2

💡 Program ends after printing element at index 1.

Variable Tracker

Variable	Start	After Create	Final
s	nil	[1 2 3]	[1 2 3 4]

Key Moments - 3 Insights

Why does s change after append even though slices are passed by value?

Append returns a new slice header with updated length and capacity, so we assign it back to s as shown in step 2 of execution_table.

What happens if we try to access s[3] before appending?

Accessing s[3] before append would cause a runtime error because the slice length is 3, so index 3 is out of range (see step 1 slice length).

How do we delete an element from a slice?

We create a new slice by combining parts before and after the element using slicing and append, similar to how append works in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of slice s after step 2?

A [1 2 3]

B [1 2 3 4]

C [2 3 4]

D [1 2 4]

💡 Hint

Check the 'Slice s' column at step 2 in execution_table.

At which step is the element '2' printed?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Output' column in execution_table for when '2' appears.

If we remove the assignment in step 2 (s = append(s, 4)), what happens to s?

A s becomes nil

B s becomes [1 2 3 4]

C s remains [1 2 3]

D Program crashes

💡 Hint

Refer to key_moments about append behavior and variable_tracker for s changes.

Concept Snapshot

Slices in Go:
- Create: s := []int{1,2,3}
- Access: s[0], s[1]
- Append: s = append(s, 4)
- Slice: s[1:3]
- Delete: s = append(s[:i], s[i+1:]...)
- Length: len(s), Capacity: cap(s)

Full Transcript

This visual execution shows common slice operations in Go. We start by creating a slice s with three elements. Then we append a new element 4 to s, which returns a new slice header that we assign back to s. Next, we access the element at index 1, which is 2, and print it. The program ends after printing. The variable tracker shows how s changes from nil to [1 2 3] and finally to [1 2 3 4]. Key moments clarify why append requires assignment, what happens if we access out-of-range indexes, and how to delete elements by slicing and appending. The quiz tests understanding of slice state after append, when output occurs, and the effect of missing assignment after append.

Practice

1. What does the slice expression mySlice[2:5] do in Go?

easy

A. It returns a new slice containing elements from index 2 up to, but not including, index 5.

B. It returns elements from index 2 to index 5, including index 5.

C. It removes elements from index 2 to 5 from the original slice.

D. It appends elements from index 2 to 5 to the original slice.

Solution

1. Step 1: Understand slice syntax

   The slice expression mySlice[2:5] extracts elements starting at index 2 up to, but not including, index 5. Go slices use half-open intervals, so the element at index 5 is not included in the new slice.

2. Final Answer:

   It returns a new slice containing elements from index 2 up to, but not including, index 5. -> Option A

3. Quick Check:

   Slice[start:end] excludes end index [OK]

Hint: Remember slice end index is excluded in Go slices [OK]

Common Mistakes:

• Including the end index element in the slice
• Thinking slice removes elements from original
• Confusing append with slicing

2. Which of the following is the correct way to append an element 5 to a slice nums in Go?

easy

A. append(nums, 5)

B. nums += 5

C. nums.append(5)

D. nums = append(nums, 5)

Solution

1. Step 1: Recall append function usage

   In Go, append returns a new slice with the element added, so you must assign it back. nums = append(nums, 5) correctly assigns the result back to nums. append(nums, 5) ignores the returned slice. nums.append(5) uses invalid method syntax. nums += 5 is invalid for slices.

2. Final Answer:

   nums = append(nums, 5) -> Option D

3. Quick Check:

   append returns new slice, assign it [OK]

Hint: Always assign append result back to slice variable [OK]

Common Mistakes:

• Not assigning append result back
• Using method syntax like nums.append()
• Trying to add with += operator

3. What is the output of this Go code?

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

medium

A. [1 10 3 4 5]

B. [1 2 10 4 5]

C. [10 2 3 4 5]

D. [1 2 3 4 5]

Solution

1. Step 1: Understand slice referencing

   The slice slice := nums[1:4] references the original array elements at indexes 1, 2, and 3. Changing slice[0] to 10 changes nums[1] because slices share the underlying array. Output: [1 10 3 4 5]

2. Final Answer:

   [1 10 3 4 5] -> Option A

3. Quick Check:

   Slices share array, modifying slice changes original [OK]

Hint: Changing slice elements changes original array too [OK]

Common Mistakes:

• Thinking slice is a copy, not a reference
• Modifying wrong index in slice
• Confusing slice length with capacity

4. Identify the error in this Go code snippet:

nums := []int{1, 2, 3}
newSlice := nums[1:4]
fmt.Println(newSlice)

medium

A. Cannot print a slice directly with fmt.Println.

B. Syntax error in slice declaration.

C. Slicing beyond the slice length causes a runtime panic.

D. Missing import for fmt package.

Solution

1. Step 1: Check slice bounds

   The original slice nums has length 3, so valid indices are 0 to 2. Attempting nums[1:4] tries to access index 3 which is out of range, causing a runtime panic.

2. Final Answer:

   Slicing beyond the slice length causes a runtime panic. -> Option C

3. Quick Check:

   Slice end index must be ≤ length [OK]

Hint: Slice end index cannot exceed slice length [OK]

Common Mistakes:

• Assuming slice auto-expands
• Confusing compile error with runtime panic
• Ignoring slice length when slicing

5. Given a slice data := []int{2, 4, 6, 8, 10, 12}, how can you create a new slice containing only the even numbers greater than 6 using slicing and append?

hard

A. newSlice := data[2:5]

B. newSlice := append([]int{}, data[3:]...)

C. newSlice := append(data[:3], data[4:]...)

D. newSlice := data[3:len(data)]

Solution

1. Step 1: Identify elements > 6

   Elements greater than 6 are 8, 10, 12 at indexes 3, 4, 5. Using data[3:] gets these elements. To create a new slice (not referencing original), append to empty slice: newSlice := append([]int{}, data[3:]...).

2. Final Answer:

   newSlice := append([]int{}, data[3:]...) -> Option B

3. Quick Check:

   Slice and append to copy subset [OK]

Hint: Use append to copy slice subset safely [OK]

Common Mistakes:

• Using slice without append copies reference
• Incorrect slice indexes for desired elements
• Trying to remove elements by slicing incorrectly