Why Strings Are a Data Structure Not Just Text in DSA Rust - See It Work

Why Strings Are a Data Structure Not Just Text

📖 Scenario: Imagine you are building a simple text editor that needs to handle words and letters carefully. You want to understand why strings in programming are more than just plain text--they are a special way to store and manage letters and words.

🎯 Goal: You will create a string variable, check its length, access individual characters, and print the results. This will show how strings work as a data structure, not just plain text.

📋 What You'll Learn

Create a string variable with exact text

Create a variable to store the length of the string

Access the first character of the string safely

Print the string, its length, and the first character

💡 Why This Matters

🌍 Real World

Text editors, messaging apps, and any software that handles words and letters use strings as data structures to manage text efficiently.

💼 Career

Understanding strings as data structures is essential for software developers, especially when working with text processing, user input, and data storage.

1

Create a string variable

Create a variable called word and set it to the string "hello" using String::from.

DSA Rust

# Your code here

Hint

Use String::from("hello") to create a string variable called word.

2

Find the length of the string

Create a variable called length and set it to the length of word using word.len().

DSA Rust

let word = String::from("hello");
# Your code here

Hint

Use word.len() to get the number of bytes in the string.

3

Access the first character safely

Create a variable called first_char and set it to the first character of word using word.chars().next(). Use unwrap() to get the character.

DSA Rust

let word = String::from("hello");
let length = word.len();
# Your code here

Hint

Use word.chars().next() to get the first character as an Option, then unwrap() to get the character.

4

Print the string, its length, and the first character

Use println! to print word, length, and first_char in this exact format: "Word: hello, Length: 5, First character: h".

DSA Rust

let word = String::from("hello");
let length = word.len();
let first_char = word.chars().next().unwrap();
# Your code here

Hint

Use println!("Word: {}, Length: {}, First character: {}", word, length, first_char); to print the values.

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