Palindromic Substrings

Palindromic Substrings - Problem

Given a string s, return the number of palindromic substrings in it.

A string is a palindrome when it reads the same backward as forward. A substring is a contiguous sequence of characters within the string.

Input & Output

Example 1 — Basic Case

$ Input: s = "abc"

› Output: 3

💡 Note: Three palindromic substrings: "a", "b", "c". Each single character is a palindrome.

Example 2 — With Longer Palindromes

$ Input: s = "aaa"

› Output: 6

💡 Note: Six palindromic substrings: "a", "a", "a", "aa", "aa", "aaa". Multiple overlapping palindromes exist.

Example 3 — Mixed Palindromes

$ Input: s = "aba"

› Output: 4

💡 Note: Four palindromic substrings: "a" at index 0, "b" at index 1, "a" at index 2, and "aba" spanning the whole string.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32 M Microsoft 28

The key insight is that every palindrome expands around a center. The optimal expand around centers approach checks each possible center (single characters and between characters) and expands outward while characters match. Time: O(n²), Space: O(1)

Common Approaches

✓ Expand Around Centers

⏱️ Time: O(n²) Space: O(1)

Every palindrome expands around a center. The center can be a single character (odd length) or between two characters (even length). For each center, expand outwards as long as characters match.

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For each starting position, generate all substrings ending at each possible position. For each substring, check if it reads the same forwards and backwards by comparing characters.

Dynamic Programming Table

⏱️ Time: O(n²) Space: O(n²)

Use a 2D boolean table where dp[i][j] represents whether substring s[i...j] is a palindrome. Fill the table bottom-up: single characters are palindromes, then check 2-char substrings, then larger ones using previously computed values.

Expand Around Centers — Algorithm Steps

For each character, treat it as center of odd-length palindromes
For each pair of adjacent characters, treat as center of even-length palindromes
Expand outwards while left and right characters match, counting palindromes

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Center

Pick a character or between two characters as center

Expand Outward

Grow palindrome while left and right characters match

Count Found

Add each valid palindrome to the total count

Code -

solution.c — C

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

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

int solution(char* s) {
    int total = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        // Odd length palindromes (center at i)
        total += expandAroundCenter(s, i, i, n);
        // Even length palindromes (center between i and i+1)
        total += expandAroundCenter(s, i, i + 1, n);
    }
    
    return total;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n centers, expand at most n/2 times in each direction

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting and pointers

✓ Linear Space

285.0K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Expand Around Centers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler