Unique Length-3 Palindromic Subsequences - Practice Coding Problems

Unique Length-3 Palindromic Subsequences - Problem

You're given a string s and need to find the count of unique palindromes of length 3 that can be formed as subsequences.

A palindrome reads the same forwards and backwards (like "aba" or "cdc"). A subsequence maintains the original character order but allows skipping characters.

Key points:

We only count unique palindromes - duplicates count as one
Length must be exactly 3
Characters don't need to be consecutive in the original string

Example: In "aabca", we can form subsequences like "aba" and "aca", giving us 2 unique length-3 palindromes.

Input & Output

example_1.py — Basic Case

$ Input: s = "aabca"

› Output: 3

💡 Note: The unique palindromes are: 'aaa' (using positions 0,1,4), 'aba' (using positions 0,2,4), and 'aca' (using positions 0,3,4). All use 'a' as outer characters with different middle characters.

example_2.py — Single Character

$ Input: s = "aaa"

› Output: 1

💡 Note: Only one unique palindrome 'aaa' can be formed. Even though there are multiple ways to choose 3 'a's from the string, they all result in the same palindrome.

example_3.py — No Repeated Characters

$ Input: s = "abc"

› Output: 0

💡 Note: No character appears more than once, so no 3-character palindromes can be formed since we need at least 2 occurrences of the same character for the first and last positions.

Visualization

Tap to expand

Understanding the Visualization

Identify Bread Types

Scan string to find which characters appear at least twice (can be outer chars)

Find Sandwich Boundaries

For each 'bread' character, find its leftmost and rightmost positions

Count Filling Options

Between boundaries, count how many different 'filling' characters exist

Sum All Sandwiches

Each bread-filling combination creates a unique palindrome sandwich

Key Takeaway

🎯 Key Insight: Every 3-char palindrome is like a sandwich - identical 'bread' (outer chars) with any 'filling' (middle char) between the first and last occurrence of the bread character!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, set operations are O(1) average case

✓ Linear Growth

Space Complexity

O(1)

Only storing at most 26 characters and their middle character sets

✓ Linear Space

Constraints

3 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
A palindrome must have exactly 3 characters
Only unique palindromes are counted

Asked in

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

The optimal solution uses hash maps to track the first and last occurrence of each character in O(n) time. For each character that appears at least twice, we count the unique characters between its first and last positions - these represent all possible 3-character palindromes with that character as the outer elements. The key insight is that palindromes have the form XYX, so we only need to find unique middle characters Y for each valid outer character X.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loop)	O(n³)	O(1)	Check all possible triplets of characters to find palindromes
One-Pass Optimal Solution	O(n)	O(1)	Track first/last positions and middle characters in a single pass
Two-Pass Character Position Mapping	O(n)	O(n)	First pass maps character positions, second pass finds palindromes efficiently

Brute Force (Triple Nested Loop) — Algorithm Steps

Use three nested loops: outer char at i, middle char at j, inner char at k
For each triplet (i,j,k) where i < j < k, check if s[i] == s[k]
If palindrome found, add to set to ensure uniqueness
Return size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with three pointers at positions 0, 1, 2

Check Pattern

Check if s[i] == s[k] to form palindrome

Move Pointers

Increment k, then j, then i systematically

Store Unique

Add found palindromes to set for uniqueness

Code -

solution.c — C

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

#define MAX_PALINDROMES 676

int countPalindromicSubsequence(char* s) {
    char palindromes[MAX_PALINDROMES][4];
    int count = 0;
    int n = strlen(s);
    
    // Try all possible triplets (i, j, k) where i < j < k
    for (int i = 0; i < n - 2; i++) {
        for (int j = i + 1; j < n - 1; j++) {
            for (int k = j + 1; k < n; k++) {
                // Check if forms palindrome
                if (s[i] == s[k]) {
                    char palindrome[4] = {s[i], s[j], s[k], '\0'};
                    
                    // Check if already exists
                    int exists = 0;
                    for (int p = 0; p < count; p++) {
                        if (strcmp(palindromes[p], palindrome) == 0) {
                            exists = 1;
                            break;
                        }
                    }
                    
                    if (!exists) {
                        strcpy(palindromes[count], palindrome);
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, len-2);
        s[len-3] = '\0';
    }
    
    printf("%d\n", countPalindromicSubsequence(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterating through all possible triplet positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a set to store unique palindromes, at most 26² = 676 entries

✓ Linear Space

Constraints

3 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
A palindrome must have exactly 3 characters
Only unique palindromes are counted

52.9K Views

Medium Frequency

~15 min Avg. Time

1.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 (Triple Nested Loop) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler