Valid Palindrome - Practice Coding Problems

Valid Palindrome - Problem

The Palindrome Challenge

A palindrome is a word, phrase, or sentence that reads the same forward and backward - like "racecar" or "A man, a plan, a canal: Panama". Your task is to determine if a given string is a valid palindrome.

The Rules:
• Convert all uppercase letters to lowercase
• Remove all non-alphanumeric characters (keep only letters and numbers)
• Check if the cleaned string reads the same forward and backward

Example: "A man, a plan, a canal: Panama" becomes "amanaplanacanalpanama" which is indeed a palindrome!

Goal: Return true if the processed string is a palindrome, false otherwise.

Input & Output

example_1.py — Basic Palindrome

$ Input: s = "A man, a plan, a canal: Panama"

› Output: true

💡 Note: After removing non-alphanumeric characters and converting to lowercase, we get "amanaplanacanalpanama", which reads the same forward and backward.

example_2.py — Not a Palindrome

$ Input: s = "race a car"

› Output: false

💡 Note: After cleaning, we get "raceacar". Reading forward: 'raceacar', reading backward: 'raceacar'. Wait, that's wrong - backward is 'racaecar', which is different.

example_3.py — Empty String Edge Case

$ Input: s = " "

› Output: true

💡 Note: After removing non-alphanumeric characters, we get an empty string, which is considered a palindrome by definition.

Visualization

Tap to expand

Understanding the Visualization

Position Inspectors

Place one inspector at the start, another at the end

Clean as You Go

Each inspector skips over dust and punctuation

Compare Characters

When both find valid letters, they compare (ignoring case)

Move Inward

If characters match, both move toward the center

Key Takeaway

🎯 Key Insight: By using two pointers moving inward and comparing characters on-the-fly, we eliminate the need for extra string storage, achieving optimal O(1) space complexity while maintaining O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with two pointers meeting in the middle

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no additional string storage

✓ Linear Space

Constraints

1 ≤ s.length ≤ 2 × 10⁵
s consists only of printable ASCII characters
Empty string after cleaning is considered a valid palindrome

Asked in

f Meta 45 a Amazon 38 ⊞ Microsoft 32 G Google 28 Apple 22

The optimal solution uses two pointers starting from opposite ends, moving toward each other while skipping non-alphanumeric characters and comparing valid characters directly. This achieves O(1) space complexity by avoiding the creation of cleaned strings, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers moving from both ends, checking characters on-the-fly
Brute Force (Clean and Reverse)	O(n)	O(n)	Clean the string, create reversed copy, then compare character by character

Two Pointers (Optimal) — Algorithm Steps

Initialize left pointer at start and right pointer at end of string
Move left pointer forward until alphanumeric character or past right pointer
Move right pointer backward until alphanumeric character or past left pointer
Compare lowercase versions of characters at both pointers
If characters match, move both pointers toward center; if not, return false
Continue until pointers meet or cross - return true if all comparisons passed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left pointer at start, right pointer at end

Skip Invalid Chars

Move pointers to next valid alphanumeric characters

Compare & Move

Compare characters and move pointers inward

Repeat Until Done

Continue until pointers meet or mismatch found

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

bool isPalindrome(char* s) {
    int left = 0, right = strlen(s) - 1;
    
    while (left < right) {
        // Skip non-alphanumeric characters from left
        while (left < right && !isalnum(s[left])) {
            left++;
        }
        
        // Skip non-alphanumeric characters from right
        while (left < right && !isalnum(s[right])) {
            right--;
        }
        
        // Compare characters (case-insensitive)
        if (tolower(s[left]) != tolower(s[right])) {
            return false;
        }
        
        left++;
        right--;
    }
    
    return true;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    printf("%s\n", isPalindrome(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with two pointers meeting in the middle

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no additional string storage

✓ Linear Space

Constraints

1 ≤ s.length ≤ 2 × 10⁵
s consists only of printable ASCII characters
Empty string after cleaning is considered a valid palindrome

89.5K Views

Very High Frequency

~15 min Avg. Time

3.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler