Slice length and capacity in Go - Mini Project: Build & Apply

Slice length and capacity

📖 Scenario: You are managing a list of fruits in a grocery store inventory system. You want to understand how slices work in Go, especially their length and capacity, to handle the inventory efficiently.

🎯 Goal: Learn how to create a slice, check its length and capacity, and understand how these properties change when slicing the slice.

📋 What You'll Learn

Create a slice of strings with exact fruits

Create a new slice from the original slice

Print the length and capacity of both slices

💡 Why This Matters

🌍 Real World

Slices are used in Go programs to manage collections of data efficiently, such as lists of items in inventory or user data.

💼 Career

Understanding slice length and capacity is essential for Go developers to write efficient and bug-free code when handling dynamic data.

1

Create the initial slice

Create a slice of strings called fruits with these exact values: "apple", "banana", "cherry", "date", "elderberry".

Go

# Create a slice called fruits with the exact fruits
# Your code here

Hint

Use []string{} to create a slice with the exact fruit names inside.

2

Create a new slice from the original

Create a new slice called citrus from fruits that contains only the elements from index 1 to 3 (inclusive start, exclusive end).

Go

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry", "date", "elderberry"}
    // Create a slice called citrus from fruits[1:4]
    // Your code here
}

Hint

Use slicing syntax fruits[1:4] to get elements from index 1 up to but not including 4.

3

Check length and capacity

Create two variables called fruitsLen and fruitsCap to store the length and capacity of fruits. Also create citrusLen and citrusCap for the length and capacity of citrus.

Go

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry", "date", "elderberry"}
    citrus := fruits[1:4]
    // Create fruitsLen and fruitsCap for fruits
    // Create citrusLen and citrusCap for citrus
    // Your code here
}

Hint

Use len(slice) for length and cap(slice) for capacity.

4

Print the lengths and capacities

Print the length and capacity of fruits and citrus using fmt.Println with the exact format:
"fruits length: " followed by fruitsLen,
"fruits capacity: " followed by fruitsCap,
"citrus length: " followed by citrusLen,
"citrus capacity: " followed by citrusCap.

Go

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry", "date", "elderberry"}
    citrus := fruits[1:4]
    fruitsLen := len(fruits)
    fruitsCap := cap(fruits)
    citrusLen := len(citrus)
    citrusCap := cap(citrus)
    // Print the lengths and capacities as instructed
    // Your code here
}

Hint

Use fmt.Println four times with the exact text and variables.

Practice

1. In Go, what does the len() function return when used on a slice?

easy

A. The maximum number of elements the slice can hold

B. The total memory size of the slice in bytes

C. The index of the last element in the slice

D. The number of elements currently in the slice

Solution

1. Step 1: Understand the purpose of len() on slices

   The len() function returns how many elements are currently stored in the slice.

2. Step 2: Differentiate from capacity

   Capacity is about how many elements the slice can hold before resizing, not the current count.

3. Final Answer:

   The number of elements currently in the slice -> Option D

4. Quick Check:

   len(slice) = current element count [OK]

Hint: Remember: len = current items, cap = max before grow [OK]

Common Mistakes:

• Confusing length with capacity
• Thinking len returns memory size
• Assuming len gives last index

2. Which of the following is the correct way to create a slice with length 3 and capacity 5 in Go?

easy

A. make([]int, 5, 3)

B. make([]int, 3, 5)

C. []int{3, 5}

D. make([]int, 3)

Solution

1. Step 1: Recall the make function signature for slices

   make([]T, length, capacity) creates a slice with given length and capacity.

2. Step 2: Match length and capacity values

   To get length 3 and capacity 5, use make([]int, 3, 5).

3. Final Answer:

   make([]int, 3, 5) -> Option B

4. Quick Check:

   make([]int, length, capacity) [OK]

Hint: make([]T, len, cap) sets length then capacity [OK]

Common Mistakes:

• Swapping length and capacity arguments
• Using slice literal instead of make
• Omitting capacity when needed

3. What will be the output of this Go code?

nums := make([]int, 2, 4)
nums[0] = 10
nums[1] = 20
fmt.Println(len(nums), cap(nums))

medium

A. 2 2

B. 0 4

C. 2 4

D. 4 4

Solution

1. Step 1: Analyze slice creation

   make([]int, 2, 4) creates a slice with length 2 and capacity 4.

2. Step 2: Check length and capacity after assignments

   Assigning values to existing indices does not change length or capacity.

3. Final Answer:

   2 4 -> Option C

4. Quick Check:

   len = 2, cap = 4 [OK]

Hint: Length stays same unless you append beyond capacity [OK]

Common Mistakes:

• Confusing length with capacity
• Assuming capacity equals length after assignment
• Thinking length changes when assigning values

4. Consider this code snippet:

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

What is the correct output?

medium

A. 2 4

B. 2 2

C. 3 4

D. 3 5

Solution

1. Step 1: Determine length of the slice

   The slice is from index 1 to 3 (exclusive), so length = 3 - 1 = 2.

2. Step 2: Calculate capacity of the slice

   Capacity is from start index to end of original array: 5 - 1 = 4.

3. Final Answer:

   2 4 -> Option A

4. Quick Check:

   len = 2, cap = 4 from slice indices [OK]

Hint: Capacity = original array length - slice start index [OK]

Common Mistakes:

• Using slice length as capacity
• Confusing slice end index with capacity
• Assuming capacity equals original array length

5. You have a slice s := make([]int, 3, 5). You append two elements to it. What will be the length and capacity of s after these appends?

hard

A. Length 5, Capacity 5

B. Length 5, Capacity 10

C. Length 3, Capacity 5

D. Length 5, Capacity 6

Solution

1. Step 1: Understand initial slice size

   Slice s starts with length 3 and capacity 5.

2. Step 2: Append two elements within capacity

   Appending two elements increases length to 5, capacity remains 5 because it is not exceeded.

3. Final Answer:

   Length 5, Capacity 5 -> Option A

4. Quick Check:

   Appending within capacity keeps capacity same [OK]

Hint: Capacity grows only when length exceeds capacity [OK]

Common Mistakes:

• Assuming capacity doubles immediately after append
• Confusing length with capacity after append
• Thinking capacity increases by 1 per append