Array Access and Update at Index in DSA Rust - Execution Trace

Concept Flow - Array Access and Update at Index

Start with array

↓

Access element at index i

↓

Read or update value

↓

Store updated value if any

↓

End operation

This flow shows how we start with an array, access an element by its index, optionally update it, and then finish the operation.

Execution Sample

DSA Rust

let mut arr = [10, 20, 30, 40, 50];
let val = arr[2];
arr[3] = 99;
println!("{:?}", arr);

This code reads the element at index 2 and updates the element at index 3, then prints the array.

Execution Table

Step	Operation	Index Accessed	Value Read	Value Updated	Array State
1	Initialize array	-	-	-	[10, 20, 30, 40, 50]
2	Access element	2	30	-	[10, 20, 30, 40, 50]
3	Update element	3	-	99	[10, 20, 30, 99, 50]
4	Print array	-	-	-	[10, 20, 30, 99, 50]

💡 All operations complete; array updated at index 3.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
arr	[10, 20, 30, 40, 50]	[10, 20, 30, 40, 50]	[10, 20, 30, 99, 50]	[10, 20, 30, 99, 50]
val	undefined	30	30	30

Key Moments - 3 Insights

Why does accessing arr[2] give 30 and not 20 or 40?

Because array indexing starts at 0, so arr[0]=10, arr[1]=20, arr[2]=30. See execution_table step 2.

What happens if we update arr[3] to 99?

The element at index 3 changes from 40 to 99, as shown in execution_table step 3 and variable_tracker for arr.

Does accessing an index change the array?

No, reading arr[2] only reads the value without changing the array. Confirmed in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value read at step 2?

A 20

B 30

C 40

D 99

💡 Hint

Check the 'Value Read' column at step 2 in the execution_table.

At which step does the array change its content?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Value Updated' and 'Array State' columns in execution_table.

If we tried to access arr[5], what would happen?

A Error: index out of bounds

B Return 0

C Return 50

D Return last element

💡 Hint

Arrays in Rust have fixed size; accessing beyond last index causes runtime error.

Concept Snapshot

Array Access and Update at Index:
- Use arr[index] to read value at position index (0-based).
- Use arr[index] = value to update element at index.
- Index must be within array bounds.
- Reading does not change array; updating changes element.
- Common in Rust for fixed-size arrays.

Full Transcript

This concept shows how to access and update elements in an array by index. We start with an array of values. Accessing an element uses its zero-based index to read the value without changing the array. Updating an element replaces the value at that index. The example code reads the value at index 2, which is 30, then updates the value at index 3 from 40 to 99. The final array reflects this change. Accessing an invalid index causes an error. This is a fundamental operation in arrays in Rust and many other languages.

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