Array declaration in Go - Time & Space Complexity

Time Complexity: Array declaration

O(n)

Understanding Time Complexity

When we declare an array in Go, it is important to understand how this affects the program's speed as the array size changes.

We want to know how the time to create an array grows when the array gets bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func main() {
    var numbers [100]int
    for i := 0; i < len(numbers); i++ {
        numbers[i] = i * 2
    }
}

This code declares an array of 100 integers and fills it with values by looping through each position.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that assigns values to each element in the array.
• How many times: Exactly once for each element, so 100 times in this example.

How Execution Grows With Input

As the array size grows, the number of assignments grows at the same rate.

Input Size (n)	Approx. Operations
10	10 assignments
100	100 assignments
1000	1000 assignments

Pattern observation: The work grows directly with the size of the array; doubling the array doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to fill the array grows in a straight line with the number of elements.

Common Mistake

[X] Wrong: "Declaring an array is instant and does not depend on its size."

[OK] Correct: While declaration reserves space quickly, initializing or filling the array requires time proportional to its size.

Interview Connect

Understanding how array operations scale helps you explain your code choices clearly and shows you know how programs handle data efficiently.

Self-Check

"What if we replaced the array with a slice that grows dynamically? How would the time complexity change?"

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