Count Palindromic Subsequences - Practice Coding Problems

Count Palindromic Subsequences - Problem

Count Palindromic Subsequences

Given a string of digits s, your task is to find all palindromic subsequences of exactly length 5 and return their count modulo 10⁹ + 7.

A palindrome reads the same forwards and backwards (like "12321" or "90509"). A subsequence is formed by deleting some characters from the original string while maintaining the relative order of remaining characters.

Example: In string "12321", one valid 5-length palindromic subsequence could be the entire string itself, but there might be others depending on repeated digits.

Since palindromic subsequences can grow exponentially with string length, we return the result modulo 10⁹ + 7 to keep numbers manageable.

Input & Output

example_1.py — Basic Case

$ Input: s = "103301"

› Output: 2

💡 Note: The palindromic subsequences of length 5 are "10301" and "13031". Both read the same forwards and backwards.

example_2.py — All Same Digits

$ Input: s = "1111111"

› Output: 21

💡 Note: We need to choose 5 positions from 7 available positions, all containing '1'. This gives us C(7,5) = 21 palindromic subsequences.

example_3.py — Minimum Length

$ Input: s = "12321"

› Output: 1

💡 Note: With exactly 5 characters forming a palindrome, there's only one way to select all 5 positions, giving us the palindrome "12321".

Constraints

1 ≤ s.length ≤ 10³
s consists of digits only (0-9)
Result must be returned modulo 10⁹ + 7
We only count palindromic subsequences of exactly length 5

Visualization

Tap to expand

Understanding the Visualization

Identify Structure

5-length palindromes have form ABCBA where A matches A and B matches B

Fix Center

Choose each character position as the middle (C) of the palindrome

Count Pairs

For each outer character, count valid middle character pairs

Combine Results

Multiply the number of ways to choose each pair type

Key Takeaway

🎯 Key Insight: By recognizing the ABCBA structure and fixing the center, we can efficiently count palindromes using combinatorics rather than generating all subsequences.

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 15

The optimal approach uses dynamic programming with a center-out strategy. For each position as the palindrome center, we count valid pairs for the outer and middle positions, achieving O(n²) time complexity. The key insight is recognizing that 5-length palindromes have structure ABCBA, allowing us to fix the center and count matching pairs efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(C(n,5))	O(1)	Generate all possible 5-length subsequences and check if palindromic
Dynamic Programming (Optimal)	O(n²)	O(1)	Use DP to count palindromes by fixing center and building outward

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all combinations of 5 indices from the string
For each combination, extract the subsequence
Check if the subsequence is palindromic
Count all valid palindromic subsequences
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose 5 positions from the string

Extract Subsequence

For each combination, build the actual subsequence string

Check Palindrome

Test if the subsequence reads the same forwards and backwards

Code -

solution.c — C

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

#define MOD 1000000007

int isPalindrome(char* s, int len) {
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

long long generateCombinations(char* s, int n, int start, int* indices, int depth) {
    if (depth == 5) {
        char subseq[6];
        for (int i = 0; i < 5; i++) {
            subseq[i] = s[indices[i]];
        }
        subseq[5] = '\0';
        return isPalindrome(subseq, 5) ? 1 : 0;
    }
    
    long long count = 0;
    for (int i = start; i <= n - (5 - depth); i++) {
        indices[depth] = i;
        count += generateCombinations(s, n, i + 1, indices, depth + 1);
    }
    return count;
}

int countPalindromicSubsequences(char* s) {
    int n = strlen(s);
    int indices[5];
    return generateCombinations(s, n, 0, indices, 0) % MOD;
}

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", countPalindromicSubsequences(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,5))

We generate C(n,5) combinations where n is string length, which can be enormous

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counting

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler