Why Strings Are a Data Structure Not Just Text in DSA Rust - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new empty String in Rust.

DSA Rust

let mut s = String::[1]();

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

Anew

Bfrom

Cpush

Dlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'from' instead of 'new' creates a String from a value, not empty.

Using 'push' is for adding characters, not creating a String.

The String::new() function creates a new empty String in Rust.

2fill in blank

medium

Complete the code to add the text "hello" to the String variable s.

DSA Rust

s.[1]("hello");

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

Apop

Bpush_str

Cclear

Dlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' removes the last character instead of adding.

Using 'len' returns length, not modifies the String.

The push_str method appends a string slice to a String.

3fill in blank

hard

Fix the error in the code to convert a &str to a String.

DSA Rust

let s = "hello".[1]();

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

Alen

Bpush_str

Cto_string

Dclear

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'push_str' on a &str causes error because it's a method for String.

Using 'len' returns length, not converts.

The to_string() method converts a string slice (&str) to a String.

4fill in blank

hard

Fill both blanks to create a String from a &str and then get its length.

DSA Rust

let s = String::[1]("hello");
let length = s.[2]();

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

Afrom

Blen

Cnew

Dpush_str

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'new' instead of 'from' does not create from &str.

Using 'push_str' instead of 'len' does not get length.

String::from("hello") creates a String from a string slice.
len() returns the length of the String.

5fill in blank

hard

Fill all three blanks to create a String, append text, and print it.

DSA Rust

let mut s = String::[1]();
s.[2](" world");
println!("{}", s[3]);

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

Anew

Bpush_str

C.as_str()

D.len()

Attempts:

3 left

💡 Hint

Common Mistakes

Using '.len()' in print shows length, not content.

Forgetting to make String mutable before push_str.

String::new() creates an empty String.
push_str(" world") appends text.
.as_str() converts String to &str for printing.

Practice

1. Why are strings considered a data structure and not just plain text in Rust?

easy

A. Because strings cannot be changed once created

B. Because strings are only used for printing text

C. Because strings store characters in a sequence with indexing and length properties

D. Because strings are always fixed size arrays

Solution

1. Step 1: Understand what a data structure is

   A data structure organizes data to allow operations like indexing, length checking, and iteration.

2. Step 2: Analyze string properties in Rust

   Rust strings store characters in order, support length queries, and allow access to parts, so they behave like a data structure.

3. Final Answer:

   Because strings store characters in a sequence with indexing and length properties -> Option C

4. Quick Check:

   Strings = Data structure [OK]

Hint: Strings hold ordered characters with length and indexing [OK]

Common Mistakes:

• Thinking strings are just plain text without structure
• Assuming strings are immutable fixed arrays
• Confusing strings with single characters

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

easy

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

B. let s = 'hello';

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

D. let s = String::from("hello");

Solution

1. Step 1: Identify mutable string creation syntax

   In Rust, to create a mutable String, you declare it with mut and initialize with String::new() or String::from().

2. Step 2: Verify the correct syntax

   The correct way is let mut s = String::new();, which creates an empty mutable String. Without mut the String is immutable. Single quotes denote characters, not strings, and String::from() requires a string slice like "hello".

3. Final Answer:

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

4. Quick Check:

   Mutable String = let mut s = String::new(); [OK]

Hint: Use 'mut' keyword to make String mutable [OK]

Common Mistakes:

• Forgetting 'mut' keyword for mutability
• Using single quotes for strings instead of double quotes
• Confusing &str with String type

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

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

medium

A. "hello"

B. "hello, world!"

C. Compilation error

D. "hello world"

Solution

1. Step 1: Understand push_str method

   The push_str method appends a string slice to the existing String.

2. Step 2: Trace the code execution

   Initially, s = "hello". After s.push_str(", world!"), s becomes "hello, world!". The print statement outputs this full string.

3. Final Answer:

   "hello, world!" -> Option B

4. Quick Check:

   push_str appends text = "hello, world!" [OK]

Hint: push_str adds text to String, so output includes appended text [OK]

Common Mistakes:

• Expecting original string without appended text
• Confusing push_str with push (which adds single char)
• Thinking code causes compile error

4. Identify the error in this Rust code snippet:

let s = String::from("hello");
s.push('!');

medium

A. Cannot push a character to an immutable String

B. push method does not exist for String

C. Missing semicolon after push

D. String::from cannot create a String

Solution

1. Step 1: Check mutability of String

   The variable s is declared without mut, so it is immutable.

2. Step 2: Understand push method requirements

   The push method modifies the String by adding a character, which requires the String to be mutable.

3. Final Answer:

   Cannot push a character to an immutable String -> Option A

4. Quick Check:

   push needs mutable String = error if not mutable [OK]

Hint: Make String mutable with 'mut' before push [OK]

Common Mistakes:

• Ignoring mut keyword requirement
• Thinking push is invalid method
• Assuming missing semicolon causes error

5. Given a String in Rust, how can you efficiently count the number of characters (not bytes) it contains?

hard

A. Use s.capacity() to find character count

B. Use s.len() to get the character count

C. Use s.bytes().count() to count characters

D. Convert to chars iterator and count elements with s.chars().count()

Solution

1. Step 1: Understand difference between bytes and characters

   Rust strings store UTF-8 bytes; len() returns byte count, not character count.

2. Step 2: Use chars iterator to count characters

   The chars() method returns an iterator over Unicode scalar values (characters). Counting these gives the correct character count.

3. Final Answer:

   Convert to chars iterator and count elements with s.chars().count() -> Option D

4. Quick Check:

   chars().count() = character count [OK]

Hint: Use s.chars().count() for accurate character count [OK]

Common Mistakes:

• Using s.len() which counts bytes, not characters
• Using bytes().count() which counts bytes
• Confusing capacity() with length