Palindromic Substrings - Practice Coding Problems

Palindromic Substrings - Problem

Count Palindromic Substrings

Given a string s, return the total number of palindromic substrings contained within it.

A palindrome is a string that reads the same forwards and backwards (like "racecar" or "aba"). A substring is any contiguous sequence of characters within the original string.

For example, in the string "abc", we have substrings: "a", "b", "c", "ab", "bc", "abc". Among these, only "a", "b", and "c" are palindromes, so the answer is 3.

Your task: Count all palindromic substrings efficiently!

Input & Output

example_1.py — Basic case

$ Input: s = "abc"

› Output: 3

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

example_2.py — Multiple palindromes

$ Input: s = "aaa"

› Output: 6

💡 Note: Six palindromic substrings: "a" (3 times), "aa" (2 times), "aaa" (1 time). Total = 3 + 2 + 1 = 6.

example_3.py — Mixed palindromes

$ Input: s = "aba"

› Output: 4

💡 Note: Four palindromic substrings: "a" (at index 0), "b", "a" (at index 2), and "aba". The entire string is also a palindrome.

Visualization

Tap to expand

Understanding the Visualization

Single tile mirrors

Every single tile is a perfect mirror by itself

Expand from center

From each tile, check if expanding left and right creates mirror patterns

Check dual centers

Also check if adjacent tiles can form the center of an even-length mirror

Count all patterns

Sum up all valid mirror patterns found

Key Takeaway

🎯 Key Insight: Instead of checking every substring individually, expand around each potential center point. This naturally finds all palindromes while avoiding redundant work - like ripples expanding from stones dropped in water!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings × O(n) for checking each palindrome

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
A single character is always considered a palindrome

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 24 Apple 18

The optimal solution uses the expand around centers technique with O(n²) time complexity. For each position, we expand outward while characters match, efficiently finding all palindromes without generating substrings explicitly. This handles both odd-length (single center) and even-length (dual center) palindromes elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and check each one for palindrome property
Expand Around Centers	O(n²)	O(1)	For each possible center, expand outward using two pointers while characters match

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through each possible starting position (0 to n-1)
For each start, iterate through each possible ending position (start to n-1)
Extract the substring from start to end
Check if the substring is a palindrome by comparing it with its reverse
If palindrome, increment the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate substrings

Start with position 0, generate all substrings starting from there

Check palindrome

For each substring, compare with its reverse

Count matches

Increment counter when palindrome found

Repeat

Move to next starting position and repeat

Code -

solution.c — C

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

bool isPalindrome(char* str, int start, int end) {
    while (start < end) {
        if (str[start] != str[end]) {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

int countSubstrings(char* s) {
    int count = 0;
    int n = strlen(s);
    
    // Check every possible substring
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if substring from i to j is palindrome
            if (isPalindrome(s, i, j)) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", countSubstrings(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings × O(n) for checking each palindrome

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
A single character is always considered a palindrome

89.2K Views

High Frequency

~15 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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler