Valid Palindrome

Clean + reverse

Do exactly what the statement says: filter to alphanumerics, lowercase, compare with the reversal.

def is_palindrome(s: str) -> bool:
    cleaned = [c.lower() for c in s if c.isalnum()]
    return cleaned == cleaned[::-1]

Time O(n), space O(n) for the cleaned copy. Honest and readable — if an interviewer asks for better, they mean the space.

Converging pointers

Skip the copy. Walk left from the front and right from the back; each step, slide past non-alphanumerics, then compare the two survivors case-insensitively.

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

The only subtlety is the guard left < right inside both skip-loops: a string like ".," would otherwise let the pointers cross while skipping and read out of bounds (or compare junk). With the guard, all-punctuation strings fall straight through to True — matching the "empty counts as palindrome" rule.

Time O(n) — each pointer moves at most n steps total. Space O(1) — this is the pattern's whole sales pitch: the answer emerges from positions, not from a rebuilt copy.