Palindrome Detection in DSA C# - Build from Scratch

Palindrome Detection

📖 Scenario: Imagine you are building a simple program to check if a word or phrase reads the same forwards and backwards. This is called a palindrome. For example, "level" and "madam" are palindromes.

🎯 Goal: You will create a program that checks if a given string is a palindrome. You will start by storing the string, then prepare it for checking, write the logic to detect palindrome, and finally print the result.

📋 What You'll Learn

Create a string variable with a specific phrase

Create a cleaned version of the string with only lowercase letters

Write logic to check if the cleaned string is a palindrome

Print the result as true or false

💡 Why This Matters

🌍 Real World

Palindrome detection is useful in text processing, data validation, and fun word games.

💼 Career

Understanding string manipulation and loops is fundamental for software development and coding interviews.

1

Store the original string

Create a string variable called original and set it to the exact value "A man a plan a canal Panama".

DSA C#

# Create the string variable 'original' with the given phrase
// Your code here

Hint

Use string original = "A man a plan a canal Panama"; to store the phrase.

2

Prepare the string for palindrome check

Create a string variable called cleaned that contains only the lowercase letters from original. Remove spaces and convert all letters to lowercase.

DSA C#

string original = "A man a plan a canal Panama";
// Create 'cleaned' by removing spaces and converting to lowercase
// Your code here

Hint

Use original.ToLower() and Where(char.IsLetter) to keep only letters.

3

Check if the string is a palindrome

Create a boolean variable called isPalindrome. Set it to true if cleaned reads the same forwards and backwards, otherwise false. Use a for loop with i from 0 to cleaned.Length / 2 to compare characters.

DSA C#

string original = "A man a plan a canal Panama";
string cleaned = new string(original.ToLower().Where(char.IsLetter).ToArray());
// Create 'isPalindrome' and set it using a for loop to compare characters
// Your code here

Hint

Compare characters from start and end moving towards the center. If any pair differs, set isPalindrome to false and stop.

4

Print the palindrome check result

Print the value of isPalindrome using Console.WriteLine.

DSA C#

string original = "A man a plan a canal Panama";
string cleaned = new string(original.ToLower().Where(char.IsLetter).ToArray());
bool isPalindrome = true;
for (int i = 0; i < cleaned.Length / 2; i++)
{
    if (cleaned[i] != cleaned[cleaned.Length - 1 - i])
    {
        isPalindrome = false;
        break;
    }
}
// Print the value of 'isPalindrome'
// Your code here

Hint

Use Console.WriteLine(isPalindrome); to show the result.

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