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 code when checking if the string "A man, a plan, a canal: Panama" is a valid palindrome?

DSA C

bool isPalindrome(char * s) {
    int left = 0, right = strlen(s) - 1;
    while (left < right) {
        while (left < right && !isalnum(s[left])) left++;
        while (left < right && !isalnum(s[right])) right--;
        if (tolower(s[left]) != tolower(s[right])) return false;
        left++;
        right--;
    }
    return true;
}

int main() {
    char s[] = "A man, a plan, a canal: Panama";
    printf("%s\n", isPalindrome(s) ? "true" : "false");
    return 0;
}

A Runtime error

B true

C Compilation error

D false

💡 Hint

Consider only alphanumeric characters and ignore cases.

The code uses two pointers moving inward, skipping non-alphanumeric characters and comparing lowercase characters. The input string is a classic palindrome ignoring spaces and punctuation.

❓ Predict Output

intermediate

Output for Non-Palindrome String

What will the output be when the code checks if the string "race a car" is a valid palindrome?

DSA C

bool isPalindrome(char * s) {
    int left = 0, right = strlen(s) - 1;
    while (left < right) {
        while (left < right && !isalnum(s[left])) left++;
        while (left < right && !isalnum(s[right])) right--;
        if (tolower(s[left]) != tolower(s[right])) return false;
        left++;
        right--;
    }
    return true;
}

int main() {
    char s[] = "race a car";
    printf("%s\n", isPalindrome(s) ? "true" : "false");
    return 0;
}

A false

B true

C Compilation error

D Runtime error

💡 Hint

Check characters ignoring spaces and punctuation carefully.

The string "race a car" is not a palindrome when ignoring spaces and punctuation because 'e' and 'a' do not match at the corresponding positions.

🧠 Conceptual

advanced

Why Two Pointers Work for Palindrome Check

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

A It converts the string to uppercase before checking.

B It sorts the string first to check for palindrome properties.

C It uses extra memory to store reversed string for comparison.

D It compares characters from both ends simultaneously, reducing the number of comparisons.

💡 Hint

Think about how palindrome characters relate from start and end.

Two pointers start from the beginning and end and move inward, comparing characters directly without extra space or full string reversal.

🔧 Debug

advanced

Identify the Bug in Palindrome Code

What is the bug in this palindrome checking code snippet?

DSA C

bool isPalindrome(char * s) {
    int left = 0, right = strlen(s);
    while (left < right) {
        if (tolower(s[left]) != tolower(s[right])) return false;
        left++;
        right--;
    }
    return true;
}

A right should be initialized to strlen(s) - 1 to avoid out-of-bounds access.

B tolower should not be used on characters.

C left and right pointers should both start at 0.

D The loop condition should be while (left <= right).

💡 Hint

Check the index of the last character in the string.

strlen(s) returns the length, but valid indices go from 0 to length-1. Using length as index causes out-of-bounds access.

🚀 Application

expert

Count Palindromic Substrings Using Two Pointers

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

A Use a hash map to store all substrings and check each for palindrome.

B Reverse the string and compare substrings directly.

C Expand around each center (single and between characters) using two pointers to count palindromes.

D Sort the string and count repeated characters as palindromes.

💡 Hint

Think about how to find palindromes centered at each position.

Expanding around centers with two pointers allows counting all palindromic substrings efficiently without extra space.

Practice

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

easy

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

B. Sort the string and check if it matches the original

C. Reverse the string and compare with the original

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

Solution

1. Step 1: Understand two-pointer setup

   Two pointers start at the beginning and end of the string to compare characters.

2. Step 2: Move pointers inward while characters match

   If characters at both pointers are equal, move pointers closer until they meet or cross.

3. Final Answer:

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

4. Quick Check:

   Two-pointer palindrome check = Use two pointers starting from both ends and move towards the center comparing characters [OK]

Hint: Compare characters from ends moving inward [OK]

Common Mistakes:

• Trying to sort the string which changes order
• Only checking half the string without pointers
• Ignoring non-alphanumeric characters if required

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

easy

A. int left = 0, right = strlen(s) - 1;

B. int left = 1, right = strlen(s);

C. int left = 0, right = strlen(s);

D. int left = 1, right = strlen(s) - 1;

Solution

1. Step 1: Understand string indexing in C

   Strings are zero-indexed, so first character is at 0 and last at length-1.

2. Step 2: Correct pointer initialization

   Left pointer starts at 0, right pointer at strlen(s)-1 to cover full string.

3. Final Answer:

   int left = 0, right = strlen(s) - 1; -> Option A

4. Quick Check:

   Indexing starts at 0, last index = length-1 [OK]

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

Common Mistakes:

• Setting right pointer to strlen(s) which is out of bounds
• Starting left pointer at 1 skipping first character
• Using wrong indices causing runtime errors

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

char s[] = "racecar";
int left = 0, right = strlen(s) - 1;
int isPalindrome = 1;
while (left < right) {
    if (s[left] != s[right]) {
        isPalindrome = 0;
        break;
    }
    left++;
    right--;
}
printf("%d", isPalindrome);

medium

A. 0

B. 1

C. 7

D. Compilation error

Solution

1. Step 1: Trace pointer comparisons on "racecar"

   Characters at left and right match: 'r'=='r', 'a'=='a', 'c'=='c', 'e'=='e'.

2. Step 2: Loop completes without mismatch

   No mismatch found, so isPalindrome remains 1 and prints 1.

3. Final Answer:

   1 -> Option B

4. Quick Check:

   "racecar" is palindrome = 1 [OK]

Hint: Check matching pairs from ends; no mismatch means palindrome [OK]

Common Mistakes:

• Assuming output is string instead of integer
• Confusing index bounds causing wrong comparisons
• Forgetting to break loop on mismatch

4. Identify the bug in the following C code that checks if a string s is a palindrome using two pointers:

int left = 0, right = strlen(s);
while (left <= right) {
    if (s[left] != s[right]) {
        return 0;
    }
    left++;
    right--;
}
return 1;

medium

A. Both A and B are bugs

B. Loop condition should be left < right, not left <= right

C. Right pointer should be initialized to strlen(s) - 1

D. No bug, code is correct

Solution

1. Step 1: Check right pointer initialization

   Right pointer set to strlen(s) is out of bounds; should be strlen(s) - 1.

2. Step 2: Check loop condition

   Loop should run while left < right to avoid comparing same middle character twice.

3. Final Answer:

   Both A and B are bugs -> Option A

4. Quick Check:

   Right pointer and loop condition both incorrect = Both A and B are bugs [OK]

Hint: Right pointer = length-1 and loop: left < right [OK]

Common Mistakes:

• Using strlen(s) as right pointer causing out-of-bounds access
• Using <= in loop causing unnecessary comparison
• Ignoring off-by-one errors

5. Given a string s that may contain uppercase letters, lowercase letters, and non-alphanumeric characters, which approach correctly checks if s is a palindrome ignoring cases and non-alphanumeric characters using two pointers?

hard

A. Count frequency of alphanumeric characters and check if all counts are even

B. Convert entire string to lowercase, remove non-alphanumeric chars, then compare with reversed string

C. Use two pointers from ends, skip non-alphanumeric chars, compare lowercase characters

D. Use two pointers but compare characters directly without skipping or case conversion

Solution

1. Step 1: Use two pointers and skip non-alphanumeric characters

   Move left and right pointers inward, skipping characters that are not letters or digits.

2. Step 2: Compare characters in lowercase form

   Convert characters to lowercase before comparing to ignore case differences.

3. Final Answer:

   Use two pointers from ends, skip non-alphanumeric chars, compare lowercase characters -> Option C

4. Quick Check:

   Two-pointer with skip and lowercase = Use two pointers from ends, skip non-alphanumeric chars, compare lowercase characters [OK]

Hint: Skip non-alphanumeric and compare lowercase chars with two pointers [OK]

Common Mistakes:

• Comparing characters without skipping non-alphanumeric
• Not converting characters to lowercase before comparison
• Using frequency count which doesn't check order