Slice and array relationship in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying a slice element

What is the output of this Go program?

Go

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

A [1 2 3]

B [1 10 3]

C [10 2 3]

D [1 10 10]

💡 Hint

Slices share the underlying array with the original array.

Changing an element of the slice changes the underlying array because the slice references the same memory.

❓ Predict Output

intermediate

Length and capacity of a slice

What will be printed by this Go code?

Go

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

A 3 4

B 3 3

C 4 4

D 4 3

💡 Hint

Length is the number of elements in the slice; capacity is from the start of the slice to the end of the array.

The slice s covers elements at indices 1,2,3 (length 3). Capacity is from index 1 to end of arr (5 elements total), so capacity is 4.

🔧 Debug

advanced

Why does this slice append not change the original array?

Consider this Go code snippet. What is the output and why?

Go

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

A [1 2 3]\n[1 2 4]

B [1 2 4]\n[1 2 4]

C [1 2 3]\n[1 2 3 4]

D [1 2 3]\n[1 2 3]

💡 Hint

Appending to a slice may create a new underlying array if capacity is exceeded.

The slice s has length 2 and capacity 3. Appending one element increases length to 3, which fits in capacity. Append modifies the underlying array by setting arr[2]=4. So arr becomes [1 2 4]. Both arr and s reflect [1 2 4].

📝 Syntax

advanced

Identify the syntax error in slice declaration

Which option contains a syntax error in slice or array usage?

A s := arr[1:4]

B arr := [3]int{1, 2, 3}

C s := arr[1..3]

D s := []int{1, 2, 3}

💡 Hint

Go slice syntax uses a single colon, not two dots.

The slice syntax uses a single colon between indices, e.g., arr[1:3]. Using two dots causes a syntax error.

🧠 Conceptual

expert

Effect of modifying a slice after re-slicing

Given the code below, what is the output?

Go

package main
import "fmt"
func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    s1 := arr[1:4]
    s2 := s1[1:3]
    s2[0] = 100
    fmt.Println(arr)
}

A [10 20 30 100 50]

B [10 100 30 40 50]

C [10 20 30 40 50]

D [10 20 100 40 50]

💡 Hint

Slices share the same underlying array. Indexes are relative to the original array.

s1 is arr[1:4] → elements at indices 1,2,3. s2 is s1[1:3] → elements at indices 2,3 of arr. Modifying s2[0] changes arr[2].

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