Array declaration in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of array length and values

What is the output of this Go program?

Go

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

A

3
0

B

3
1

C

3
2

D

2
2

💡 Hint

Remember that len(arr) returns the number of elements, and indexing starts at 0.

The array has 3 elements, so len(arr) is 3. The element at index 1 is the second element, which is 2.

❓ Predict Output

intermediate

Array default values

What will this Go program print?

Go

package main
import "fmt"
func main() {
    var arr [4]int
    fmt.Println(arr[2])
}

A undefined

B 2

C nil

D 0

💡 Hint

Uninitialized int array elements have a default value.

In Go, arrays of int type are initialized with zero values, so arr[2] is 0.

📝 Syntax

advanced

Identify the correct array declaration

Which option correctly declares an array of 5 strings in Go?

A arr := [5]string{}

B var arr [5]string

C var arr []string = make([]string, 5)

D var arr [5] = string{}

💡 Hint

Arrays have fixed size and type in Go, slices are different.

Option B declares a fixed-size array of 5 strings. Option B is invalid syntax because it lacks the type after :=. Option B declares a slice, not an array. Option B has wrong syntax for array type.

❓ Predict Output

advanced

Array initialization and zero values

What is the output of this Go program?

Go

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

A 0

B 2

C runtime error

D 3

💡 Hint

Uninitialized elements in an array get zero values.

The array has 4 elements, only first two initialized. The third element (index 2) is zero by default.

🧠 Conceptual

expert

Array vs Slice declaration difference

Which option correctly describes the difference between arrays and slices in Go?

A Arrays have fixed size known at compile time; slices are dynamic and reference arrays.

B Slices have fixed size; arrays can grow dynamically.

C Arrays and slices are the same in Go, just different names.

D Arrays are pointers to slices internally.

💡 Hint

Think about size and mutability differences.

Arrays have fixed size and store elements directly. Slices are dynamic, can grow, and reference underlying arrays.

Practice

1. What does the following Go code declare?
var arr [3]int

easy

A. A slice of integers with length 3

B. An array of 3 integers initialized with zero values

C. A pointer to an integer array

D. A map with integer keys and values

Solution

1. Step 1: Understand the syntax var arr [3]int

   This declares a fixed-size array named arr with 3 elements, each of type int.

2. Step 2: Recognize default initialization

   In Go, arrays are initialized with zero values for their type, so all 3 integers start as 0.

3. Final Answer:

   An array of 3 integers initialized with zero values -> Option B

4. Quick Check:

   Array declaration = fixed size + type + zero values [OK]

Hint: Remember: [n]type means fixed size array of n elements [OK]

Common Mistakes:

• Confusing array with slice declaration
• Thinking it creates a pointer or map
• Assuming uninitialized values are random

2. Which of the following is the correct way to declare an array of 4 strings in Go?

easy

A. var arr [4]string

B. var arr []string{4}

C. arr := [4]string{}

D. var arr string[4]

Solution

1. Step 1: Check Go array declaration syntax

   Arrays are declared with var name [size]type. So var arr [4]string is correct.

2. Step 2: Analyze other options

   var arr []string{4} uses slice syntax incorrectly. arr := [4]string{} is valid short declaration syntax in Go. var arr string[4] reverses size and type, which is invalid.

3. Final Answer:

   var arr [4]string -> Option A

4. Quick Check:

   Array syntax = var name [size]type [OK]

Hint: Array size goes inside brackets before type [OK]

Common Mistakes:

• Using slice syntax instead of array syntax
• Placing size after type
• Missing var keyword or wrong initialization

3. What is the output of this Go program?

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

medium

A. 10

B. 0

C. 30

D. 20

Solution

1. Step 1: Understand array initialization

   The array nums has 3 integers: 10 at index 0, 20 at index 1, and 30 at index 2.

2. Step 2: Access element at index 1

   Printing nums[1] outputs the second element, which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Array index starts at 0, nums[1] = 20 [OK]

Hint: Array indexes start at 0; second element is index 1 [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Expecting output 10 or 30 instead of 20
• Thinking array is zero-indexed but printing wrong element

4. Identify the error in this Go array declaration:

var arr [3]int = {1, 2, 3}

medium

A. Array initialization syntax is incorrect

B. Braces {} should be replaced with []

C. Missing keyword 'var'

D. Array size must be omitted

Solution

1. Step 1: Review array initialization syntax

   In Go, when initializing an array with values, the correct syntax is var arr = [3]int{1, 2, 3} or arr := [3]int{1, 2, 3}.

2. Step 2: Identify the error

   The code uses var arr [3]int = {1, 2, 3} which misses the array type on the right side before the braces. This causes a syntax error.

3. Final Answer:

   Array initialization syntax is incorrect -> Option A

4. Quick Check:

   Array init needs type before braces [OK]

Hint: Array init needs type before braces, like [3]int{...} [OK]

Common Mistakes:

• Omitting array type on right side during initialization
• Using wrong braces or brackets
• Trying to assign without proper syntax

5. How can you declare and initialize a 2D array of integers with 2 rows and 3 columns in Go?

hard

A. var matrix [2][3]int = [2][3]int{{1,2,3},{4,5,6}}

B. var matrix [][]int = {{1,2,3},{4,5,6}}

C. matrix := [2][3]int{{1,2,3},{4,5,6}}

D. var matrix [3][2]int = {{1,2},{3,4},{5,6}}

Solution

1. Step 1: Understand 2D array declaration

   A 2D array with 2 rows and 3 columns is declared as [2][3]int. Both dimensions must be specified.

2. Step 2: Check initialization syntax

   matrix := [2][3]int{{1,2,3},{4,5,6}} uses short declaration with := and correctly initializes the 2D array with two rows of three integers each.

3. Step 3: Analyze other options

   var matrix [2][3]int = [2][3]int{{1,2,3},{4,5,6}} is correct syntax but uses explicit var with type on both sides (valid but less common). var matrix [][]int = {{1,2,3},{4,5,6}} is a slice of slices, not an array. var matrix [3][2]int = {{1,2},{3,4},{5,6}} has dimensions reversed (3 rows, 2 columns).

4. Final Answer:

   matrix := [2][3]int{{1,2,3},{4,5,6}} -> Option C

5. Quick Check:

   2D array = [rows][cols]type with nested braces [OK]

Hint: Use [rows][cols]type with nested braces to initialize [OK]

Common Mistakes:

• Confusing slices with arrays
• Swapping row and column sizes
• Missing nested braces for 2D arrays