Palindrome Permutation

Palindrome Permutation - Problem

Given a string s, return true if a permutation of the string could form a palindrome and false otherwise.

A palindrome is a word that reads the same forward and backward (e.g., "racecar", "madam").

You need to determine if the characters in the string can be rearranged to form a palindrome, not whether the string itself is already a palindrome.

Example: The string "aab" can be rearranged to "aba", which is a palindrome, so the answer is true.

Input & Output

Example 1 — Can Form Palindrome

$ Input: s = "aab"

› Output: true

💡 Note: The string "aab" can be rearranged to "aba" which is a palindrome. Character 'a' appears 2 times (even), 'b' appears 1 time (odd). Since at most one character has odd frequency, a palindrome is possible.

Example 2 — Cannot Form Palindrome

$ Input: s = "carerac"

› Output: true

💡 Note: The string "carerac" has character frequencies: 'c'=2, 'a'=2, 'r'=2, 'e'=1. Only one character ('e') has an odd frequency, so a palindrome can be formed, for example "caracer".

Example 3 — Single Character

$ Input: s = "a"

› Output: true

💡 Note: A single character is always a palindrome. Character 'a' appears 1 time (odd), which is allowed.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 30 a Amazon 20 M Microsoft 15

The key insight is that a palindrome can have at most one character with odd frequency (the middle character). The optimal approach uses frequency counting in O(n) time, or bit manipulation for O(1) space when dealing with limited character sets. Time: O(n), Space: O(k) where k is unique characters.

Common Approaches

✓ Bit Manipulation Toggle

⏱️ Time: O(n) Space: O(1)

Instead of using a hash map, use bit manipulation where each bit represents whether a character has appeared an odd number of times. XOR operation naturally toggles bits.

Character Frequency Count

⏱️ Time: O(n) Space: O(k)

Count how many times each character appears. For a string to form a palindrome, at most one character can have an odd count (this would be the middle character).

Generate All Permutations

⏱️ Time: O(n! × n) Space: O(n)

This approach generates all possible arrangements of the string characters and checks each permutation to see if it's a palindrome. While conceptually simple, it's extremely inefficient.

Bit Manipulation Toggle — Algorithm Steps

Use integer as bit mask for character frequencies
XOR each character's bit - toggles odd/even count
Check if at most one bit is set (power of 2 check)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Bitmask

Start with bitmask = 0

XOR Each Character

Toggle corresponding bit for each character

Check Result

At most one bit should be set

Code -

solution.c — C

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

bool solution(char* s) {
    int bitMask = 0;
    int len = strlen(s);
    
    // Toggle bit for each character
    for (int i = 0; i < len; i++) {
        bitMask ^= (1 << (s[i] - 'a'));
    }
    
    // Check if at most one bit is set
    return bitMask == 0 || (bitMask & (bitMask - 1)) == 0;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    bool result = solution(s);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant time bit operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses one integer to track all character frequencies

⚡ Linearithmic Space

125.0K 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

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation Toggle — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler