Array Traversal Patterns in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested loop traversal over array

What is the output of this Rust code that traverses a 2D array with nested loops?

DSA Rust

fn main() {
    let arr = [[1, 2], [3, 4]];
    for i in 0..arr.len() {
        for j in 0..arr[i].len() {
            print!("{} ", arr[i][j]);
        }
    }
}

A 2 1 4 3

B 1 2 3 4

C 4 3 2 1

D 1 3 2 4

💡 Hint

Think about how nested loops iterate row by row, then column by column.

The outer loop goes over each row, and the inner loop goes over each element in that row, printing elements in order: 1, 2, then 3, 4.

❓ Predict Output

intermediate

Output of reverse traversal using iterators

What is the output of this Rust code that traverses an array in reverse using iterators?

DSA Rust

fn main() {
    let arr = [10, 20, 30, 40];
    for &val in arr.iter().rev() {
        print!("{} ", val);
    }
}

A 40 30 20 10

B 10 20 30 40

C 40 20 30 10

D 30 40 20 10

💡 Hint

The rev() method reverses the iterator order.

The iterator goes from the last element to the first, printing 40 30 20 10.

🔧 Debug

advanced

Identify the runtime error in array traversal

What runtime error does this Rust code produce when traversing an array?

DSA Rust

fn main() {
    let arr = [5, 10, 15];
    for i in 0..=arr.len() {
        println!("{}", arr[i]);
    }
}

A Index out of bounds panic

B No error, prints 5 10 15 0

C Prints 5 10 15 twice

D Compilation error due to invalid range

💡 Hint

Check the range used for indexing the array.

The loop uses 0..=arr.len(), which includes arr.len() as an index, causing an out of bounds panic at runtime.

🧠 Conceptual

advanced

Understanding stride in array traversal

If you want to traverse an array skipping every other element, which Rust iterator method is best to use?

A arr.iter().filter(|&x| x % 2 == 0)

B arr.iter().skip(2)

C arr.iter().rev()

D arr.iter().step_by(2)

💡 Hint

Think about how to jump indices by a fixed step.

step_by(2) makes the iterator jump two elements at a time, effectively skipping every other element.

🚀 Application

expert

Find the sum of elements at even indices

Given an array of integers, which Rust code correctly calculates the sum of elements at even indices (0, 2, 4, ...)?

A arr.iter().filter(|&v| v % 2 == 0).sum::<i32>()

B arr.iter().step_by(2).sum::<i32>()

C arr.iter().enumerate().filter(|(i, _)| i % 2 == 0).map(|(_, &v)| v).sum::<i32>()

D arr.iter().enumerate().map(|(i, &v)| if i % 2 == 0 { v } else { 0 }).sum::<i32>()

💡 Hint

You need to check indices, not values, to select elements.

Option C uses enumerate to get indices, filters even indices, then sums values. Option C is valid and works correctly for arrays, but may be less clear in some contexts. Option C is the most explicit and safe approach.

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