Array Traversal Patterns in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is array traversal?

Array traversal means visiting each element in an array one by one to perform some operation like reading or modifying the elements.

beginner

How do you traverse an array forwards in Rust?

You use a for loop like for element in &array { /* use element */ } to visit elements from the first to the last.

intermediate

What is the difference between iter() and iter_mut() in Rust array traversal?

iter() lets you read elements without changing them, while iter_mut() lets you change elements during traversal.

intermediate

How can you traverse an array backwards in Rust?

Use array.iter().rev() to visit elements from last to first.

intermediate

Why is it important to avoid modifying an array while traversing it forwards?

Modifying an array while traversing can cause unexpected behavior or skip elements. It's safer to use separate loops or iterators that allow mutation.

Which Rust method allows you to traverse an array without changing its elements?

A iter()

B iter_mut()

C into_iter()

D rev()

iter() provides read-only access to elements during traversal.

How do you traverse an array backwards in Rust?

A array.iter_mut()

B for element in array {}

C array.iter().rev()

D array.into_iter()

Using array.iter().rev() visits elements from last to first.

What does iter_mut() allow you to do?

A Modify elements during traversal

B Read elements only

C Traverse backwards

D Create a new array

iter_mut() gives mutable references to elements so you can change them.

What is the safest way to modify elements in an array while traversing?

A Use iter()

B Use iter_mut()

C Modify elements directly in a for loop without iterators

D Use rev()

iter_mut() safely allows modification during traversal.

What happens if you modify an array while traversing it with a simple for loop?

A No effect

B Array becomes immutable

C Automatically reverses traversal

D May skip or repeat elements

Modifying during traversal can cause unexpected behavior like skipping elements.

Explain how to traverse an array forwards and backwards in Rust, including how to modify elements safely.

Think about read-only vs mutable iteration methods.

Describe why modifying an array during traversal can be problematic and how Rust helps prevent errors.

Consider safety and predictable behavior.

Practice

1. What does the following Rust code snippet do?
for i in 0..5 { println!("{}", i); }

easy

A. Prints numbers from 1 to 4

B. Prints numbers from 1 to 5

C. Prints numbers from 0 to 5

D. Prints numbers from 0 to 4

Solution

1. Step 1: Understand the range syntax 0..5

   The range 0..5 in Rust includes numbers starting at 0 up to but not including 5.

2. Step 2: Trace the loop iterations

   The loop variable i takes values 0, 1, 2, 3, and 4, printing each number.

3. Final Answer:

   Prints numbers from 0 to 4 -> Option D

4. Quick Check:

   Range 0..5 excludes 5, so output is 0 to 4 [OK]

Hint: Remember Rust ranges exclude the end number [OK]

Common Mistakes:

• Thinking 0..5 includes 5
• Confusing 0..5 with 0..=5
• Assuming loop starts at 1

2. Which of the following is the correct syntax to iterate over the indices of an array arr in Rust?

easy

A. for i in 0..arr.len() { println!("{}", arr[i]); }

B. for i in 0..arr { println!("{}", i); }

C. for i in arr { println!("{}", i); }

D. for i in arr.len() { println!("{}", i); }

Solution

1. Step 1: Check valid iteration over array indices

   Rust arrays have a length method .len(), so 0..arr.len() gives valid indices.

2. Step 2: Access elements by index

   Using arr[i] inside the loop accesses each element correctly.

3. Final Answer:

   for i in 0..arr.len() { println!("{}", arr[i]); } -> Option A

4. Quick Check:

   Use 0..arr.len() for index-based iteration [OK]

Hint: Use arr.len() for array length, not arr alone [OK]

Common Mistakes:

• Using 0..arr instead of 0..arr.len()
• Trying to iterate directly over arr without reference
• Using arr.len() without range syntax

3. What is the output of this Rust code?

let arr = [10, 20, 30];
for i in (0..arr.len()).rev() {
    print!("{} ", arr[i]);
}

medium

A. 10 20 30

B. 0 1 2

C. 30 20 10

D. Compilation error

Solution

1. Step 1: Understand the range and reverse

   The range 0..arr.len() is 0..3, which is 0,1,2. Using .rev() reverses it to 2,1,0.

2. Step 2: Print elements in reverse order

   arr[2] = 30, arr[1] = 20, arr[0] = 10, so output is "30 20 10 "

3. Final Answer:

   30 20 10 -> Option C

4. Quick Check:

   Reverse iteration prints elements backward [OK]

Hint: Use .rev() to reverse range iteration [OK]

Common Mistakes:

• Forgetting .rev() reverses the order
• Printing indices instead of array values
• Confusing range end with inclusive

4. Identify the error in this Rust code snippet that tries to print all elements of an array arr:

let arr = [1, 2, 3];
for i in 0..arr.len() {
    println!("{}", arr[i+1]);
}

medium

A. Syntax error due to missing semicolon

B. Index out of bounds error at runtime

C. No error, prints all elements correctly

D. Compilation error due to type mismatch

Solution

1. Step 1: Analyze the loop indices and access

   The loop runs i from 0 to 2 (arr.len()=3). Accessing arr[i+1] means indices 1,2,3.

2. Step 2: Identify out of bounds access

   arr[3] does not exist, causing runtime panic (index out of bounds).

3. Final Answer:

   Index out of bounds error at runtime -> Option B

4. Quick Check:

   Accessing arr[i+1] exceeds array length [OK]

Hint: Check array indices carefully to avoid out of bounds [OK]

Common Mistakes:

• Assuming arr[i+1] is safe for all i
• Ignoring runtime panics
• Confusing compile-time and runtime errors

5. Given a Rust array arr of integers, which code snippet correctly prints only the even-indexed elements (0, 2, 4, ...) of the array?

hard

A. for i in (0..arr.len()).step_by(2) { println!("{}", arr[i]); }

B. for i in 0..arr.len() { if i % 2 == 1 { println!("{}", arr[i]); } }

C. for i in 0..arr.len() { println!("{}", arr[i * 2]); }

D. for i in (0..arr.len()).rev().step_by(2) { println!("{}", arr[i]); }

Solution

1. Step 1: Understand step_by usage

   The method step_by(2) skips every second index, so 0, 2, 4, ...

2. Step 2: Confirm correct element access

   Using arr[i] inside the loop prints elements at even indices correctly.

3. Final Answer:

   for i in (0..arr.len()).step_by(2) { println!("{}", arr[i]); } -> Option A

4. Quick Check:

   step_by(2) iterates over even indices [OK]

Hint: Use step_by(2) to jump every two elements [OK]

Common Mistakes:

• Using i % 2 == 1 instead of 0 for even indices
• Multiplying i by 2 causing out of bounds
• Using rev() which reverses order unnecessarily