Slice and array relationship in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a slice in Go?

A slice in Go is a flexible, dynamic view into the elements of an array. It does not store data itself but references an underlying array.

beginner

How does a slice relate to its underlying array?

A slice points to a segment of an array. Changes to the slice elements affect the underlying array and vice versa.

intermediate

What happens when you append to a slice that has no extra capacity?

Go creates a new underlying array with more capacity, copies the old elements, and appends the new ones. The slice then points to this new array.

beginner

How can you create a slice from an array?

You can create a slice by specifying a range of indices on an array, like: slice := array[start:end].

beginner

Does modifying a slice affect the original array?

Yes, because the slice references the original array's elements, modifying the slice changes the array's data.

What does a Go slice store internally?

A Only the length of the array

B A copy of the array elements

C A pointer to an array, length, and capacity

D The entire array data

A slice stores a pointer to the underlying array, its length, and its capacity.

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

A The array element changes too

B The array remains unchanged

C The array is copied and changed separately

D The slice breaks the link to the array

Slices reference the array, so changes to the slice affect the array.

What happens when you append to a slice that has enough capacity?

A The program crashes

B A new array is created

C The slice length stays the same

D The element is added to the existing array

If capacity allows, append adds elements to the existing array without creating a new one.

How do you create a slice from an array named 'arr' from index 2 to 5?

A slice := arr[3:5]

B slice := arr[2:5]

C slice := arr[2:6]

D slice := arr[2..5]

The slice syntax includes the start index and excludes the end index, so arr[2:5] includes indices 2,3,4.

Which of these is true about slices in Go?

A Slices can grow beyond the size of the underlying array

B Slices always copy the array data

C Slices cannot be created from arrays

D Slices have fixed length and capacity

Slices can grow by allocating a new underlying array when capacity is exceeded.

Explain how a slice and its underlying array are connected in Go.

Think about how slices are views into arrays.

Describe what happens internally when you append an element to a slice that has no remaining capacity.

Consider slice capacity and memory allocation.

Practice

1. In Go, what is the relationship between a slice and the underlying array it references?

easy

A. A slice is a completely independent copy of the array.

B. A slice is a view into an array and shares the same data.

C. A slice stores data separately and does not affect the array.

D. A slice can only reference arrays of fixed size 10.

Solution

1. Step 1: Understand slice basics

   A slice in Go points to an underlying array and does not copy data.

2. Step 2: Relationship between slice and array

   Changes to the slice affect the array and vice versa because they share the same data.

3. Final Answer:

   A slice is a view into an array and shares the same data. -> Option B

4. Quick Check:

   Slice shares array data = B [OK]

Hint: Remember: slices share data with arrays, not copy it [OK]

Common Mistakes:

• Thinking slices copy array data
• Believing slices are independent arrays
• Assuming slices have fixed size

2. Which of the following is the correct way to create a slice from an array arr := [5]int{1,2,3,4,5} that includes elements 2, 3, and 4?

easy

A. slice := arr[1:4]

B. slice := arr[2:5]

C. slice := arr[0:3]

D. slice := arr[3:6]

Solution

1. Step 1: Identify slice indices

   Slice syntax is arr[start:end], including start but excluding end index.

2. Step 2: Select correct indices for elements 2,3,4

   Elements 2,3,4 are at indices 1,2,3, so slice is arr[1:4].

3. Final Answer:

   slice := arr[1:4] -> Option A

4. Quick Check:

   Slice indices 1 to 4 exclude 4 = D [OK]

Hint: Slice includes start index, excludes end index [OK]

Common Mistakes:

• Using wrong start or end index
• Trying to slice beyond array length
• Confusing inclusive/exclusive slice bounds

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

arr := [3]int{10, 20, 30}
slice := arr[:]
slice[1] = 99
fmt.Println(arr)

medium

A. [99 20 30]

B. [10 20 30]

C. [10 99 30]

D. [10 20 99]

Solution

1. Step 1: Understand slice referencing

   slice := arr[:] creates a slice referencing the entire array.

2. Step 2: Modify slice element

   slice[1] = 99 changes the second element of the slice and underlying array.

3. Step 3: Print array

   Printing arr shows the updated array: [10 99 30].

4. Final Answer:

   [10 99 30] -> Option C

5. Quick Check:

   Slice change affects array = A [OK]

Hint: Changing slice changes array too [OK]

Common Mistakes:

• Assuming array stays unchanged
• Confusing slice copy with reference
• Misreading slice syntax

4. Identify the error in the following Go code snippet:

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

medium

A. No error, output is [1 2 10 4]

B. Syntax error in slice declaration

C. Array length mismatch error

D. Index out of range error when assigning to slice[2]

Solution

1. Step 1: Check slice length

   slice := arr[1:3] includes elements at indices 1 and 2, length 2.

2. Step 2: Accessing slice[2]

   slice[2] tries to access third element (index 2), which is out of range.

3. Final Answer:

   Index out of range error when assigning to slice[2] -> Option D

4. Quick Check:

   Slice length 2, index 2 invalid = C [OK]

Hint: Slice length limits valid indices from 0 to len-1 [OK]

Common Mistakes:

• Assuming slice length equals array length
• Using invalid slice indices
• Ignoring runtime panics

5. Given the array arr := [5]int{1, 2, 3, 4, 5}, you create two slices:
slice1 := arr[1:4]
slice2 := arr[2:5]
If you set slice1[1] = 99, what will be the content of slice2?

hard

A. [99 4 5]

B. [3 99 5]

C. [3 4 5]

D. [2 99 5]

Solution

1. Step 1: Identify slice1 and slice2 elements

   slice1 = arr[1:4] = elements at indices 1,2,3 -> [2,3,4]
   slice2 = arr[2:5] = elements at indices 2,3,4 -> [3,4,5]

2. Step 2: Modify slice1[1]

   slice1[1] is element at arr index 2 (value 3), changed to 99.
   So arr becomes [1,2,99,4,5].

3. Step 3: Check slice2 after modification

   slice2 references arr[2], arr[3], arr[4] -> [99,4,5].

4. Final Answer:

   [99 4 5] -> Option A

5. Quick Check:

   Shared array data means slice2 reflects change = B [OK]

Hint: Slices share array; changing one affects overlapping slices [OK]

Common Mistakes:

• Mixing up slice indices and values
• Forgetting slices share underlying array
• Assuming slices are independent copies