Why Palindrome Detection in DSA C#?

The Big Idea

What if you could instantly tell if a word reads the same backward without flipping it manually?

The Scenario

Imagine you want to check if a word or sentence reads the same backward as forward, like "madam" or "racecar". Doing this by hand means flipping the word and comparing each letter one by one.

The Problem

Manually reversing and comparing letters is slow and easy to make mistakes, especially with long words or sentences. It's hard to keep track of positions and remember to ignore spaces or punctuation.

The Solution

Palindrome detection algorithms quickly and correctly check if a string reads the same backward and forward by comparing characters from both ends moving toward the center, saving time and avoiding errors.

Before vs After

✗ Before

string word = "madam";
string reversed = "";
for (int i = word.Length - 1; i >= 0; i--) {
    reversed += word[i];
}
bool isPalindrome = (word == reversed);

✓ After

string word = "madam";
int left = 0, right = word.Length - 1;
bool isPalindrome = true;
while (left < right) {
    if (word[left] != word[right]) {
        isPalindrome = false;
        break;
    }
    left++;
    right--;
}

What It Enables

This lets programs instantly recognize palindromes, enabling applications like spell checkers, DNA sequence analysis, and data validation.

Real Life Example

Checking if a username or password is a palindrome to enforce security rules or creating fun palindrome games and puzzles in apps.

Key Takeaways

Manual checking is slow and error-prone.

Palindrome detection algorithms compare characters from both ends efficiently.

This technique is useful in many real-world applications.

Practice

1. What is a palindrome in the context of strings?

easy

A. A string that contains only vowels

B. A string that reads the same forwards and backwards

C. A string with all unique characters

D. A string that is empty

Solution

1. Step 1: Understand palindrome definition

   A palindrome is a word or phrase that reads the same forwards and backwards, ignoring spaces and punctuation.

2. Step 2: Apply definition to options

   A string that reads the same forwards and backwards matches this definition exactly, while others describe different string properties.

3. Final Answer:

   A string that reads the same forwards and backwards -> Option B

4. Quick Check:

   Palindrome = Same forwards and backwards [OK]

Hint: Check if string reversed equals original [OK]

Common Mistakes:

• Confusing palindrome with unique characters
• Thinking palindrome means only vowels
• Assuming empty string is always palindrome

2. Which of the following C# code snippets correctly checks if a string s is a palindrome?

easy

A. return s.Length == 0;

B. return s == s.ToUpper();

C. return s == new string(s.Reverse().ToArray());

D. return s[0] == s[s.Length];

Solution

1. Step 1: Understand palindrome check logic

   To check palindrome, compare string with its reversed version.

2. Step 2: Analyze each option

   return s == new string(s.Reverse().ToArray()); reverses string and compares correctly. return s == s.ToUpper(); compares uppercase, not palindrome. return s.Length == 0; checks empty string only. return s[0] == s[s.Length]; accesses invalid index (out of range).

3. Final Answer:

   return s == new string(s.Reverse().ToArray()); -> Option C

4. Quick Check:

   Reverse and compare = return s == new string(s.Reverse().ToArray()); [OK]

Hint: Reverse string and compare to original [OK]

Common Mistakes:

• Using wrong index causing out of range error
• Comparing uppercase instead of reversed string
• Checking only empty string

3. What will be the output of the following C# code?

string s = "level";
bool isPalindrome = s == new string(s.Reverse().ToArray());
Console.WriteLine(isPalindrome);

medium

A. True

B. False

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Reverse the string "level"

   Reversed string is "level", same as original.

2. Step 2: Compare original and reversed strings

   Since both are equal, isPalindrome is true, so Console.WriteLine prints True.

3. Final Answer:

   True -> Option A

4. Quick Check:

   "level" reversed = "level" [OK]

Hint: Check if reversed string equals original [OK]

Common Mistakes:

• Assuming output is False for palindromes
• Confusing compilation error due to Reverse()
• Thinking runtime exception occurs

4. Identify the error in this palindrome check code and select the fix:

string s = "test";
bool isPalindrome = true;
for (int i = 0; i <= s.Length / 2; i++)
{
    if (s[i] != s[s.Length - i])
    {
        isPalindrome = false;
        break;
    }
}
Console.WriteLine(isPalindrome);

medium

A. Remove the break statement

B. Change loop condition to i < s.Length

C. Initialize isPalindrome to false

D. Change s.Length - i to s.Length - i - 1

Solution

1. Step 1: Identify index error in character comparison

   String indices go from 0 to s.Length - 1, so s[s.Length - i] is out of range when i=0.

2. Step 2: Fix index to s.Length - i - 1

   This correctly accesses the mirrored character from the end.

3. Final Answer:

   Change s.Length - i to s.Length - i - 1 -> Option D

4. Quick Check:

   Correct index fixes out of range error [OK]

Hint: Remember last index is length minus one [OK]

Common Mistakes:

• Using s.Length - i instead of s.Length - i - 1
• Looping beyond half the string length
• Removing break causing unnecessary checks

5. You want to detect if a string is a palindrome ignoring case and spaces. Which code snippet correctly implements this in C#?

hard

A. string clean = new string(s.Where(char.IsLetterOrDigit).ToArray()).ToLower();
bool isPal = clean == new string(clean.Reverse().ToArray());

B. string clean = s.Replace(" ", "");
bool isPal = clean == clean.ToUpper();

C. bool isPal = s == new string(s.Reverse().ToArray());

D. bool isPal = s.ToLower() == s.ToUpper();

Solution

1. Step 1: Clean string by removing non-letter/digit and convert to lowercase

   string clean = new string(s.Where(char.IsLetterOrDigit).ToArray()).ToLower(); bool isPal = clean == new string(clean.Reverse().ToArray()); uses Where with char.IsLetterOrDigit and ToLower to normalize string.

2. Step 2: Reverse cleaned string and compare

   string clean = new string(s.Where(char.IsLetterOrDigit).ToArray()).ToLower(); bool isPal = clean == new string(clean.Reverse().ToArray()); reverses cleaned string and compares correctly for palindrome ignoring case and spaces.

3. Final Answer:

   string clean = new string(s.Where(char.IsLetterOrDigit).ToArray()).ToLower(); bool isPal = clean == new string(clean.Reverse().ToArray()); -> Option A

4. Quick Check:

   Normalize then reverse and compare = string clean = new string(s.Where(char.IsLetterOrDigit).ToArray()).ToLower(); bool isPal = clean == new string(clean.Reverse().ToArray()); [OK]

Hint: Remove spaces and lowercase before checking palindrome [OK]

Common Mistakes:

• Not removing spaces or punctuation
• Comparing original string without normalization
• Using uppercase comparison incorrectly