String slices in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with string slices?

Consider the following Rust code. What will it print?

Rust

fn main() {
    let s = String::from("hello world");
    let slice = &s[0..5];
    println!("{}", slice);
}

A hello world

B world

C hello

D Syntax error

💡 Hint

Remember that &s[0..5] takes a slice from index 0 up to but not including 5.

The slice &s[0..5] extracts the first 5 characters from the string "hello world", which is "hello".

❓ Predict Output

intermediate

What happens if you slice a string with invalid UTF-8 boundaries?

What error or output will this Rust code produce?

Rust

fn main() {
    let s = String::from("Здравствуйте");
    let slice = &s[0..3];
    println!("{}", slice);
}

A Prints "Зд"

B Panics at runtime with a slice error

C Prints "Здр"

D Compiles but prints garbage characters

💡 Hint

Rust string slices must be on valid UTF-8 character boundaries.

The slice &s[0..3] cuts in the middle of a multi-byte UTF-8 character, causing a runtime panic.

🔧 Debug

advanced

Why does this Rust code panic at runtime?

Identify the reason for the runtime error in this code snippet.

Rust

fn main() {
    let s = String::from("hello");
    let slice = &s[0..10];
    println!("{}", slice);
}

A The slice range 0..10 is out of bounds for the string length

B The variable s is immutable and cannot be sliced

C Missing semicolon after println! macro

D You cannot slice a String, only &str

💡 Hint

Check the length of the string and the slice range.

The string "hello" has length 5, so slicing from 0 to 10 is out of bounds and causes a panic at runtime.

❓ Predict Output

advanced

What is the output of this Rust code using string slices and pattern matching?

What will this Rust program print?

Rust

fn main() {
    let s = "rustacean";
    match &s[0..4] {
        "rust" => println!("Found rust!"),
        _ => println!("Not rust"),
    }
}

A Runtime panic due to invalid slice

B Not rust

C Compile error due to slice

D Found rust!

💡 Hint

The slice &s[0..4] extracts the first 4 characters.

The slice &s[0..4] is "rust", so the match arm prints "Found rust!".

🧠 Conceptual

expert

How many characters are in this Rust string slice?

Given the Rust code below, how many characters does the slice contain?

Rust

fn main() {
    let s = String::from("caé");
    let slice = &s[0..4];
    println!("{}", slice);
}

A 3 characters

B 4 characters

C 2 characters

D 1 character

💡 Hint

Remember that some characters use multiple bytes in UTF-8.

The slice &s[0..4] contains the bytes for 'c', 'a', and 'é' where 'é' is two bytes, so the slice covers 3 characters.

Practice

1. What is a string slice in Rust?

easy

A. A type of integer used for indexing strings

B. A reference to a part of a string without copying it

C. A function that modifies a string in place

D. A new string created by copying characters

Solution

1. Step 1: Understand string slice concept

   A string slice is a reference to a part of a string, not a new string.

2. Step 2: Compare options

   Only A reference to a part of a string without copying it describes a reference without copying, which matches string slices.

3. Final Answer:

   A reference to a part of a string without copying it -> Option B

4. Quick Check:

   String slice = reference without copy [OK]

Hint: Remember: slices borrow, not copy strings [OK]

Common Mistakes:

• Thinking slices create new strings
• Confusing slices with string modification
• Believing slices are integer types

2. Which of the following is the correct syntax to get a slice of the first 4 characters from a string text?

easy

A. &text[0..4]

B. text.slice(0, 4)

C. &text[1..5]

D. text[0:4]

Solution

1. Step 1: Recall Rust slice syntax

   Rust uses &string[start..end] to get a slice from start to end-1.

2. Step 2: Check options

   &text[0..4] uses &text[0..4], which correctly slices first 4 chars (indices 0 to 3).

3. Final Answer:

   &text[0..4] -> Option A

4. Quick Check:

   Slice syntax = &string[start..end] [OK]

Hint: Use &string[start..end] for slices, not methods or colons [OK]

Common Mistakes:

• Using method calls like slice() which don't exist
• Using 1-based indexing instead of 0-based
• Using Python-style slicing with colons

3. What will the following Rust code print?

let s = String::from("hello world");
let slice = &s[6..11];
println!("{}", slice);

medium

A. hello

B. Syntax error

C. hello world

D. world

Solution

1. Step 1: Understand slicing indices

   The slice &s[6..11] takes characters from index 6 up to 10 (11 excluded).

2. Step 2: Identify substring

   In "hello world", index 6 is 'w' and index 10 is 'd', so slice is "world".

3. Final Answer:

   world -> Option D

4. Quick Check:

   Slice &s[6..11] = "world" [OK]

Hint: Remember slice end index is excluded [OK]

Common Mistakes:

• Including the end index character
• Confusing start and end indices
• Expecting full string output

4. Identify the error in this Rust code snippet:

let s = String::from("rustacean");
let slice = &s[0..5];
println!("{}", slice);
let invalid_slice = &s[5..15];

medium

A. The slice &s[5..15] causes a runtime panic due to out-of-bounds

B. The slice &s[0..5] is invalid syntax

C. The println! macro is missing a semicolon

D. String::from cannot create strings with length 9

Solution

1. Step 1: Check slice ranges

   The string "rustacean" has length 9, so valid indices are 0 to 8.

2. Step 2: Analyze invalid slice

   The slice &s[5..15] tries to access indices beyond length, causing runtime panic.

3. Final Answer:

   The slice &s[5..15] causes a runtime panic due to out-of-bounds -> Option A

4. Quick Check:

   Out-of-bounds slice = panic [OK]

Hint: Slice end must be ≤ string length to avoid panic [OK]

Common Mistakes:

• Assuming slices auto-adjust to string length
• Thinking &s[0..5] is invalid syntax
• Ignoring runtime panics from invalid slices

5. Given a string text, how can you safely get a slice of the first n characters without risking a runtime panic if n is larger than the string length?

hard

A. Use text.get(0..n).unwrap()

B. Use &text[0..n] without checks

C. Use &text[0..n.min(text.len())]

D. Use &text[0..=n]

Solution

1. Step 1: Understand safe slicing

   To avoid panic, slice end must not exceed string length.

2. Step 2: Use min to limit slice end

   Using n.min(text.len()) ensures slice end is at most string length.

3. Final Answer:

   Use &text[0..n.min(text.len())] -> Option C

4. Quick Check:

   Safe slice end = min(n, length) [OK]

Hint: Use min() to limit slice end safely [OK]

Common Mistakes:

• Slicing without length check causing panic
• Using unwrap() which can panic if None
• Using inclusive range which is invalid for slices