Longest Palindromic Substring - Practice Coding Problems

Longest Palindromic Substring - Problem

Find the longest palindromic substring in a given string. A palindrome is a word, phrase, or sequence that reads the same backward as forward, like "racecar" or "madam".

Given a string s, you need to return the longest contiguous substring that forms a palindrome. If there are multiple palindromes of the same maximum length, return any one of them.

Example: In the string "babad", both "bab" and "aba" are valid answers since they're both palindromes of length 3.

Input & Output

example_1.py — Basic Case

$ Input: s = "babad"

› Output: "bab"

💡 Note: Both "bab" and "aba" are valid answers as they are both palindromes of length 3. The algorithm returns "bab" as it's found first.

example_2.py — Even Length Palindrome

$ Input: s = "cbbd"

› Output: "bb"

💡 Note: "bb" is the longest palindromic substring. This demonstrates finding palindromes with even length (center between two characters).

example_3.py — Single Character

$ Input: s = "a"

› Output: "a"

💡 Note: A single character is always a palindrome, so the entire string is returned.

Visualization

Tap to expand

Understanding the Visualization

Identify Centers

Every palindrome has a center - either on a character (odd length) or between characters (even length)

Expand Symmetrically

From each center, expand outward while characters match on both sides

Track Maximum

Keep track of the longest palindrome found during the expansion process

Key Takeaway

🎯 Key Insight: Every palindrome expands symmetrically from its center. By checking all possible centers and expanding outward, we can find the longest palindrome in O(n²) time.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) centers to check × O(n) expansion in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the longest palindrome

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
Note: If there are multiple palindromes of the same maximum length, return any one of them

Asked in

a Amazon 85 ⊞ Microsoft 72 G Google 68 f Meta 54

The optimal approach uses the expand around centers technique with O(n²) time complexity. For each possible center (both characters and between characters), we expand outward while characters match. This is much more efficient than the brute force O(n³) approach of checking all substrings.

Common Approaches

Approach	Time	Space	Notes
✓ Expand Around Centers	O(n²)	O(1)	Expand around each possible center to find palindromes efficiently
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's a palindrome

Expand Around Centers — Algorithm Steps

For each position in the string, consider it as a potential center
Handle both odd-length palindromes (center on character) and even-length palindromes (center between characters)
Expand outward from each center while characters match
Keep track of the longest palindrome found
Return the longest palindromic substring

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Center

Select a character or position between characters as center

Expand Outward

Compare characters moving outward from center

Stop When Mismatch

Stop expanding when characters don't match or reach string bounds

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int expandAroundCenter(char* s, int left, int right, int len) {
    while (left >= 0 && right < len && s[left] == s[right]) {
        left--;
        right++;
    }
    return right - left - 1;
}

char* longestPalindrome(char* s) {
    int len = strlen(s);
    if (len == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    int start = 0;
    int maxLen = 1;
    
    for (int i = 0; i < len; i++) {
        // Check for odd length palindromes
        int len1 = expandAroundCenter(s, i, i, len);
        // Check for even length palindromes
        int len2 = expandAroundCenter(s, i, i + 1, len);
        
        int currentMax = len1 > len2 ? len1 : len2;
        if (currentMax > maxLen) {
            maxLen = currentMax;
            start = i - (currentMax - 1) / 2;
        }
    }
    
    char* result = malloc(maxLen + 1);
    strncpy(result, s + start, maxLen);
    result[maxLen] = '\0';
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    
    char* result = longestPalindrome(s);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) centers to check × O(n) expansion in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the longest palindrome

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
Note: If there are multiple palindromes of the same maximum length, return any one of them

89.4K Views

Very High Frequency

~25 min Avg. Time

2.8K 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

Expand Around Centers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler