Maximum Palindromes After Operations - Practice Coding Problems

Maximum Palindromes After Operations - Problem

Array Hash Table String Greedy Sorting Counting Medium

Imagine you have a collection of string words and magical powers to rearrange any characters between them! 🎭

You're given an array of strings words, and you can perform an unlimited number of character swaps. In each operation, you can:

Choose any two strings (they can be the same string)
Pick any character position in each string
Swap those two characters

Your goal is to determine the maximum number of palindromes you can create from these words after performing optimal swaps.

Example: If you have ["abc", "def"], you could swap characters to potentially create ["aba", "dfd"] - two palindromes!

The key insight is that since you can swap any characters between any words, what matters is the total count of each character across all words, not their initial positions.

Input & Output

example_1.py — Basic Case

$ Input: words = ["abde", "cxyz", "abc"]

› Output: 2

💡 Note: We have characters: a=2, b=2, c=2, d=1, e=1, x=1, y=1, z=1. This gives us 3 pairs and 5 singles. Sorting word lengths: [3,4,4]. We can form 2 palindromes by using pairs optimally: one 3-length palindrome (1 pair + 1 single) and one 4-length palindrome (2 pairs).

example_2.py — All Same Length

$ Input: words = ["abc", "def", "ghi"]

› Output: 0

💡 Note: All characters appear only once, giving us 0 pairs and 9 singles. Each word needs at least 1 pair to form a palindrome of length 3, but we have no pairs available. Result: 0 palindromes.

example_3.py — Perfect Palindromes

$ Input: words = ["aab", "baa", "cc"]

› Output: 3

💡 Note: We have a=4, b=2, c=2, giving us 4 pairs and 0 singles. Word lengths [3,3,2] all can be formed into palindromes: length 3 needs 1 pair + 1 single (we can use 2 pairs as substitute), length 3 needs 1 pair + 1 single, length 2 needs 1 pair. Total: 3 palindromes.

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters only
Key insight: Since any character can be moved to any position in any word, only total character counts matter

Visualization

Tap to expand

Understanding the Visualization

Inventory Count

Count all your cookies by letter type across all jars

Resource Planning

Calculate how many 'pairs' and 'single' cookies you have

Smart Assignment

Start with the smallest jars - they need fewer cookies to form palindromes

Maximize Output

Continue until you run out of cookies or jars

Key Takeaway

🎯 Key Insight: Since characters can be freely redistributed, we only care about total character counts. The greedy strategy of filling shortest words first maximizes palindromes because they require fewer resources.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal approach uses a greedy strategy with character counting. Since we can swap any characters between words, we count total character frequencies, calculate available pairs and singles, then greedily assign them to the shortest words first to maximize the number of palindromes. This works because shorter words require fewer resources to become palindromes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Redistributions)	O(exponential)	O(n * m)	Generate all possible ways to redistribute characters and check palindromes
Optimal Greedy with Character Counting	O(n log n + m)	O(k)	Count character frequencies, then greedily assign to shortest words first

Brute Force (Try All Redistributions) — Algorithm Steps

Generate all possible character distributions among words
For each distribution, check if each word can form a palindrome
Count the maximum palindromes across all distributions
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Count All Characters

First, count every character across all words

Generate Distributions

Try every possible way to redistribute characters (exponential possibilities!)

Check Palindromes

For each distribution, check how many words can form palindromes

Find Maximum

Return the distribution that creates the most palindromes

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}

int maxPalindromesAfterOperations(char** words, int wordsSize) {
    // Count characters (assuming lowercase letters only)
    int charCount[26] = {0};
    int wordLengths[wordsSize];
    
    for (int i = 0; i < wordsSize; i++) {
        wordLengths[i] = strlen(words[i]);
        for (int j = 0; j < wordLengths[i]; j++) {
            charCount[words[i][j] - 'a']++;
        }
    }
    
    // Count pairs and singles
    int pairs = 0, singles = 0;
    
    for (int i = 0; i < 26; i++) {
        pairs += charCount[i] / 2;
        singles += charCount[i] % 2;
    }
    
    // Sort word lengths
    qsort(wordLengths, wordsSize, sizeof(int), compare);
    
    int palindromes = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        int pairsNeeded = wordLengths[i] / 2;
        int singleNeeded = wordLengths[i] % 2;
        
        if (pairs >= pairsNeeded && singles >= singleNeeded) {
            pairs -= pairsNeeded;
            singles -= singleNeeded;
            palindromes++;
        }
    }
    
    return palindromes;
}

Time & Space Complexity

Time Complexity

⏱️

O(exponential)

The number of ways to redistribute characters is exponentially large

✓ Linear Growth

Space Complexity

O(n * m)

Space to store different distributions where n is number of words and m is average word length

⚡ Linearithmic Space

38.9K Views

Medium-High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Redistributions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler