String Basics and Memory Representation in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code snippet?

Consider the following Rust code that manipulates a String. What will be printed?

DSA Rust

fn main() {
    let mut s = String::from("hello");
    s.push_str(", world");
    println!("{}", s);
}

A "hello, world"

B "hello world"

C "hello"

D "hello,world"

💡 Hint

Look carefully at the push_str argument and how it adds to the original string.

The push_str method appends the exact string ", world" to the original string "hello", resulting in "hello, world".

🧠 Conceptual

intermediate

How is a Rust String stored in memory?

Which of the following best describes the memory representation of a Rust String?

A A pointer to a heap-allocated buffer, length, and capacity stored on the stack

B A fixed-size array of characters stored entirely on the stack

C A linked list of characters stored on the heap

D A null-terminated array of bytes stored on the heap

💡 Hint

Think about how Rust manages growable strings efficiently.

Rust's String type stores a pointer to a heap buffer, along with length and capacity fields on the stack, allowing dynamic resizing.

🔧 Debug

advanced

What error does this Rust code produce?

Analyze the following Rust code. What error will it cause when compiled?

DSA Rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}", s1);
}

A Runtime error: null pointer dereference

B No error; prints 'hello'

C Compile-time error: cannot borrow immutable variable 's1' as mutable

D Compile-time error: use of moved value 's1'

💡 Hint

Remember Rust's ownership rules and what happens when you assign one String to another.

Assigning s1 to s2 moves ownership, so s1 is no longer valid. Using s1 after move causes a compile-time error.

❓ Predict Output

advanced

What is the output of this Rust code involving slicing?

What will this Rust program print?

DSA Rust

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

A Runtime panic due to invalid slice

B "hello"

C "hello world"

D "world"

💡 Hint

Look at the slice range and what part of the string it extracts.

The slice &s[0..5] extracts characters from index 0 up to but not including 5, which is "hello".

🧠 Conceptual

expert

Why does Rust String slicing require valid UTF-8 boundaries?

Why must Rust string slices (&str) always be on valid UTF-8 character boundaries?

A To ensure slices are always null-terminated strings

B Because Rust strings are stored as ASCII only, so slicing must align with bytes

C To prevent slicing in the middle of a multi-byte UTF-8 character, which would cause invalid data

D Because Rust strings use UTF-16 encoding internally, requiring 2-byte alignment

💡 Hint

Think about how UTF-8 encodes characters with varying byte lengths.

UTF-8 characters can be multiple bytes. Slicing must not split a character byte sequence, or it would create invalid UTF-8 data.

Practice

1. What does the String type in Rust represent?

easy

A. A growable, heap-allocated string

B. A fixed-size array of characters

C. A pointer to a string literal

D. An immutable string slice

Solution

1. Step 1: Understand Rust string types

   Rust has two main string types: String and string slices (&str). String is growable and stored on the heap.

2. Step 2: Compare options with definitions

   A growable, heap-allocated string correctly describes String as growable and heap-allocated. Others describe slices or fixed arrays.

3. Final Answer:

   A growable, heap-allocated string -> Option A

4. Quick Check:

   String = growable heap string [OK]

Hint: Remember: String is growable and heap-allocated [OK]

Common Mistakes:

• Confusing String with &str (string slice)
• Thinking String is fixed size
• Assuming String is immutable

2. Which of the following is the correct way to create a new empty String in Rust?

easy

A. let s = String::new();

B. let s = String();

C. let s = new String();

D. let s = String[];

Solution

1. Step 1: Recall Rust String creation syntax

   In Rust, String::new() creates a new empty String.

2. Step 2: Check each option syntax

   let s = String::new(); uses correct Rust syntax. The other options use invalid Rust syntax for creating a String.

3. Final Answer:

   let s = String::new(); -> Option A

4. Quick Check:

   String::new() creates empty String [OK]

Hint: Use String::new() to create empty String [OK]

Common Mistakes:

• Using parentheses like a function call without ::new()
• Trying to use new keyword like other languages
• Using array brackets for String

3. What will be the output of this Rust code?

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

medium

A. Runtime error

B. hel

C. hello

D. he

Solution

1. Step 1: Understand string slicing in Rust

   The slice &s[0..2] takes characters from index 0 up to but not including 2.

2. Step 2: Extract substring from "hello"

   Characters at index 0 and 1 are 'h' and 'e', so the slice is "he".

3. Final Answer:

   he -> Option D

4. Quick Check:

   Slice 0..2 of "hello" = "he" [OK]

Hint: Slice 0..n means characters from 0 up to n-1 [OK]

Common Mistakes:

• Assuming slice includes index 2
• Expecting full string output
• Thinking slicing causes runtime error

4. Identify the error in this Rust code snippet:

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

medium

A. Slice range 0..4 is invalid

B. Cannot index String with single usize

C. Missing semicolon after println!

D. String::from is not valid

Solution

1. Step 1: Check indexing rules for String

   Rust does not allow indexing a String with a single usize like s[4] because strings are UTF-8 encoded and indexing by byte is unsafe.

2. Step 2: Verify other parts

   Slice &s[0..4] is valid. Semicolons and String::from usage are correct.

3. Final Answer:

   Cannot index String with single usize -> Option B

4. Quick Check:

   Single index on String causes error [OK]

Hint: Use slices, not single index, to access String parts [OK]

Common Mistakes:

• Trying to access String by single index
• Confusing slice range validity
• Ignoring Rust UTF-8 string rules

5. Given a UTF-8 encoded Rust String containing emoji and letters, which method safely returns the number of characters (not bytes)?

hard

A. s.len()

B. s.as_bytes().len()

C. s.chars().count()

D. s.bytes().count()

Solution

1. Step 1: Understand difference between bytes and characters

   UTF-8 strings store characters as 1 or more bytes. len() returns byte count, not character count.

2. Step 2: Identify method counting characters

   s.chars().count() iterates over Unicode scalar values (characters) and counts them correctly.

3. Final Answer:

   s.chars().count() -> Option C

4. Quick Check:

   chars().count() counts characters, not bytes [OK]

Hint: Use chars().count() for character count, not len() [OK]

Common Mistakes:

• Using len() which counts bytes, not characters
• Confusing bytes() with chars()
• Assuming as_bytes().len() counts characters