Array Access and Update at Index in DSA Rust - 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 O(1) time because arrays allow direct access using the index.

beginner

How do you update the value at index 2 in a Rust array named arr?

You can update the value at index 2 by assigning a new value like this:
arr[2] = new_value;

intermediate

What happens if you try to access an index outside the bounds of a Rust array?

Rust will panic at runtime with an index out of bounds error because it checks array bounds to prevent unsafe memory access.

beginner

Explain the difference between accessing and updating an array element.

Accessing means reading the value at a given index without changing it. Updating means changing the value stored at that index.

intermediate

In Rust, how can you safely access an element at index 3 without risking a panic?

Use the get method:
arr.get(3) returns Option<&T>. It returns Some(&value) if index exists, or None if out of bounds.

What is the correct way to update the 4th element of a Rust array named arr to 10?

A arr[3] = 10;

B arr[4] = 10;

C arr.update(3, 10);

D arr.set(4, 10);

Array indices start at 0, so the 4th element is at index 3. The syntax arr[3] = 10; updates it.

What will happen if you try to access arr[10] in a Rust array of length 5?

A Returns None

B Returns the value at index 10

C Panics with index out of bounds error

D Returns zero

Rust checks array bounds at runtime and will panic if you access an invalid index.

Which method allows safe access to an array element in Rust without panicking?

A arr[5]

B arr.safe(5)

C arr.access(5)

D arr.get(5)

The get method returns an Option type, allowing safe access.

What is the output of this Rust code?

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

A [1, 5, 3]

B [5, 2, 3]

C [1, 2, 3]

D Compilation error

The element at index 1 is updated to 5, so the array becomes [1, 5, 3].

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

A O(n)

B O(1)

C O(n^2)

D O(log n)

Updating an element at a specific index is a direct operation and takes constant time O(1).

Describe how to access and update an element at a specific index in a Rust array. Include what happens if the index is invalid.

Think about direct indexing and safe methods.

Explain why array access and update operations are fast and what their time complexity is.

Consider how arrays are stored in memory.

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