Palindrome Detection in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a palindrome?

A palindrome is a word, phrase, number, or sequence that reads the same backward as forward, ignoring spaces, punctuation, and capitalization.

beginner

How can you check if a string is a palindrome using two pointers?

Use two pointers: one at the start and one at the end of the string. Move both pointers towards the center, comparing characters. If all pairs match, the string is a palindrome.

intermediate

Why do we ignore case and non-alphanumeric characters when detecting palindromes?

Ignoring case and non-alphanumeric characters ensures that the palindrome check focuses on meaningful characters only, making it more flexible and accurate for phrases and sentences.

intermediate

What is the time complexity of checking a palindrome using the two-pointer technique?

The time complexity is O(n), where n is the length of the string, because each character is checked at most once.

beginner

Show a simple C# code snippet to check if a string is a palindrome.

public bool IsPalindrome(string s) { int left = 0, right = s.Length - 1; while (left < right) { if (char.ToLower(s[left]) != char.ToLower(s[right])) return false; left++; right--; } return true; }

What does a palindrome string read the same as?

A It reads the same only forward

B It reads the same only backward

C It reads the same backward and forward

D It reads differently backward and forward

A palindrome reads the same backward and forward.

Which technique is commonly used to check palindrome efficiently?

A Using a stack only

B Sorting the string

C Reversing the string and comparing

D Two pointers moving towards the center

Two pointers moving towards the center compare characters efficiently.

Why should we ignore case when checking palindromes?

A Because case changes the length of the string

B Because uppercase and lowercase letters are considered the same

C Because case affects the order of characters

D Because case is always ignored in programming

Uppercase and lowercase letters represent the same letter for palindrome checks.

What is the time complexity of palindrome detection using two pointers?

A O(n)

B O(n^2)

C O(log n)

D O(1)

Each character is checked once, so time complexity is O(n).

Which characters are usually ignored in palindrome detection?

A Spaces and punctuation

B Only digits

C Only letters

D All characters are considered

Spaces and punctuation are ignored to focus on meaningful characters.

Explain how to check if a string is a palindrome using the two-pointer method.

Think about comparing characters from both ends moving inward.

Describe why normalization (ignoring case and non-alphanumeric characters) is important in palindrome detection.

Consider how phrases with spaces and punctuation can still be palindromes.

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