Array Access and Update at Index in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the time complexity of accessing an element at a specific index in an array?

Accessing an element at a specific index in an array takes constant time, O(1), because arrays allow direct access to any element by its index.

beginner

How do you update the value at index 3 in an array named arr in Go?

You update the value by assigning a new value directly: arr[3] = newValue. This changes the element at index 3 to newValue.

intermediate

What happens if you try to access an index outside the bounds of an array in Go?

Accessing an index outside the array bounds causes a runtime panic (error) in Go, stopping the program. Always ensure the index is within 0 and array length - 1.

intermediate

Explain why arrays provide fast access to elements compared to linked lists.

Arrays store elements in contiguous memory locations, so the address of any element can be calculated directly using its index. Linked lists require traversal from the head to reach an element, making access slower.

intermediate

In Go, what is the difference between an array and a slice when accessing and updating elements?

Both arrays and slices allow access and update by index using []. However, slices are more flexible in size and are references to arrays, while arrays have fixed size and are values.

What is the correct way to update the 2nd element of an array arr to 10 in Go?

A arr[2] = 10

B arr.update(2, 10)

C arr[1] = 10

D arr.set(1, 10)

Array indices start at 0, so the 2nd element is at index 1. Use arr[1] = 10 to update it.

What happens if you try to access arr[5] when arr has length 5 in Go?

A Runtime panic (error)

B Returns zero value

C Returns the last element

D Compiles but undefined behavior

Accessing index 5 in an array of length 5 is out of bounds and causes a runtime panic in Go.

Which of these is true about array element access?

A Access time depends on element value

B Access time is constant O(1)

C Access time depends on array size

D Access time depends on previous elements

Arrays allow direct access to any element by index in constant time O(1).

How do you access the last element of an array arr in Go?

A arr[-1]

B arr[len(arr)]

C arr[last]

D arr[len(arr)-1]

Array indices go from 0 to len(arr)-1, so the last element is at index len(arr)-1.

Which data structure allows faster element access by index?

A Array

B Queue

C Stack

D Linked list

Arrays provide constant time access by index, faster than linked lists which require traversal.

Describe how you access and update an element at a specific index in an array.

Think about how you use the square brackets [] with the index.

Explain what happens if you try to access an array index that is out of bounds in Go.

Consider safety and errors in Go when accessing arrays.

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