Palindrome Permutation - Practice Coding Problems

Palindrome Permutation - Problem

Given a string s, determine if any permutation of the characters in the string can form a palindrome.

A palindrome is a word that reads the same forwards and backwards, like "racecar" or "madam". The key insight is that we don't need to generate all permutations - we just need to check if the character frequencies allow for a palindromic arrangement.

Examples:

"aab" → true (can form "aba")
"carerac" → true (can form "racecar")
"code" → false (no palindromic permutation possible)

Think about it: What property must the character frequencies have for a palindrome to be possible?

Input & Output

example_1.py — Basic case with palindrome possible

$ Input: s = "aab"

› Output: true

💡 Note: The string "aab" can be rearranged to form "aba", which is a palindrome. Character frequencies: a=2 (even), b=1 (odd). Since only one character has odd frequency, a palindrome is possible.

example_2.py — No palindrome possible

$ Input: s = "code"

› Output: false

💡 Note: The string "code" cannot form any palindrome. Character frequencies: c=1, o=1, d=1, e=1. All characters have odd frequencies (4 odd counts > 1), so no palindromic arrangement is possible.

example_3.py — Perfect palindrome

$ Input: s = "carerac"

› Output: true

💡 Note: The string "carerac" can be rearranged to form "racecar". Character frequencies: c=2, a=2, r=2, e=1. Only 'e' has odd frequency, so it can be the center character of a palindrome.

Visualization

Tap to expand

Understanding the Visualization

Count Letter Pairs

For palindrome 'racecar': r-r pair, a-a pair, c-c pair, with 'e' in center

Apply Mirror Rule

All letters must have even count (for pairs) except at most one (for center)

Verify Pattern

If ≤1 letter has odd count, palindrome arrangement is possible

Key Takeaway

🎯 Key Insight: For any palindrome, characters must form mirror pairs with at most one character in the center position.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each set operation is O(1) average case

✓ Linear Growth

Space Complexity

O(k)

Set stores at most k unique characters with odd frequency, where k ≤ min(n, 128)

✓ Linear Space

Constraints

0 ≤ s.length ≤ 5000
s consists of only lowercase English letters
Empty string is considered to have palindromic permutation

Asked in

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

The optimal solution uses a hash set to track characters with odd frequencies in a single pass. For each character, we toggle its presence in the set - if present, remove it (even frequency); if absent, add it (odd frequency). A palindrome is possible if at most one character has an odd frequency (the potential center character). Time: O(n), Space: O(k) where k is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n! × n)	O(n! × n)	Generate all possible permutations and check if any is a palindrome
One-Pass Hash Set (Optimal)	O(n)	O(k)	Track characters with odd frequencies using a set in single pass
Two-Pass Character Counting	O(n)	O(k)	Count character frequencies first, then verify palindrome condition

Generate All Permutations — Algorithm Steps

Generate all permutations of the input string
For each permutation, check if it's a palindrome
Return true if any permutation is palindromic
Return false if no palindromic permutation is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Permutations

Create every possible arrangement of characters

Check Each Permutation

Test if each arrangement is a palindrome

Return Result

Return true if any palindrome is found

Code -

solution.c — C

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

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

void swap(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

bool permuteAndCheck(char* s, int start, int len) {
    if (start == len) {
        return isPalindrome(s);
    }
    
    for (int i = start; i < len; i++) {
        swap(&s[start], &s[i]);
        if (permuteAndCheck(s, start + 1, len)) {
            return true;
        }
        swap(&s[start], &s[i]);
    }
    return false;
}

bool canPermutePalindrome(char* s) {
    int len = strlen(s);
    char* copy = malloc((len + 1) * sizeof(char));
    strcpy(copy, s);
    
    bool result = permuteAndCheck(copy, 0, len);
    free(copy);
    return result;
}

int main() {
    char s[1001];
    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] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    
    printf("%s\n", canPermutePalindrome(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to check each palindrome

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storage for all permutations, each of length n

⚠ Quadratic Space

Constraints

0 ≤ s.length ≤ 5000
s consists of only lowercase English letters
Empty string is considered to have palindromic permutation

52.0K Views

High Frequency

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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler