Array Access and Update at Index in DSA Rust

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 put mail in a mailbox, you just use its number without opening all the boxes before it.

[0] -> 10
[1] -> 20
[2] -> 30
[3] -> 40
[4] -> 50

Dry Run Walkthrough

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

Goal: Change the value at position 2 from 30 to 35 and show the updated array

Step 1: Access the element at index 2

[0] -> 10
[1] -> 20
[2] -> 30 ↑
[3] -> 40
[4] -> 50

Why: We need to find the exact box to update

Step 2: Update the element at index 2 to 35

[0] -> 10
[1] -> 20
[2] -> 35 ↑
[3] -> 40
[4] -> 50

Why: Replace old value with new value at the correct position

Step 3: Print the updated array

[0] -> 10
[1] -> 20
[2] -> 35
[3] -> 40
[4] -> 50

Why: Show the final updated state of the array

Result:

[10, 20, 35, 40, 50]

Annotated Code

DSA Rust

fn main() {
    let mut arr = [10, 20, 30, 40, 50];
    let index = 2;
    let new_value = 35;

    // Access the element at index 2
    let old_value = arr[index];
    println!("Old value at index {}: {}", index, old_value);

    // Update the element at index 2
    arr[index] = new_value;

    // Print the updated array
    println!("Updated array: {:?}", arr);
}

let old_value = arr[index];

Access the element at the given index to read its current value

arr[index] = new_value;

Update the element at the given index with the new value

println!("Updated array: {:?}", arr);

Display the entire array after the update

Output

Old value at index 2: 30

Updated array: [10, 20, 35, 40, 50]

Complexity Analysis

Time: O(1) because accessing or updating an element by index in an array takes constant time

Space: O(1) because no extra space is needed beyond the original array

vs Alternative: Compared to linked lists, arrays allow direct access by index in constant time, while linked lists require traversal which takes O(n)

Edge Cases

Index is out of array bounds

Program will panic or error because the index does not exist

DSA Rust

let old_value = arr[index];

Array has only one element

Access and update still work normally at index 0

DSA Rust

let old_value = arr[index];

When to Use This Pattern

When you need to quickly read or change a value at a specific position in a fixed-size collection, use array access and update by index for constant time operations.

Common Mistakes

Mistake: Trying to access or update an index outside the array length
Fix: Always check that the index is within 0 and array length minus one before accessing

Summary

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

Use it when you know the exact position of the item you want to read or update.

The key is that arrays let you jump straight to any position without looking at others first.

Practice

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

easy

A. Removes the element at index 2

B. Adds 2 to every element in the array

C. Accesses the element at index 2 of the array

D. Returns the length of the array

Solution

1. Step 1: Understand array indexing

   In Rust, arrays use zero-based indexing, so arr[2] accesses the third element.

2. Step 2: Identify the operation

   The expression retrieves the value stored at index 2 without modifying the array.

3. Final Answer:

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

4. Quick Check:

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

Hint: Remember arrays start at index 0 in Rust [OK]

Common Mistakes:

• Thinking indexing starts at 1
• Confusing access with modification
• Assuming it returns array length

2. Which of the following is the correct syntax to update the element at index 1 of a mutable array arr to 10 in Rust?

easy

A. arr[1] = 10;

B. arr(1) = 10;

C. arr{1} = 10;

D. arr->1 = 10;

Solution

1. Step 1: Recall Rust array update syntax

   In Rust, to update an element, use square brackets with the index and assign a new value.

2. Step 2: Check each option

   Only arr[1] = 10; uses correct square bracket indexing and assignment syntax.

3. Final Answer:

   arr[1] = 10; -> Option A

4. Quick Check:

   Use square brackets for indexing and assignment [OK]

Hint: Use square brackets [] for indexing and assignment [OK]

Common Mistakes:

• Using parentheses () instead of brackets
• Using curly braces {} for indexing
• Using arrow operator -> incorrectly

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

fn main() {
    let mut arr = [5, 10, 15, 20];
    arr[2] = 25;
    println!("{:?}", arr);
}

medium

A. [5, 10, 15, 20]

B. Compilation error

C. [25, 10, 15, 20]

D. [5, 10, 25, 20]

Solution

1. Step 1: Analyze array initialization and update

   The array arr starts as [5, 10, 15, 20]. The statement arr[2] = 25; changes the element at index 2 (third element) from 15 to 25.

2. Step 2: Understand the print output

   The println!("{:?}", arr); prints the entire array showing the updated value.

3. Final Answer:

   [5, 10, 25, 20] -> Option D

4. Quick Check:

   Updated index 2 to 25, array prints updated [OK]

Hint: Remember index 2 is third element, updated value shows in print [OK]

Common Mistakes:

• Thinking index 2 is second element
• Assuming original array prints without update
• Expecting compilation error due to mutability

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

fn main() {
    let arr = [1, 2, 3];
    arr[1] = 5;
    println!("{:?}", arr);
}

medium

A. Cannot assign to element of immutable array

B. Index out of bounds error

C. Syntax error in array declaration

D. Missing semicolon after assignment

Solution

1. Step 1: Check array mutability

   The array arr is declared without mut, so it is immutable and cannot be changed.

2. Step 2: Identify assignment error

   The line arr[1] = 5; tries to modify an immutable array element, causing a compile-time error.

3. Final Answer:

   Cannot assign to element of immutable array -> Option A

4. Quick Check:

   Immutable arrays cannot be updated [OK]

Hint: Declare array with 'mut' to allow updates [OK]

Common Mistakes:

• Ignoring mut keyword for mutability
• Assuming index out of bounds error
• Thinking syntax error causes failure

5. Given a mutable array arr of length 4 initialized as [2, 4, 6, 8], which code snippet correctly doubles the value at index 3 and then prints the updated array?

hard

A. arr[4] = arr[4] * 2;
println!("{:?}", arr);

B. arr[3] = arr[3] * 2;
println!("{:?}", arr);

C. arr[3] *= 2
println!("{:?}", arr);

D. arr[3] = arr[3] + 2;
println!("{:?}", arr);

Solution

1. Step 1: Identify correct index and operation

   Index 3 is the fourth element (value 8). Doubling means multiplying by 2, so arr[3] = arr[3] * 2; is correct.

2. Step 2: Check syntax and print statement

   arr[3] = arr[3] * 2; println!("{:?}", arr); uses correct syntax with semicolon and prints the updated array properly.

3. Final Answer:

   arr[3] = arr[3] * 2; println!("{:?}", arr); -> Option B

4. Quick Check:

   Multiply element at index 3 by 2, then print [OK]

Hint: Use correct index and multiply, remember semicolons [OK]

Common Mistakes:

• Using index 4 which is out of bounds
• Forgetting semicolon after assignment
• Adding 2 instead of multiplying by 2