Accessing array elements in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print the first element of the array.

Go

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

Drag options to blanks, or click blank then click option'

A(0)

B<0>

C{0}

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or curly braces instead of square brackets.

Using an index starting at 1 instead of 0.

The correct way to access an element in a Go array is by using square brackets with the index inside, like arr[0].

2fill in blank

medium

Complete the code to print the last element of the array.

Go

package main
import "fmt"
func main() {
    arr := [4]string{"a", "b", "c", "d"}
    fmt.Println(arr[[1]])
}

Drag options to blanks, or click blank then click option'

A3

B4

C0

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using index 4 which is out of range.

Using negative indexes which Go does not support.

The last element of an array with 4 elements is at index 3, since indexing starts at 0.

3fill in blank

hard

Fix the error in the code to correctly access the second element of the array.

Go

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

Drag options to blanks, or click blank then click option'

A<1>

B(1)

C1

D{1}

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or curly braces instead of square brackets.

Using index 2 instead of 1 for the second element.

Array elements in Go are accessed using square brackets with the index inside, so nums[1] accesses the second element.

4fill in blank

hard

Fill both blanks to create a map of words to their lengths for words longer than 3 characters.

Go

package main
import "fmt"
func main() {
    words := []string{"go", "code", "play", "fun"}
    lengths := map[string]int{
        [1]: [2],
    }
    fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

A"code"

Blen("code")

C"go"

Dlen("go")

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong word as key.

Not using the len function for the value.

The map key should be the word "code" and the value should be its length using len("code").

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths for words longer than 2 characters.

Go

package main
import (
    "fmt"
    "strings"
)
func main() {
    words := []string{"go", "code", "play", "fun"}
    lengths := map[string]int{
        [1]: [2],
        [3]: len("play"),
    }
    fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

Astrings.ToUpper("code")

Blen("code")

Cstrings.ToUpper("play")

Dlen("play")

Attempts:

3 left

💡 Hint

Common Mistakes

Not using strings.ToUpper for keys.

Mixing up keys and values.

The map keys are uppercase words using strings.ToUpper, and the values are their lengths using len.

Practice

1. What is the index of the first element in a Go array?

easy

A. 1

B. Depends on the array size

C. -1

D. 0

Solution

1. Step 1: Understand Go array indexing

   In Go, arrays start indexing from 0, meaning the first element is at index 0.

2. Step 2: Confirm the first element's index

   The first element is always accessed with index 0, not 1 or any other number.

3. Final Answer:

   0 -> Option D

4. Quick Check:

   First element index = 0 [OK]

Hint: Remember, Go arrays start counting at zero [OK]

Common Mistakes:

• Thinking indexing starts at 1
• Assuming negative indexes are valid
• Believing index depends on array size

2. Which of the following is the correct way to access the third element of an array named arr in Go?

easy

A. arr[3]

B. arr[2]

C. arr(2)

D. arr{2}

Solution

1. Step 1: Recall Go array indexing syntax

   Go uses square brackets with zero-based indexing to access elements, so the third element is at index 2.

2. Step 2: Identify correct syntax

   arr[2] accesses the third element; arr[3] accesses the fourth, arr(2) and arr{2} are invalid syntax.

3. Final Answer:

   arr[2] -> Option B

4. Quick Check:

   Third element = arr[2] [OK]

Hint: Use square brackets and zero-based index [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Using 1-based index
• Using curly braces for access

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

arr := [4]int{10, 20, 30, 40}
fmt.Println(arr[1])

medium

A. 10

B. 40

C. 20

D. 30

Solution

1. Step 1: Identify the array elements and their indexes

   The array is [10, 20, 30, 40], indexed 0 to 3. Index 1 corresponds to the second element, 20.

2. Step 2: Determine the printed value

   arr[1] accesses the element 20, so fmt.Println prints 20.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember index 1 is second element [OK]

Common Mistakes:

• Printing arr[0] instead
• Confusing index 1 with 2
• Expecting output as 30 or 40

4. What is wrong with this Go code snippet?

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

medium

A. Index 3 is out of bounds for the array

B. Array declaration syntax is incorrect

C. fmt.Println cannot print array elements

D. The array size should be 4

Solution

1. Step 1: Check array size and valid indexes

   The array has size 3, so valid indexes are 0, 1, and 2 only.

2. Step 2: Identify the error in accessing arr[3]

   Accessing arr[3] tries to get the fourth element, which does not exist, causing an out-of-bounds runtime error.

3. Final Answer:

   Index 3 is out of bounds for the array -> Option A

4. Quick Check:

   Valid indexes: 0 to 2 only [OK]

Hint: Array indexes go from 0 to length-1 [OK]

Common Mistakes:

• Using index equal to array length
• Thinking fmt.Println can't print elements
• Assuming array size auto-expands

5. Given the array arr := [5]int{5, 10, 15, 20, 25}, which code snippet correctly sums the first three elements?

hard

A. sum := arr[0] + arr[1] + arr[2]

B. sum := arr[1] + arr[2] + arr[3]

C. sum := arr[0] + arr[2] + arr[3]

D. sum := arr[2] + arr[3] + arr[4]

Solution

1. Step 1: Identify the first three elements

   The first three elements are at indexes 0, 1, and 2, which are 5, 10, and 15 respectively.

2. Step 2: Check which option sums these elements

   sum := arr[0] + arr[1] + arr[2] sums arr[0], arr[1], and arr[2], which is correct. Other options include elements beyond the first three.

3. Final Answer:

   sum := arr[0] + arr[1] + arr[2] -> Option A

4. Quick Check:

   Sum first three = arr[0]+arr[1]+arr[2] [OK]

Hint: Sum elements at indexes 0, 1, and 2 for first three [OK]

Common Mistakes:

• Starting sum at index 1
• Skipping elements
• Including elements beyond first three