Valid Palindrome Two Pointer in DSA Python - 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 is a valid palindrome ignoring non-alphanumeric characters and case?

DSA Python

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        if s[left].lower() != s[right].lower():
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("A man, a plan, a canal: Panama"))

A False

B SyntaxError

C TypeError

D True

💡 Hint

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

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

❓ Predict Output

intermediate

Output for Non-Palindrome String

What will the function return for the input string "race a car"?

DSA Python

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        if s[left].lower() != s[right].lower():
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("race a car"))

A False

B True

C IndexError

D ValueError

💡 Hint

Check the characters compared at the first mismatch.

The function returns False because "race a car" is not a palindrome when ignoring spaces and case. The characters compared at the mismatch cause the function to return False.

🔧 Debug

advanced

Identify the bug in palindrome check

What error will this code produce when run with input "No lemon, no melon"?

DSA Python

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    while left <= right:
        if not s[left].isalnum():
            left += 1
        if not s[right].isalnum():
            right -= 1
        if s[left].lower() != s[right].lower():
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("No lemon, no melon"))

A IndexError

B True

C False

D SyntaxError

💡 Hint

Check how pointers move when skipping characters.

The code increments left and right pointers without using 'while' loops to skip non-alphanumeric characters properly. This can cause pointers to move past each other and cause IndexError when accessing s[left] or s[right].

❓ Predict Output

advanced

Output of palindrome check with empty string

What is the output of the palindrome check function when the input string is empty?

DSA Python

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    while left < right:
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        if s[left].lower() != s[right].lower():
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("") )

A IndexError

B False

C True

D TypeError

💡 Hint

Consider the meaning of an empty string as a palindrome.

An empty string is considered a valid palindrome. The function returns True immediately because the while loop condition is false initially.

🧠 Conceptual

expert

Why use two pointers for palindrome check?

Which of the following best explains why the two-pointer technique is efficient for checking if a string is a palindrome ignoring non-alphanumeric characters and case?

A It converts the string to a list and reverses it, then compares both lists for equality.

B It allows checking characters from both ends simultaneously, skipping irrelevant characters, reducing time complexity to O(n).

C It uses recursion to compare characters, which uses less memory than iteration.

D It sorts the string first, then compares characters, which is faster than other methods.

💡 Hint

Think about how skipping characters and comparing from both ends helps.

The two-pointer technique moves inward from both ends, skipping non-alphanumeric characters and comparing characters in one pass, making it efficient with O(n) time complexity.

Practice

1. What does the two-pointer technique check when verifying if a string is a palindrome?

easy

A. It counts the number of vowels in the string

B. It compares characters from the start and end moving towards the center

C. It reverses the string and compares with the original

D. It sorts the characters and checks if sorted string equals original

Solution

1. Step 1: Understand two-pointer technique

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

2. Step 2: Compare characters moving inward

   Characters at both pointers are compared; pointers move closer if equal.

3. Final Answer:

   It compares characters from the start and end moving towards the center -> Option B

4. Quick Check:

   Two-pointer palindrome check = comparing ends [OK]

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

Common Mistakes:

• Thinking it reverses the string
• Checking only vowels or sorting characters
• Using one pointer only

2. Which of the following is the correct syntax to initialize two pointers for a palindrome check in Python?

easy

A. left = 1; right = len(s)

B. left = -1; right = len(s) + 1

C. left = len(s); right = 0

D. left = 0; right = len(s) - 1

Solution

1. Step 1: Identify pointer start positions

   Left pointer starts at 0 (first character), right pointer at last index (length - 1).

2. Step 2: Check syntax correctness

   left = 0; right = len(s) - 1 correctly sets left=0 and right=len(s)-1 for valid indexing.

3. Final Answer:

   left = 0; right = len(s) - 1 -> Option D

4. Quick Check:

   Start pointers at 0 and last index [OK]

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

Common Mistakes:

• Starting right pointer at length (out of range)
• Starting left pointer at 1 (skips first char)
• Using negative or invalid indices

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

def is_palindrome(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome('racecar'))
print(is_palindrome('hello'))

medium

A. True\nTrue

B. False\nTrue

C. True\nFalse

D. False\nFalse

Solution

1. Step 1: Check 'racecar' palindrome

   Characters match from both ends, so returns True.

2. Step 2: Check 'hello' palindrome

   Characters differ ('h' != 'o'), returns False.

3. Final Answer:

   True\nFalse -> Option C

4. Quick Check:

   'racecar' palindrome = True, 'hello' not = False [OK]

Hint: Check characters from ends; mismatch means False [OK]

Common Mistakes:

• Assuming 'hello' is palindrome
• Returning True without full check
• Mixing up True/False outputs

4. Find the error in this palindrome check code:

def check_palindrome(s):
    left, right = 0, len(s)
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

medium

A. right should be initialized as len(s) - 1

B. left should start at 1

C. The while condition should be left <= right

D. The function should return False at the end

Solution

1. Step 1: Check pointer initialization

   Right pointer is set to len(s), which is out of string index range.

2. Step 2: Correct pointer initialization

   Right should be len(s) - 1 to point to last character index.

3. Final Answer:

   right should be initialized as len(s) - 1 -> Option A

4. Quick Check:

   Right pointer must be last index, not length [OK]

Hint: Right pointer = length minus one, not length [OK]

Common Mistakes:

• Using len(s) as index causes IndexError
• Changing left pointer start incorrectly
• Incorrect loop condition

5. Given the string s = "A man, a plan, a canal: Panama", which modification is needed in the two-pointer palindrome check to correctly identify it as a palindrome?

hard

A. Ignore non-alphanumeric characters and case during comparison

B. Reverse the string and compare directly

C. Only compare vowels in the string

D. Convert string to uppercase and compare characters directly

Solution

1. Step 1: Understand input complexity

   String contains spaces, commas, and mixed case which affect direct comparison.

2. Step 2: Modify comparison logic

   Skip non-alphanumeric characters and compare lowercase versions to ignore case and symbols.

3. Step 3: Why other options fail

   Reversing or uppercase alone won't ignore spaces/punctuation; vowels only is incorrect.

4. Final Answer:

   Ignore non-alphanumeric characters and case during comparison -> Option A

5. Quick Check:

   Clean string and ignore case for palindrome check [OK]

Hint: Skip symbols and compare lowercase chars [OK]

Common Mistakes:

• Not ignoring punctuation and spaces
• Only changing case without skipping symbols
• Comparing vowels only