String Traversal and Character Access in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of iterating over a UTF-8 string's chars

What is the output of this Rust code that prints each character of the string on a new line?

DSA Rust

fn main() {
    let s = "héllo";
    for c in s.chars() {
        println!("{}", c);
    }
}

A "h\né\nl\nl\no\n" (each char on separate line)

B "h\né\nl\nl\no"

C "h\né\nl\nl\no\n"

D "héllo"

💡 Hint

Remember that println! adds a newline after each character.

The chars() iterator yields each Unicode scalar value. println! prints each on its own line, so output shows each character followed by a newline.

❓ Predict Output

intermediate

Indexing a Rust string slice

What happens when you run this Rust code?

DSA Rust

fn main() {
    let s = "hello";
    let c = s[1];
    println!("{}", c);
}

A Compile-time error: cannot index string with integer

B Prints 'h'

C Prints 'e'

D Runtime panic

💡 Hint

Rust strings cannot be indexed by integer directly because of UTF-8 encoding.

Rust strings are UTF-8 encoded and do not support direct indexing by integer. This code causes a compile-time error.

🔧 Debug

advanced

Fix the code to print the third character of a string

This Rust code tries to print the third character of a string but fails. Which option fixes it correctly?

DSA Rust

fn main() {
    let s = "rustacean";
    let c = s[2];
    println!("{}", c);
}

A let c = s[2..3].chars().next().unwrap();

B let c = s.chars().nth(2).unwrap();

C let c = s.as_bytes()[2] as char;

D let c = s.get(2..3).unwrap().chars().next().unwrap();

💡 Hint

Use chars() iterator and nth() to get character by position.

Option B uses chars().nth(2) to get the third character safely. Option B is invalid because slicing string by byte indices may panic if not on char boundary. Option B casts a byte to char incorrectly. Option B returns a &str slice but get() returns Option<&str>, so unwrap() is needed but slicing must be on char boundary.

🧠 Conceptual

advanced

Why can't Rust strings be indexed by integer?

Why does Rust not allow direct indexing of String or &str by integer like s[0]?

A Because Rust strings are immutable and indexing would allow mutation.

B Because Rust strings are stored as linked lists internally, making indexing impossible.

C Because Rust strings are UTF-8 encoded and characters can be multiple bytes, so indexing by byte may not correspond to a valid character boundary.

D Because Rust strings are stored in reverse order for optimization.

💡 Hint

Think about how UTF-8 encoding affects character length.

Rust strings are UTF-8 encoded, so characters can be 1 to 4 bytes. Indexing by integer would be ambiguous and unsafe because it might split a character.

❓ Predict Output

expert

Output of slicing a UTF-8 string with multi-byte characters

What is the output of this Rust code?

DSA Rust

fn main() {
    let s = "café";
    let slice = &s[0..3];
    println!("{}", slice);
}

A caf

B ca�

C Compile-time error

D Runtime panic

💡 Hint

UTF-8 characters can be multiple bytes; slicing must be on valid character boundaries.

The character 'é' is two bytes in UTF-8. Slicing from 0 to 3 bytes cuts into the middle of 'é', causing a runtime panic due to invalid UTF-8 slice.

Practice

1. What does the following Rust code print?
let s = "hello";
for c in s.chars() {
print!("{}-", c);
}

easy

A. h-e-l-l-o-

B. hello

C. h e l l o

D. h,e,l,l,o,

Solution

1. Step 1: Understand the chars() method

   The chars() method returns an iterator over each character in the string s.

2. Step 2: Trace the for loop printing

   Each character is printed followed by a dash, so output is h-e-l-l-o-.

3. Final Answer:

   h-e-l-l-o- -> Option A

4. Quick Check:

   chars() + print with dash = h-e-l-l-o- [OK]

Hint: chars() iterates characters; print each with dash [OK]

Common Mistakes:

• Thinking chars() returns words
• Ignoring the dash printed after each char
• Confusing chars() with bytes()

2. Which of the following is the correct way to access the third character of a Rust string s safely?

easy

A. let c = s.bytes().nth(2).unwrap();

B. let c = s[2];

C. let c = s.get(2).unwrap();

D. let c = s.chars().nth(2).unwrap();

Solution

1. Step 1: Understand string indexing in Rust

   Rust strings cannot be indexed directly by integer due to UTF-8 encoding, so s[2] is invalid.

2. Step 2: Use chars().nth() to get character safely

   The chars() iterator allows accessing the nth character safely with nth(2) and unwrap() to get the value.

3. Final Answer:

   let c = s.chars().nth(2).unwrap(); -> Option D

4. Quick Check:

   chars().nth(2).unwrap() = correct char access [OK]

Hint: Use chars().nth(index).unwrap() for safe char access [OK]

Common Mistakes:

• Using direct indexing like s[2]
• Using get(2) which returns Option<&str> slice, not char
• Using bytes() which returns u8, not char

3. What is the output of this Rust code?

let s = "rust";
let mut result = String::new();
for c in s.chars() {
    if c == 'u' {
        result.push('U');
    } else {
        result.push(c);
    }
}
println!("{}", result);

medium

A. rust

B. rUSt

C. rUst

D. Rust

Solution

1. Step 1: Iterate over each character in "rust"

   The loop goes over 'r', 'u', 's', 't' one by one.

2. Step 2: Replace 'u' with 'U' and keep others same

   When character is 'u', push 'U' to result; else push original char.

3. Final Answer:

   rUst -> Option C

4. Quick Check:

   Only 'u' replaced by 'U' = rUst [OK]

Hint: Check character equality and push accordingly [OK]

Common Mistakes:

• Replacing wrong characters
• Not pushing characters correctly
• Confusing uppercase and lowercase

4. Identify the error in this Rust code snippet:

let s = "hello";
let c = s[1];
println!("{}", c);

medium

A. s is not declared mutable

B. Cannot index string with integer directly

C. Missing semicolon after println!

D. println! macro syntax error

Solution

1. Step 1: Check string indexing rules in Rust

   Rust strings are UTF-8 encoded and do not support direct indexing by integer like arrays.

2. Step 2: Identify the invalid line

   The line let c = s[1]; causes a compile-time error because of invalid indexing.

3. Final Answer:

   Cannot index string with integer directly -> Option B

4. Quick Check:

   Direct indexing on String = error [OK]

Hint: Rust strings can't be indexed by integer directly [OK]

Common Mistakes:

• Assuming s[1] works like array indexing
• Ignoring UTF-8 encoding complexity
• Thinking semicolon or macro syntax is the error

5. Given a string s, how can you create a new string containing only the vowels from s in Rust?
Choose the correct code snippet.

hard

A. let vowels: String = s.chars().filter(|c| "aeiou".contains(*c)).collect();

B. let vowels: String = s.bytes().filter(|b| b == b'a' || b == b'e').collect();

C. let vowels: String = s.get(0..5).unwrap().to_string();

D. let vowels: String = s.chars().map(|c| if "aeiou".contains(c) { c } else { ' ' }).collect();

Solution

1. Step 1: Use chars() to iterate characters

   We need to check each character, so chars() is appropriate.

2. Step 2: Filter vowels and collect into String

   Filter characters that are vowels using filter and collect them into a new String.

3. Final Answer:

   let vowels: String = s.chars().filter(|c| "aeiou".contains(*c)).collect(); -> Option A

4. Quick Check:

   chars() + filter vowels + collect() = correct [OK]

Hint: Filter chars with contains("aeiou") and collect to String [OK]

Common Mistakes:

• Using bytes() which returns u8, not char
• Using get() which slices string, not filters vowels
• Replacing non-vowels with spaces instead of filtering