Array Access and Update at Index in DSA Go

Mental Model

An array is like a row of boxes where each box has a number. You can quickly find or change the item in any box by using its number.

Analogy: Imagine a row of mailboxes numbered from 0 upwards. To get or change the mail in mailbox number 3, you just go directly to mailbox 3 without checking others.

[0] -> [1] -> [2] -> [3] -> [4]
 ↑
 index 0 points here

Dry Run Walkthrough

Input: array: [10, 20, 30, 40, 50], update index 2 with value 99

Goal: Change the value at index 2 from 30 to 99 and show the updated array

Step 1: Access the element at index 2 (which is 30)

[10] -> [20] -> [30↑] -> [40] -> [50]

Why: We need to find the exact box to update

Step 2: Replace the value at index 2 with 99

[10] -> [20] -> [99↑] -> [40] -> [50]

Why: We update the value in the box directly

Step 3: Finish update and show the full array

[10] -> [20] -> [99] -> [40] -> [50]

Why: The array now reflects the updated value

Result:

[10] -> [20] -> [99] -> [40] -> [50]

Annotated Code

DSA Go

package main

import "fmt"

func updateAtIndex(arr []int, index int, value int) {
    if index < 0 || index >= len(arr) {
        fmt.Println("Index out of range")
        return
    }
    arr[index] = value // update the value at the given index
}

func main() {
    arr := []int{10, 20, 30, 40, 50}
    fmt.Println("Before update:", arr)
    updateAtIndex(arr, 2, 99)
    fmt.Println("After update:", arr)
}

