Smallest Palindromic Rearrangement I - Practice Coding Problems

Smallest Palindromic Rearrangement I - Problem

Given a palindromic string s, you need to find the lexicographically smallest palindromic permutation of that string.

A palindromic permutation is any rearrangement of the characters in s that reads the same forwards and backwards. Since s is already a palindrome, we know that at least one palindromic permutation exists.

Goal: Return the lexicographically smallest palindromic permutation of s.

Example: If s = "aabaa", possible palindromic permutations include "aabaa", "abaaa", but the lexicographically smallest is "aaaaa" - wait, that's not a palindrome! The correct answer is "aabaa" when rearranged optimally.

Input & Output

example_1.py — Basic Case

$ Input: "aabaa"

› Output: "aabaa"

💡 Note: The input is already a palindrome, and it's already the lexicographically smallest permutation of its characters that forms a palindrome.

example_2.py — Rearrangement Needed

$ Input: "aabbcc"

› Output: "abccba"

💡 Note: Count: a:2, b:2, c:2. Left half gets one of each character in alphabetical order: 'abc'. No middle character needed (all counts are even). Right half is reverse of left: 'cba'. Result: 'abccba'.

example_3.py — With Middle Character

$ Input: "aabbbcc"

› Output: "abcbbca"

💡 Note: Count: a:2, b:3, c:2. Left half: 'abc' (1 of each, taking floor of count/2). Middle: 'b' (the only character with odd count). Right half: 'cba'. Result: 'abcbbca'.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
s is guaranteed to be a palindrome
There will always be at least one palindromic permutation

Visualization

Tap to expand

Understanding the Visualization

Count the Paint Colors

Count how many times each character appears in the string

Design the Left Wing

Use half of each character count to build the left side in alphabetical order

Place the Body

If any character has an odd count, place one in the center

Mirror the Right Wing

Reverse the left side to create the right side, completing the palindrome

Key Takeaway

🎯 Key Insight: A palindrome is perfectly symmetric - optimize one half alphabetically, then mirror it. This avoids generating unnecessary permutations and directly constructs the lexicographically smallest result in O(n) time.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 Apple 12

The optimal solution uses character frequency counting to construct the lexicographically smallest palindrome. Key insight: a palindrome is symmetric, so we only need to optimally arrange the left half and mirror it. Count each character, place half of each count in alphabetical order on the left, handle any odd-count character in the middle, then mirror the left side to create the right side. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Character Counting + Construction (Optimal)	O(n)	O(1)	Count character frequencies and construct the lexicographically smallest palindrome
Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all permutations and find the lexicographically smallest palindrome

Character Counting + Construction (Optimal) — Algorithm Steps

Count frequency of each character in the string
Build the left half by placing half of each character's count in alphabetical order
Identify any character with odd count for the middle position
Mirror the left half to create the right half
Combine left + middle + right to form the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of each character

Build Left Half

Place half of each character count in alphabetical order

Handle Middle

Place the lexicographically smallest odd-count character in middle

Mirror Right Half

Create right half by reversing left half

Code -

solution.c — C

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

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

char* smallestPalindrome(char* s) {
    int len = strlen(s);
    int charCount[256] = {0};
    
    // Count frequency of each character
    for (int i = 0; i < len; i++) {
        charCount[s[i]]++;
    }
    
    char* result = malloc((len + 1) * sizeof(char));
    int pos = 0;
    char middle = 0;
    
    // Process characters in ASCII order (which is lexicographical for same case)
    for (int c = 0; c < 256; c++) {
        if (charCount[c] > 0) {
            // Add half of characters to left side
            for (int i = 0; i < charCount[c] / 2; i++) {
                result[pos++] = c;
            }
            // Track first character with odd count for middle
            if (charCount[c] % 2 == 1 && middle == 0) {
                middle = c;
            }
        }
    }
    
    // Add middle character if exists
    if (middle) {
        result[pos++] = middle;
    }
    
    // Add right half (reverse of left half)
    int rightStart = middle ? pos - 1 : pos;
    for (int i = (middle ? rightStart - 1 : rightStart - 1); i >= 0; i--) {
        if (middle && i == rightStart - 1) continue; // Skip middle
        result[pos++] = result[i];
    }
    
    result[pos] = '\0';
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    // Remove quotes
    char* start = s;
    if (*start == '"') start++;
    char* end = start + strlen(start) - 1;
    if (*end == '"') *end = '\0';
    
    char* result = smallestPalindrome(start);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count characters, then O(n) to construct result

✓ Linear Growth

Space Complexity

O(1)

Only need constant space for character count (at most 26 for lowercase letters)

✓ Linear Space

28.6K Views

Medium Frequency

~15 min Avg. Time

892 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

Character Counting + Construction (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler