Palindrome Detection in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of palindrome check with mixed case and spaces

What is the output of this Rust code that checks if a string is a palindrome ignoring case and spaces?

DSA Rust

fn is_palindrome(s: &str) -> bool {
    let filtered: String = s.chars()
        .filter(|c| c.is_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();
    filtered == filtered.chars().rev().collect::<String>()
}

fn main() {
    let test_str = "A man a plan a canal Panama";
    println!("{}", is_palindrome(test_str));
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Think about how the function ignores spaces and case before checking.

The function removes non-alphanumeric characters and converts all letters to lowercase, so the phrase "A man a plan a canal Panama" is recognized as a palindrome.

❓ Predict Output

intermediate

Result of palindrome check on numeric string

What does this Rust code print when checking if the string "12321" is a palindrome?

DSA Rust

fn is_palindrome(s: &str) -> bool {
    s.chars().eq(s.chars().rev())
}

fn main() {
    let num_str = "12321";
    println!("{}", is_palindrome(num_str));
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Check if the string reads the same forwards and backwards.

The string "12321" is the same forwards and backwards, so the function returns true.

❓ Predict Output

advanced

Output of palindrome check with Unicode characters

What is the output of this Rust code checking if the string "あいいあ" is a palindrome?

DSA Rust

fn is_palindrome(s: &str) -> bool {
    s.chars().eq(s.chars().rev())
}

fn main() {
    let unicode_str = "あいいあ";
    println!("{}", is_palindrome(unicode_str));
}

A Runtime panic

B false

C Compilation error

D true

💡 Hint

Unicode characters can be compared like normal characters in Rust.

The string "あいいあ" reads the same forwards and backwards, so the function returns true.

❓ Predict Output

advanced

Output of palindrome check ignoring punctuation

What does this Rust code print when checking if "Madam, I'm Adam." is a palindrome ignoring punctuation and case?

DSA Rust

fn is_palindrome(s: &str) -> bool {
    let filtered: String = s.chars()
        .filter(|c| c.is_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();
    filtered == filtered.chars().rev().collect::<String>()
}

fn main() {
    let phrase = "Madam, I'm Adam.";
    println!("{}", is_palindrome(phrase));
}

A false

B true

C Compilation error

D Runtime panic

💡 Hint

Punctuation is removed before checking palindrome.

After removing punctuation and lowering case, the phrase reads the same forwards and backwards.

🧠 Conceptual

expert

Why is using chars().eq(chars().rev()) better than reversing string bytes for palindrome check?

Which reason best explains why checking palindrome with s.chars().eq(s.chars().rev()) is better than reversing the string bytes directly in Rust?

A Because bytes() automatically ignores spaces and punctuation.

B Because reversing bytes is faster and always correct for palindrome detection.

C Because chars() correctly handles Unicode characters which may be multiple bytes, ensuring accurate palindrome detection.

D Because chars() converts all characters to lowercase automatically.

💡 Hint

Think about how Unicode characters are stored in memory.

Unicode characters can be multiple bytes, so reversing bytes can break characters. Using chars() ensures each character is handled properly.

Practice

1. What does a palindrome string mean in simple terms?

easy

A. It has all unique characters

B. It contains only vowels

C. It is always an even length string

D. It reads the same forwards and backwards

Solution

1. Step 1: Understand palindrome definition

   A palindrome is a word or phrase that reads the same from left to right and right to left.

2. Step 2: Check options against definition

   Only It reads the same forwards and backwards matches this meaning exactly.

3. Final Answer:

   It reads the same forwards and backwards -> Option D

4. Quick Check:

   Palindrome = Same forwards and backwards [OK]

Hint: Palindrome means mirror reading same both ways [OK]

Common Mistakes:

• Confusing palindrome with unique characters
• Thinking palindrome must be even length
• Assuming palindrome only has vowels

2. Which Rust code snippet correctly checks if a string s is a palindrome?

easy

A. s.reverse() == s

B. s.chars().eq(s.chars().rev())

C. s == s.reverse()

D. s.chars().all(|c| c == s.chars().next().unwrap())

Solution

1. Step 1: Understand Rust string palindrome check

   To check palindrome, compare characters iterator with its reverse iterator.

2. Step 2: Analyze options

   s.chars().eq(s.chars().rev()) uses chars().eq(chars().rev()) which correctly compares forward and backward characters. Options A and C use invalid methods or wrong comparisons. s.chars().all(|c| c == s.chars().next().unwrap()) checks if all characters are same, not palindrome.

3. Final Answer:

   s.chars().eq(s.chars().rev()) -> Option B

4. Quick Check:

   Compare chars iterator with reversed iterator [OK]

Hint: Use chars().eq(chars().rev()) to check palindrome [OK]

Common Mistakes:

• Using reverse() method on &str which does not exist
• Comparing string with reversed string incorrectly
• Checking all chars equal instead of palindrome

3. What is the output of this Rust code?

let s = "racecar";
let result = s.chars().eq(s.chars().rev());
println!("{}", result);

medium

A. true

B. Runtime panic

C. Compilation error

D. false

Solution

1. Step 1: Analyze the string and palindrome check

   The string "racecar" reads the same forwards and backwards, so it is a palindrome.

2. Step 2: Understand the code output

   The code compares characters forward and backward and returns true for palindrome strings. So, it prints true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   "racecar" palindrome check = true [OK]

Hint: Check if string equals its reverse chars [OK]

Common Mistakes:

• Assuming palindrome check returns false for odd length
• Thinking code causes compile or runtime error
• Confusing output with string itself

4. Identify the error in this Rust palindrome check code:

fn is_palindrome(s: &str) -> bool {
    s == s.chars().rev().collect::<String>()
}

medium

A. Cannot compare &str with String directly

B. Missing semicolon after collect

C. chars().rev() does not exist

D. Function return type should be String

Solution

1. Step 1: Understand types in comparison

   The left side is &str, right side is String from collect(). Direct comparison between &str and String is not allowed.

2. Step 2: Fix type mismatch

   Convert left side to String or right side to &str for comparison. For example, use s.to_string() == s.chars().rev().collect::<String>().

3. Final Answer:

   Cannot compare &str with String directly -> Option A

4. Quick Check:

   Type mismatch in comparison causes error [OK]

Hint: Compare same types: &str vs &str or String vs String [OK]

Common Mistakes:

• Ignoring type mismatch error
• Assuming collect needs semicolon inside expression
• Thinking chars().rev() is invalid method

5. You want to detect palindromes ignoring case and spaces in Rust. Which code snippet correctly implements this?

hard

A. let is_pal = s.chars().all(|c| c.is_alphanumeric());

B. let lower = s.to_lowercase();
let is_pal = lower == lower.reverse();

C. let filtered: String = s.chars().filter(|c| !c.is_whitespace()).collect();
let lower = filtered.to_lowercase();
let is_pal = lower.chars().eq(lower.chars().rev());

D. let filtered: String = s.chars().filter(|c| c.is_whitespace()).collect();
let is_pal = filtered == filtered.chars().rev().collect::<String>();

Solution

1. Step 1: Remove spaces and convert to lowercase

   let filtered: String = s.chars().filter(|c| !c.is_whitespace()).collect(); let lower = filtered.to_lowercase(); let is_pal = lower.chars().eq(lower.chars().rev()); filters out whitespace, collects characters, then converts to lowercase string.

2. Step 2: Check palindrome on cleaned string

   It compares characters forward and backward correctly on the cleaned lowercase string.

3. Final Answer:

   let filtered: String = s.chars().filter(|c| !c.is_whitespace()).collect(); let lower = filtered.to_lowercase(); let is_pal = lower.chars().eq(lower.chars().rev()); -> Option C

4. Quick Check:

   Filter spaces + lowercase + compare reversed chars [OK]

Hint: Clean string first: remove spaces, lowercase, then check palindrome [OK]

Common Mistakes:

• Using reverse() method which does not exist
• Filtering only whitespace but not converting case
• Checking all chars alphanumeric instead of palindrome