Array Access and Update at Index in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Array Update at Index

What is the output of the following Rust code that updates an array element at a specific index?

DSA Rust

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

A [10, 20, 30, 40, 50]

B [10, 20, 99, 40, 50]

C [99, 20, 30, 40, 50]

D Compilation error

💡 Hint

Remember that arrays in Rust are fixed size and mutable if declared with 'mut'.

The code changes the element at index 2 (third element) from 30 to 99. The rest remain unchanged.

❓ Predict Output

intermediate

Result of Out-of-Bounds Array Access

What happens when the following Rust code tries to access an array element out of bounds?

DSA Rust

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

A Prints 0

B Compilation error

C Runtime panic with index out of bounds error

D Prints garbage value

💡 Hint

Rust checks array bounds at runtime and panics if index is invalid.

Accessing arr[5] is out of bounds since arr has length 3. Rust panics at runtime with an index out of bounds error.

❓ Predict Output

advanced

Output After Multiple Array Updates

What is the output of this Rust program after multiple updates to the array elements?

DSA Rust

fn main() {
    let mut arr = [5, 10, 15, 20];
    arr[0] += 5;
    arr[3] -= 10;
    arr[1] = arr[2] * 2;
    println!("{:?}", arr);
}

A [10, 30, 15, 10]

B [5, 30, 15, 10]

C [10, 20, 15, 10]

D [10, 15, 15, 10]

💡 Hint

Apply each update step by step and track changes carefully.

arr[0] becomes 5+5=10, arr[3] becomes 20-10=10, arr[1] becomes arr[2]*2=15*2=30.

🔧 Debug

advanced

Identify the Error in Array Update

What error does this Rust code produce when trying to update an array element?

DSA Rust

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

A Cannot assign to `arr[1]` because `arr` is not mutable

B Index out of bounds error at runtime

C Compilation error: missing semicolon

D No error, prints [1, 10, 3]

💡 Hint

Check if the array is declared mutable before updating.

The array is declared without 'mut', so it cannot be changed. Rust compiler prevents this with an error.

🧠 Conceptual

expert

Understanding Rust Array Indexing and Mutability

Which statement about Rust arrays and indexing is TRUE?

A Arrays in Rust can be resized dynamically after declaration

B Accessing an array element with an invalid index causes a compile-time error

C Rust arrays allow negative indices to access elements from the end

D You must declare an array as mutable to update its elements

💡 Hint

Think about mutability and safety in Rust arrays.

Rust arrays have fixed size and require 'mut' to update elements. Out-of-bounds access causes runtime panic, not compile error. Negative indices are not allowed.

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