Common slice operations in Go - Mini Project: Build & Apply

Common slice operations

📖 Scenario: You are managing a list of daily temperatures recorded in a city. You want to practice common slice operations in Go to handle this data efficiently.

🎯 Goal: Build a Go program that creates a slice of temperatures, extracts a subset of days, appends new temperature data, and finally prints the updated slice.

📋 What You'll Learn

Create a slice of integers named temps with exact values: 23, 25, 22, 20, 19

Create a variable subset that slices temps from index 1 to 4 (exclusive)

Append the values 21 and 24 to the temps slice

Print the final temps slice

💡 Why This Matters

🌍 Real World

Handling lists of data like temperatures, sales, or scores is common in many programs. Knowing how to slice and append helps manage this data easily.

💼 Career

Many software jobs require working with lists or arrays. Mastering slice operations in Go is essential for backend development, data processing, and more.

1

Create the initial slice of temperatures

Create a slice of integers called temps with these exact values: 23, 25, 22, 20, 19

Go

// Create the slice temps with the given values
// Your code here

Hint

Use temps := []int{23, 25, 22, 20, 19} to create the slice.

2

Slice the temperatures to get a subset

Create a variable called subset that slices the temps slice from index 1 to 4 (exclusive)

Go

package main

import "fmt"

func main() {
    temps := []int{23, 25, 22, 20, 19}
    // Create subset slice from temps[1:4]
    // Your code here
}

Hint

Use subset := temps[1:4] to get the slice from index 1 to 3.

3

Append new temperature values

Append the values 21 and 24 to the temps slice using the append function

Go

package main

import "fmt"

func main() {
    temps := []int{23, 25, 22, 20, 19}
    subset := temps[1:4]
    // Append 21 and 24 to temps
    // Your code here
}

Hint

Use temps = append(temps, 21, 24) to add new values.

4

Print the final temperatures slice

Print the temps slice using fmt.Println to display the updated list of temperatures

Go

package main

import "fmt"

func main() {
    temps := []int{23, 25, 22, 20, 19}
    subset := temps[1:4]
    temps = append(temps, 21, 24)
    // Print temps slice
    // Your code here
}

Hint

Use fmt.Println(temps) to print the slice.

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