Iterating over collections in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to iterate over the vector and print each number.

Rust

let numbers = vec![1, 2, 3];
for num in numbers.[1]() {
    println!("{}", num);
}

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

Ainto_iter

Biter

Citer_mut

Ddrain

Attempts:

3 left

💡 Hint

Common Mistakes

Using iter() when ownership is needed.

Using iter_mut() when mutation is not required.

The into_iter() method consumes the vector and returns an iterator over its elements.

2fill in blank

medium

Complete the code to iterate over the vector by reference and print each number.

Rust

let numbers = vec![4, 5, 6];
for num in numbers.[1]() {
    println!("{}", num);
}

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

Aiter

Bdrain

Citer_mut

Dinto_iter

Attempts:

3 left

💡 Hint

Common Mistakes

Using into_iter() which consumes the vector.

Using iter_mut() when mutation is not needed.

The iter() method returns an iterator over references to the elements, so the vector is not consumed.

3fill in blank

hard

Fix the error in the code to iterate mutably over the vector and increment each number.

Rust

let mut numbers = vec![7, 8, 9];
for num in numbers.[1]() {
    *num += 1;
}
println!("{:?}", numbers);

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

Ainto_iter

Biter

Citer_mut

Ddrain

Attempts:

3 left

💡 Hint

Common Mistakes

Using iter() which gives immutable references.

Using into_iter() which consumes the vector.

The iter_mut() method returns mutable references, allowing modification of elements.

4fill in blank

hard

Fill both blanks to create a dictionary (HashMap) from a vector of words with their lengths, filtering words longer than 3 characters.

Rust

use std::collections::HashMap;
let words = vec!["rust", "is", "fun", "and", "fast"];
let lengths: HashMap<_, _> = words.into_iter()
    .filter(|word| word.[1]() > 3)
    .map(|word| (word, word.[2]()))
    .collect();

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

Alen

Bto_string

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using to_string() in filter which returns a String, not a number.

Using clone() instead of len().

Use len() to get the length of the word for filtering and mapping.

5fill in blank

hard

Fill all three blanks to create a HashMap from a vector of tuples, filtering pairs where the number is greater than 10.

Rust

use std::collections::HashMap;
let pairs = vec![("a", 5), ("b", 15), ("c", 20)];
let map: HashMap<_, _> = pairs.into_iter()
    .filter(|(_, num)| *num [1] 10)
    .map(|(key, value)| (key.[2]().[3](), value))
    .collect::<HashMap<_, _>>();

println!("{:?}", map);

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

A<

B>

Cto_string

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in filter.

Not cloning the key before calling to_string().

Filter numbers greater than 10 using >. Use clone() to copy the key, then to_string() to convert it to a String.

Practice

1. What does the following Rust code do?

let numbers = [1, 2, 3];
for num in numbers {
    println!("{}", num);
}

easy

A. Causes a compile error because arrays can't be iterated

B. Prints each number in the array on a new line

C. Prints the whole array as one line

D. Prints the length of the array

Solution

1. Step 1: Understand the for loop over an array

   The for loop visits each element in the array named 'numbers'.

2. Step 2: Action inside the loop

   Each element is printed on its own line using println! macro.

3. Final Answer:

   Prints each number in the array on a new line -> Option B

4. Quick Check:

   for loop over array prints elements one by one [OK]

Hint: For loops visit each item in order [OK]

Common Mistakes:

• Thinking arrays can't be iterated
• Expecting the whole array printed at once
• Confusing print! with println!

2. Which of these is the correct syntax to iterate over a vector named v in Rust?

easy

A. for i in v { println!("{}", i); }

B. for i to v { println!("{}", i); }

C. foreach i in v { println!("{}", i); }

D. loop i in v { println!("{}", i); }

Solution

1. Step 1: Recall Rust for loop syntax

   Rust uses 'for variable in collection' to iterate over items.

2. Step 2: Check each option

   for i in v { println!("{}", i); } matches correct syntax; others use invalid keywords.

3. Final Answer:

   for i in v { println!("{}", i); } -> Option A

4. Quick Check:

   Rust uses 'for ... in ...' loops [OK]

Hint: Remember: for variable in collection [OK]

Common Mistakes:

• Using 'to' instead of 'in'
• Using 'foreach' which is not Rust syntax
• Using 'loop' incorrectly

3. What is the output of this Rust code?

let v = vec![10, 20, 30];
let mut sum = 0;
for &num in &v {
    sum += num;
}
println!("{}", sum);

medium

A. 60

B. 303020

C. Error due to borrowing

D. 0

Solution

1. Step 1: Understand iteration with references

   The loop uses '&num in &v' to borrow each element by reference and dereference it with '&num'.

2. Step 2: Calculate sum of elements

   sum starts at 0, then adds 10, 20, and 30, resulting in 60.

3. Final Answer:

   60 -> Option A

4. Quick Check:

   Sum of 10+20+30 = 60 [OK]

Hint: Sum elements by iterating with references [OK]

Common Mistakes:

• Confusing references and values
• Expecting concatenation instead of sum
• Thinking borrowing causes error here

4. Identify the error in this Rust code snippet:

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

medium

A. Loop variable 'num' must be a reference

B. Syntax error: missing semicolon after println!

C. Array cannot be iterated directly

D. Cannot modify 'num' because it is an immutable copy

Solution

1. Step 1: Check mutability of loop variable

   In Rust, loop variables are immutable by default; 'num' is a copy of array element.

2. Step 2: Understand why 'num += 1' fails

   Trying to change 'num' causes error because it is not declared mutable.

3. Final Answer:

   Cannot modify 'num' because it is an immutable copy -> Option D

4. Quick Check:

   Loop variables are immutable unless declared mutable [OK]

Hint: Loop vars are immutable unless 'mut' used [OK]

Common Mistakes:

• Thinking semicolon missing causes error
• Believing arrays can't be iterated
• Assuming loop vars are references by default

5. You have a vector of strings: let words = vec!["apple", "banana", "cherry"];. How do you create a new vector containing the lengths of each word using iteration?

hard

A. let lengths = words.map(|w| w.len());

B. let lengths = for w in words { w.len() };

C. let lengths: Vec<usize> = words.iter().map(|w| w.len()).collect();

D. let lengths = words.iter().for_each(|w| w.len());

Solution

1. Step 1: Use iterator and map to transform elements

   words.iter() creates an iterator over references to strings; map applies a function to each element.

2. Step 2: Collect results into a new vector

   collect() gathers the mapped lengths into a Vec<usize>.

3. Final Answer:

   let lengths: Vec<usize> = words.iter().map(|w| w.len()).collect(); -> Option C

4. Quick Check:

   Use iter().map(...).collect() to transform collections [OK]

Hint: Use iter().map(...).collect() to build new collections [OK]

Common Mistakes:

• Trying to use for loop as expression
• Using map directly on vector without iter()
• Using for_each which returns () not a collection