if index < 0 || index >= len(arr) {

check if index is valid to avoid errors

arr[index] = value // update the value at the given index

directly replace the element at the specified index

Output

Before update: [10 20 30 40 50]

After update: [10 20 99 40 50]

Complexity Analysis

Time: O(1) because accessing or updating an element by index in an array is immediate

Space: O(1) because no extra space is needed for the update operation

vs Alternative: Compared to linked lists where you must traverse nodes to reach an index (O(n)), arrays allow instant access and update at any index

Edge Cases

index is negative

prints 'Index out of range' and does not update

DSA Go

if index < 0 || index >= len(arr) {

index is equal or greater than array length

prints 'Index out of range' and does not update

DSA Go

if index < 0 || index >= len(arr) {

array is empty

prints 'Index out of range' for any index since no elements exist

DSA Go

if index < 0 || index >= len(arr) {

When to Use This Pattern

When a problem requires quick access or change of data at a specific position, use array indexing because it gives direct access in constant time.

Common Mistakes

Mistake: Trying to access or update an index outside the array bounds causing runtime errors
Fix: Always check if the index is within 0 and length-1 before accessing or updating

Summary

It lets you get or change the value at a specific position in an array instantly.

Use it when you need fast direct access or update to elements by their position.

Remember arrays let you jump straight to any box by its number without checking others.

Practice

1. What does the expression arr[2] do in an array arr?

easy

A. Accesses the element at index 3 of the array

B. Accesses the element at index 2 of the array

C. Updates the element at index 2 of the array

D. Deletes the element at index 2 of the array

Solution

1. Step 1: Understand array indexing

   Array indexing starts at 0, so index 2 means the third element.

2. Step 2: Identify the operation

   Using arr[2] accesses (reads) the element at index 2 without changing it.

3. Final Answer:

   Accesses the element at index 2 of the array -> Option B

4. Quick Check:

   arr[2] reads element at index 2 [OK]

Hint: Remember arrays start at 0 index [OK]

Common Mistakes:

• Thinking index 2 is the second element
• Confusing access with update
• Assuming indexing starts at 1

2. Which of the following is the correct syntax to update the element at index 1 in a Go array named nums to 10?

easy

A. nums[1] = 10

B. nums(1) = 10

C. nums[1] := 10

D. nums.update(1, 10)

Solution

1. Step 1: Recall Go array update syntax

   In Go, to update an element, use array[index] = value.

2. Step 2: Check each option

   nums[1] = 10 uses correct syntax. nums(1) = 10 uses parentheses which is invalid. nums[1] := 10 uses := which is for declaration, not update. nums.update(1, 10) uses a method that does not exist.

3. Final Answer:

   nums[1] = 10 -> Option A

4. Quick Check:

   Use square brackets and = for update [OK]

Hint: Use square brackets and = to update array element [OK]

Common Mistakes:

• Using parentheses instead of square brackets
• Using := instead of = for update
• Assuming arrays have update methods

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

package main
import "fmt"
func main() {
  arr := [4]int{5, 10, 15, 20}
  arr[2] = 25
  fmt.Println(arr)
}

medium

A. [5 10 25 20]

B. [5 10 15 20]

C. [25 10 15 20]

D. [5 25 15 20]

Solution

1. Step 1: Understand initial array and update

   Initial array is [5, 10, 15, 20]. The code updates element at index 2 (third element) to 25.

2. Step 2: Apply the update and print

   After update, array becomes [5, 10, 25, 20]. Printing shows this updated array.

3. Final Answer:

   [5 10 25 20] -> Option A

4. Quick Check:

   Index 2 updated to 25 [OK]

Hint: Index 2 means third element update [OK]

Common Mistakes:

• Confusing index 2 with index 1 or 3
• Not updating the array before print
• Expecting commas in printed array

4. Identify the error in the following Go code snippet:

package main
func main() {
  arr := [3]int{1, 2, 3}
  arr[3] = 4
}

medium

A. Cannot assign to arr[3] because arrays are immutable

B. Syntax error due to missing import

C. Index out of range error at arr[3]

D. No error, code runs fine

Solution

1. Step 1: Check array size and index used

   Array has size 3 with valid indices 0, 1, 2. Accessing arr[3] is invalid.

2. Step 2: Identify error type

   Accessing arr[3] causes runtime panic: index out of range error.

3. Final Answer:

   Index out of range error at arr[3] -> Option C

4. Quick Check:

   Index must be less than array length [OK]

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

Common Mistakes:

• Assuming arr[3] is valid for size 3 array
• Thinking arrays are immutable in Go
• Ignoring runtime errors

5. Given an array arr := [5]int{1, 2, 3, 4, 5}, which code snippet correctly doubles the value at each index using array access and update?

hard

A. for i := 1; i <= len(arr); i++ { arr[i] = arr[i] * 2 }

B. for i := 0; i < len(arr); i++ { arr[i] *= 2; arr[i+1] = arr[i] }

C. for i := 0; i < len(arr); i++ { arr[i+1] = arr[i] * 2 }

D. for i := 0; i < len(arr); i++ { arr[i] = arr[i] * 2 }

Solution

1. Step 1: Understand array length and valid indices

   Array length is 5, valid indices are 0 to 4. Loop must run from 0 to 4.

2. Step 2: Analyze each loop snippet

   for i := 0; i < len(arr); i++ { arr[i] = arr[i] * 2 } loops correctly and updates each element by doubling. for i := 1; i <= len(arr); i++ { arr[i] = arr[i] * 2 } uses i from 1 to 5, arr[5] is invalid index. for i := 0; i < len(arr); i++ { arr[i+1] = arr[i] * 2 } updates arr[i+1], which causes out of range at last iteration. for i := 0; i < len(arr); i++ { arr[i] *= 2; arr[i+1] = arr[i] } updates arr[i+1] inside loop, causing out of range and incorrect logic.

3. Final Answer:

   for i := 0; i < len(arr); i++ { arr[i] = arr[i] * 2 } -> Option D

4. Quick Check:

   Loop from 0 to len-1 and update arr[i] [OK]

Hint: Loop indices 0 to len-1 for safe access [OK]

Common Mistakes:

• Looping beyond array length causing index error
• Updating wrong indices inside loop
• Using <= instead of < in loop condition