Codestin Search App

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.

Constraints

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

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.

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
✓ 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	O(n! × n)	O(n! × n)	Generate all possible permutations and check if any is a palindrome

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty hash set to track odd-frequency characters
For each character in the string:
- If character is in set, remove it (even frequency now)
- If character not in set, add it (odd frequency now)
Return true if set size ≤ 1 (at most one odd frequency)

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Character

Add to set if not present, remove if present

Toggle Logic

Set tracks characters with current odd frequency

Final Check

Set size ≤ 1 means palindrome possible

Code -

solution.c — C

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

bool canPermutePalindrome(char* s) {
    // Track characters with odd frequencies (assuming ASCII)
    bool oddChars[128] = {false};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        int index = (int)s[i];
        // Toggle the odd status
        oddChars[index] = !oddChars[index];
    }
    
    // Count characters with odd frequencies
    int oddCount = 0;
    for (int i = 0; i < 128; i++) {
        if (oddChars[i]) {
            oddCount++;
        }
    }
    
    // At most one character can have odd frequency
    return oddCount <= 1;
}

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)

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

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler