Valid Palindrome Two Pointer in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Pointer Palindrome Check

What is the output of the following C# code that checks if a string is a palindrome ignoring non-alphanumeric characters and case?

DSA C#

using System;

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

    public static void Main() {
        string input = "A man, a plan, a canal: Panama";
        Console.WriteLine(IsPalindrome(input));
    }
}

A True

B False

C Compilation error

D Runtime exception

💡 Hint

Focus on how non-alphanumeric characters are skipped and case is ignored.

The code uses two pointers moving inward, skipping non-alphanumeric characters and comparing lowercase characters. The input is a well-known palindrome phrase ignoring punctuation and case, so the output is True.

❓ Predict Output

intermediate

Result of Palindrome Check on Non-Palindrome String

What will the output be when running the palindrome check code on the string "race a car"?

DSA C#

using System;

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

    public static void Main() {
        string input = "race a car";
        Console.WriteLine(IsPalindrome(input));
    }
}

A False

B Compilation error

C True

D Runtime exception

💡 Hint

Check character comparisons carefully after skipping spaces.

The string "race a car" is not a palindrome when ignoring spaces and case because the characters at the ends do not match after skipping.

🧠 Conceptual

advanced

Why Two Pointers Work for Palindrome Checking

Why is the two-pointer technique effective for checking if a string is a palindrome?

A Because it converts the string into a number and checks if the number is a palindrome.

B Because it compares characters from both ends moving towards the center, ensuring symmetry.

C Because it sorts the string first to check for palindrome properties.

D Because it uses recursion to check each character individually.

💡 Hint

Think about how palindrome means the string reads the same forwards and backwards.

Two pointers start at the beginning and end of the string and move inward, comparing characters. This directly checks the palindrome property of symmetry.

🔧 Debug

advanced

Identify the Bug in Palindrome Code

What is the bug in this palindrome checking code snippet?

DSA C#

public static 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;
}

A It converts characters to lowercase incorrectly causing wrong comparisons.

B It uses <= instead of < causing an index out of range error.

C It does not skip non-alphanumeric characters, so it may return false incorrectly.

D It increments both pointers in the wrong order causing infinite loop.

💡 Hint

Check how the code handles spaces and punctuation.

The code compares characters directly without skipping non-alphanumeric characters, so strings with spaces or punctuation may fail even if they are palindromes ignoring those characters.

🚀 Application

expert

Count Palindromic Substrings Using Two Pointers

Given a string, which approach correctly counts all palindromic substrings using the two-pointer technique?

A Sort the string and count repeated characters as palindromes.

B Reverse the string and compare with original to count palindromes.

C Use a stack to push characters and pop when matching characters are found.

D Expand around each character and each pair of characters as centers, using two pointers to check palindrome substrings.

💡 Hint

Think about how palindromes can be centered at one or two characters.

Counting palindromic substrings involves expanding around each possible center (single character or pair) using two pointers moving outward to check palindrome validity.

Practice

1. What is the main idea behind the two-pointer technique to check if a string is a palindrome?

easy

A. Sort the characters and check if the sorted string equals the original

B. Reverse the string and compare it with the original string

C. Count the frequency of each character and check if all counts are even

D. Use two pointers starting from both ends and move towards the center comparing characters

Solution

1. Step 1: Understand the two-pointer approach

   Two pointers start at the beginning and end of the string and move inward.

2. Step 2: Compare characters at pointers

   If characters are equal, move pointers closer; if not, string is not palindrome.

3. Final Answer:

   Use two pointers starting from both ends and move towards the center comparing characters -> Option D

4. Quick Check:

   Two-pointer technique = Compare ends inward [OK]

Hint: Compare characters from both ends moving inward [OK]

Common Mistakes:

• Reversing string instead of using pointers
• Checking only half the string incorrectly
• Ignoring case or non-alphanumeric characters

2. Which of the following C# code snippets correctly initializes two pointers for palindrome checking on string s?

