Array Traversal Patterns in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print each element of the array.

DSA Rust

let arr = [10, 20, 30, 40];
for [1] in arr.iter() {
    println!("{}", [1]);
}

Drag options to blanks, or click blank then click option'

Ax

Bi

Cval

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that is not consistent inside the loop.

Trying to use the index instead of the element.

The variable 'i' is used to represent each element when iterating over the array.

2fill in blank

medium

Complete the code to sum all elements in the array.

DSA Rust

let arr = [1, 2, 3, 4, 5];
let mut sum = 0;
for &[1] in arr.iter() {
    sum += [1];
}
println!("Sum: {}", sum);

Drag options to blanks, or click blank then click option'

Ax

Bval

Cnum

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to dereference the element with '&'.

Using a variable name inconsistent inside the loop.

The variable 'num' holds each element's value during iteration and is used to add to sum.

3fill in blank

hard

Fix the error in the code to print elements with their indices.

DSA Rust

let arr = [5, 10, 15];
for ([1], val) in arr.iter().enumerate() {
    println!("Index: {}, Value: {}", [1], val);
}

Drag options to blanks, or click blank then click option'

Aindex

Bi

Cpos

Didx

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in the loop and println! macro.

Not using enumerate() to get indices.

The variable 'idx' is used to hold the index from enumerate and must be consistent in the println! macro.

4fill in blank

hard

Fill both blanks to create a vector of squares of even numbers from the array.

DSA Rust

let arr = [1, 2, 3, 4, 5, 6];
let evens_squared: Vec<i32> = arr.iter()
    .filter(|&&[1]| [1] % 2 == 0)
    .map(|&[2]| [2] * [2])
    .collect();

Drag options to blanks, or click blank then click option'

Anum

Bval

Cx

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in filter and map.

Forgetting to dereference elements properly.

The variable 'num' is used consistently in both filter and map closures to represent each element.

5fill in blank

hard

Fill all three blanks to create a hashmap counting occurrences of each number in the array.

DSA Rust

use std::collections::HashMap;

let arr = [1, 2, 2, 3, 3, 3];
let mut counts = HashMap::new();

for &[1] in arr.iter() {
    let counter = counts.entry([2]).or_insert([3]);
    *counter += 1;
}

Drag options to blanks, or click blank then click option'

Anum

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names for the element and hashmap key.

Initializing the count to 1 instead of 0.

The variable 'num' is used for the element in the loop and as the key in the hashmap. The initial count is set to 0 before incrementing.

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