Why Arrays Exist and What Problem They Solve in DSA Go - Why This Pattern

Mental Model

Arrays store many items in one place so you can find them quickly by position.

Analogy: Think of an egg carton holding eggs in fixed spots so you can grab the third egg without checking all eggs.

[0] -> 5
[1] -> 8
[2] -> 3
[3] -> 7
[4] -> 1

Dry Run Walkthrough

Input: Store numbers 5, 8, 3, 7, 1 in an array and get the value at position 2

Goal: Show how arrays let us quickly find the value at a specific position without searching all items

Step 1: Create an array with 5 numbers

[0] -> 5
[1] -> 8
[2] -> 3
[3] -> 7
[4] -> 1

Why: We need a place to store multiple numbers in order

Step 2: Access the value at position 2

[0] -> 5
[1] -> 8
[2] -> [3] ← accessed
[3] -> 7
[4] -> 1

Why: Arrays let us jump directly to position 2 without checking others

Step 3: Return the value found at position 2

[0] -> 5
[1] -> 8
[2] -> 3
[3] -> 7
[4] -> 1

Why: We got the value 3 quickly because arrays store items in order and fixed spots

Result:

[0] -> 5
[1] -> 8
[2] -> 3
[3] -> 7
[4] -> 1
Value at position 2 is 3

Annotated Code

DSA Go

package main

import "fmt"

func main() {
	// Step 1: Create an array with 5 numbers
	numbers := [5]int{5, 8, 3, 7, 1}

	// Step 2: Access the value at position 2
	value := numbers[2]

	// Step 3: Print the array and the accessed value
	for i, v := range numbers {
		fmt.Printf("[%d] -> %d\n", i, v)
	}
	fmt.Printf("Value at position 2 is %d\n", value)
}

numbers := [5]int{5, 8, 3, 7, 1}

Create an array with fixed size and values

value := numbers[2]

Directly access the value at index 2 for fast retrieval

for i, v := range numbers { fmt.Printf("[%d] -> %d\n", i, v) }

Print all array elements with their positions

fmt.Printf("Value at position 2 is %d\n", value)

Show the accessed value from the array

Output

[0] -> 5

[1] -> 8

[2] -> 3

[3] -> 7

[4] -> 1

Value at position 2 is 3

Complexity Analysis

Time: O(1) for access because arrays allow direct jump to any position using the index

Space: O(n) because arrays allocate space for all n elements upfront

vs Alternative: Compared to linked lists, arrays provide faster access by index but have fixed size and costly insertions/deletions

Edge Cases

Empty array

Accessing any position causes an error or panic because no elements exist

DSA Go

value := numbers[2] // will panic if array is empty or index out of range

Accessing index out of bounds

Program crashes or errors because the position does not exist

DSA Go

value := numbers[2] // must ensure index < len(numbers)

When to Use This Pattern

When you need to store many items and access them quickly by position, arrays are the go-to structure because they provide direct access by index.

Common Mistakes

Mistake: Trying to access an index outside the array size causing runtime errors
Fix: Always check that the index is within the array bounds before accessing

Summary

Arrays store multiple items in order and let you find any item quickly by its position.

Use arrays when you want fast access to elements by index and know the number of items in advance.

The key insight is that arrays keep items in fixed spots so you can jump directly to any position without searching.

Practice

1. Why do arrays exist in programming languages like Go?

easy

A. To perform mathematical calculations faster

B. To store values of different types in a single variable

C. To store multiple values of the same type in a fixed-size sequence

D. To replace all other data structures

Solution

1. Step 1: Understand the purpose of arrays

   Arrays are designed to hold multiple values of the same type together in a fixed-size sequence.

2. Step 2: Compare with other options

   The other options describe features not specific to arrays or are incorrect.

3. Final Answer:

   To store multiple values of the same type in a fixed-size sequence -> Option C

4. Quick Check:

   Arrays = fixed-size same-type storage [OK]

Hint: Arrays hold same-type items in order with fixed size [OK]

Common Mistakes:

• Thinking arrays can store different types together
• Confusing arrays with lists or slices
• Believing arrays perform calculations themselves

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

easy

A. var arr [5]int

B. int arr[5]

C. var arr []int = make(5)

D. arr := []int{5}

Solution

1. Step 1: Recall Go array declaration syntax

   In Go, arrays are declared with fixed size: var arr [5]int declares an array of 5 integers.

2. Step 2: Analyze other options

   int arr[5] is invalid C-style syntax in Go. var arr []int = make(5) uses make incorrectly (make is for slices, not arrays). arr := []int{5} declares a slice, not an array.

3. Final Answer:

   var arr [5]int -> Option A

4. Quick Check:

   Array declaration = var arr [size]type [OK]

Hint: Use var name [size]type for arrays in Go [OK]

Common Mistakes:

• Using make() for arrays instead of slices
• Confusing slices with arrays
• Initializing arrays with fewer elements than size without explicit zeros

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

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

medium

A. [10 20]

B. [10 20 30]

C. [0 0 0]

D. Compilation error

Solution

1. Step 1: Understand array initialization and assignment

   The array of size 3 is declared with default zeros. Then each index is assigned 10, 20, and 30 respectively.

2. Step 2: Print the array

   Printing the array shows all elements in order: [10 20 30].

3. Final Answer:

   [10 20 30] -> Option B

4. Quick Check:

   Array after assignments = [10 20 30] [OK]

Hint: Arrays print all elements in order inside brackets [OK]

Common Mistakes:

• Expecting commas between elements in output
• Thinking unassigned elements remain uninitialized
• Confusing slices and arrays output format

4. Identify the error in this Go code snippet that tries to assign a value to an array element:

package main
func main() {
  var arr [3]int
  arr[3] = 100
}

medium

A. Index out of range error at runtime

B. Compilation error: index 3 out of bounds

C. No error, code runs fine

D. Array size is not declared

Solution

1. Step 1: Check array size and index used

   The array has size 3, so valid indices are 0, 1, and 2. Index 3 is out of bounds.

2. Step 2: Understand Go's bounds checking

   Go performs bounds checking at runtime and panics with an index out of range error on out-of-bounds access.

3. Final Answer:

   Index out of range error at runtime -> Option A

4. Quick Check:

   Array index must be less than size [OK]

Hint: Array indices go from 0 to size-1 only [OK]

Common Mistakes:

• Using index equal to array size
• Expecting runtime error instead of compile error
• Confusing slices with arrays for index bounds

5. You want to store the daily temperatures for a week using an array in Go. Which of the following is the best approach and why?

medium

A. Use a single float64 variable and update it daily

B. Use a slice without fixed size to store temperatures

C. Use a map with string keys for days and float64 values

D. Use an array of size 7 with type float64 to store temperatures

Solution

1. Step 1: Analyze the problem requirements

   We need to store exactly 7 temperature values, one for each day of the week.

2. Step 2: Choose the best data structure

   An array of size 7 with float64 type fits perfectly because the size is fixed and known. Slices or maps add unnecessary overhead here. A single variable cannot hold multiple values.

3. Final Answer:

   Use an array of size 7 with type float64 to store temperatures -> Option D

4. Quick Check:

   Fixed-size data = array best choice [OK]

Hint: Fixed known size? Use array for efficient storage [OK]

Common Mistakes:

• Choosing slices when size is fixed and known
• Using maps when order matters and keys are unnecessary
• Trying to store multiple values in one variable