easy

A. int left = 0, right = s.Length - 1;

B. int left = 1, right = s.Length;

C. int left = 0, right = s.Length;

D. int left = 1, right = s.Length - 1;

Solution

1. Step 1: Identify valid pointer initialization

   Left pointer starts at 0 (first char), right pointer at s.Length - 1 (last char).

2. Step 2: Check each option

   int left = 0, right = s.Length - 1; correctly sets left=0 and right=s.Length-1; others are off by one.

3. Final Answer:

   int left = 0, right = s.Length - 1; -> Option A

4. Quick Check:

   Pointers start at 0 and last index [OK]

Hint: Start left at 0 and right at length minus one [OK]

Common Mistakes:

• Setting right pointer to s.Length (out of range)
• Starting left pointer at 1 instead of 0
• Confusing length with last index

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

string s = "A man, a plan, a canal: Panama";
bool IsPalindrome(string str) {
    int left = 0, right = str.Length - 1;
    while (left < right) {
        if (!char.IsLetterOrDigit(str[left])) { left++; continue; }
        if (!char.IsLetterOrDigit(str[right])) { right--; continue; }
        if (char.ToLower(str[left]) != char.ToLower(str[right])) return false;
        left++; right--;
    }
    return true;
}
Console.WriteLine(IsPalindrome(s));

medium

A. Runtime exception

B. True

C. Compilation error

D. False

Solution

1. Step 1: Understand the code logic

   The code skips non-alphanumeric characters and compares letters ignoring case.

2. Step 2: Analyze the input string

   "A man, a plan, a canal: Panama" is a famous palindrome ignoring spaces and punctuation.

3. Final Answer:

   True -> Option B

4. Quick Check:

   Ignoring punctuation and case, string is palindrome [OK]

Hint: Ignore non-letters and compare lowercase chars [OK]

Common Mistakes:

• Not skipping non-alphanumeric characters
• Comparing characters without case normalization
• Assuming spaces affect palindrome check

4. Identify the bug in the following palindrome check code and select the fix:

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

medium

A. Change while condition to left < right

B. Skip non-alphanumeric characters before comparing

C. All of the above

D. Add case-insensitive comparison using char.ToLower

Solution

1. Step 1: Check loop condition correctness

   Using <= causes unnecessary comparison when left == right; < is better.

2. Step 2: Consider case and character filtering

   Comparisons should ignore case and skip non-alphanumeric chars for valid palindrome check.

3. Step 3: Combine fixes

   All suggested fixes improve correctness and handle common palindrome cases.

4. Final Answer:

   All of the above -> Option C

5. Quick Check:

   Loop, case, and filtering fixes needed [OK]

Hint: Check loop, case, and skip non-letters [OK]

Common Mistakes:

• Using <= instead of < in loop
• Ignoring case differences
• Not skipping punctuation or spaces

5. Given the string "No lemon, no melon", which modification to the two-pointer palindrome check is necessary to correctly identify it as a palindrome?

hard

A. Convert characters to lowercase and skip non-alphanumeric characters during comparison

B. Only convert characters to lowercase without skipping any characters

C. Skip spaces only, but compare punctuation as is

D. Reverse the string and compare directly without any preprocessing

Solution

1. Step 1: Analyze the string content

   "No lemon, no melon" contains spaces and punctuation that should be ignored.

2. Step 2: Determine necessary preprocessing

   Lowercase conversion and skipping all non-alphanumeric characters ensures correct palindrome check.

3. Final Answer:

   Convert characters to lowercase and skip non-alphanumeric characters during comparison -> Option A

4. Quick Check:

   Lowercase + skip non-alphanumeric = correct palindrome check [OK]

Hint: Lowercase and skip all non-letters/digits [OK]

Common Mistakes:

• Skipping only spaces but not punctuation
• Ignoring case differences
• Comparing raw strings without preprocessing