5 Best Ways to Count the Number of Unique Palindromes Using String Characters in Python

Rate this post

πŸ’‘ Problem Formulation: The challenge is to write a Python program that calculates the number of unique palindromic sequences that can be created from the characters of a given string. For example, given the string “aabb”, the desired output is 2, since there are two unique palindromes that can be made: “abba” and “baab”.

Method 1: Frequency Map and Permutations

This technique involves creating a frequency map of all characters in the string then generating possible half-palindromes and mirroring them to create full palindromes. It is best used when the input string is short to medium in length due to the permutations overhead.

Here’s an example:

from collections import Counter
from itertools import permutations

def count_unique_palindromes(s):
    freq = Counter(s)
    odd_char = ''
    half_palindrome = ''
    unique_palindromes = set()

    # Create half palindrome
    for char, count in freq.items():
        if count % 2 != 0:
            odd_char = char
        half_palindrome += char * (count // 2)

    # Generate permutations and construct unique palindromes
    for perm in permutations(half_palindrome):
        middle = odd_char if odd_char else ''
        palindrome = ''.join(perm) + middle + ''.join(perm)[::-1]

    return len(unique_palindromes)

# Testing with a short string



This code snippet counts the unique palindromes by using the Counter class to get the frequency of each character, creating a half-palindrome, and then using permutations to find all unique full-palindrome combinations. It handles the potential central odd character and then mirrors the half part to get a complete palindrome.

Method 2: Recursive Generation

In the recursive generation approach, the function recursively builds palindromes by adding characters on either end. This approach is efficient with strings that have a lot of repeated characters.

Here’s an example:

def count_unique_palindromes_recursive(s):
    freq = Counter(s)
    def generate(freq):
        if len(freq) == 0:
            return ['']
        if len(freq) == 1:
            char, count = next(iter(freq.items()))
            return [char * count]
        palindromes = set()
        for char in list(freq):
            if freq[char] > 1:
                freq[char] -= 2
                for sub_palindrome in generate(freq):
                    palindromes.add(char + sub_palindrome + char)
                freq[char] += 2
                del freq[char]
        return list(palindromes)

    return len(generate(freq))




The recursive approach continuously builds smaller palindromes and wraps them with the same character on both ends. It efficiently reuses intermediates and avoids generating the full permutation set, which significantly reduces overhead for strings with repeated characters.

Method 3: Dynamic Programming

A dynamic programming method to count unique palindromes finds all palindromic sub-strings and uses memoization to avoid redundant calculations. This is most efficient for longer strings where repetitive sub-string calculations are common.

Here’s an example:

# This method is not directly applicable to the specific problem but introduces the dynamic programming approach to working with palindromes in strings.

This method currently lacks specificity for the defined problem, but typically, dynamic programming involves breaking a problem into sub-problems, solving each sub-problem just once, and storing their solutions.

Method 4: Greedy Approach

The greedy approach takes advantage of the palindrome’s symmetry. It attempts to build the longest possible palindrome by pairing characters greedily without considering global implications – effective in scenarios with a high frequency of a few characters.

Here’s an example:

# Again, this is a theoretical approach that does not directly apply to the problem without extensive modification or additional context.

The greedy approach mentioned here does not have a straightforward code example because it would significantly differ based on the given string and may not generate all unique palindromes.

Bonus One-Liner Method 5: Simplified Computation

For a straightforward case where permutations are not involved and palindromic symmetry is enforced, a one-liner can estimate the number based on the number of characters allowed in the palindrome’s center.

Here’s an example:

print(sum(v % 2 for v in Counter("aabb").values()) or 1)



This code leverages the fact that for each unique character of which an odd number exists, one unique palindrome can be made with it in the center. If no such characters exist, the output should be 1, representing the singular even-character palindrome.


  • Method 1: Frequency Map and Permutations. Strengths: Simple and effective for small strings. Weaknesses: Poor scalability with string length due to factorial time complexity.
  • Method 2: Recursive Generation. Strengths: More efficient for strings with many repeated characters by avoiding full permutations. Weaknesses: Potential for stack overflow with large input strings.
  • Method 3: Dynamic Programming. Strengths: Optimizes by avoiding recalculating subproblems. Weaknesses: More complex implementation; may overcomplicate the specific problem unless tailored.
  • Method 4: Greedy Approach. Strengths: Simplest conceptually when few characters have high frequency. Weaknesses: May not find all unique palindromes; lacks a one-size-fits-all implementation.
  • Method 5: Simplified Computation. Strengths: Extremely quick and concise. Weaknesses: Overly simplified and does not count all unique permutations.