Smallest Palindromic Rearrangement II - Practice Coding Problems

Smallest Palindromic Rearrangement II - Problem

Given a palindromic string s and an integer k, your task is to find the k-th lexicographically smallest palindromic permutation of the characters in s.

Key points:

The input string s is already a palindrome
You need to rearrange its characters to form different palindromes
Return the k-th smallest palindrome in lexicographical order
If there are fewer than k distinct palindromic permutations, return an empty string
Different arrangements that create the same palindromic string count as one permutation

Example: For s = "aab" and k = 2, the palindromic permutations are ["aba", "baa"], so return "baa".

Input & Output

example_1.py — Basic Case

$ Input: s = "aab", k = 2

› Output: "baa"

💡 Note: The palindromic permutations of "aab" are ["aba", "baa"] in lexicographical order. The 2nd one is "baa".

example_2.py — Single Character

$ Input: s = "aaa", k = 1

› Output: "aaa"

💡 Note: Only one palindromic permutation exists: "aaa". Since k=1, return "aaa".

example_3.py — Impossible Case

$ Input: s = "abc", k = 1

› Output: ""

💡 Note: "abc" cannot form any palindromic permutation because all characters appear with odd frequency (more than one odd frequency character).

Constraints

1 ≤ s.length ≤ 16
s consists of only lowercase English letters
s is a palindromic string
1 ≤ k ≤ 10⁹
The input string s is guaranteed to be a palindrome

Visualization

Tap to expand

Understanding the Visualization

Analyze Structure

Count character frequencies. Characters with odd counts go in middle, others are split symmetrically

Build First Half

Use combinatorics to determine which character goes at each position for the k-th permutation

Complete Palindrome

Construct: first_half + middle_character + reverse(first_half)

Key Takeaway

🎯 Key Insight: Palindromes have inherent symmetry - we only need to determine the first half and middle character. Using combinatorial mathematics, we can directly calculate which characters belong in each position for the k-th palindrome without generating all possible permutations.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses combinatorial mathematics to directly calculate the k-th palindromic permutation. Key insights: palindromes are symmetric (only need to determine first half), use frequency counting and combinatorial ranking to avoid generating all permutations. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Combinatorial Approach	O(n)	O(1)	Use combinatorics to directly calculate the k-th palindrome without generating all

Mathematical Combinatorial Approach — Algorithm Steps

Count frequency of each character in the string
Determine the structure: characters that appear odd times go in middle
For each position in first half, calculate how many palindromes start with each possible character
Use this count to determine which character should be at current position for k-th palindrome
Build the palindrome by constructing first half + middle + reverse of first half

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each character appears

Palindrome Structure

Identify middle character and halve frequencies for symmetric placement

Combinatorial Ranking

For each position, calculate permutations to determine character choice

Build Result

Construct palindrome: first_half + middle + reversed_first_half

Code -

solution.c — C

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

long long factorial(int n) {
    if (n <= 1) return 1;
    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

char* solution(char* s, int k) {
    int len = strlen(s);
    int freq[26] = {0};
    
    // Count frequencies
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Check palindrome possibility
    int oddCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] % 2 == 1) oddCount++;
    }
    if (oddCount > 1) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    // Find middle character
    char middleChar = '\0';
    for (int i = 0; i < 26; i++) {
        if (freq[i] % 2 == 1) {
            middleChar = 'a' + i;
            freq[i]--;
            break;
        }
    }
    
    // Halve frequencies
    for (int i = 0; i < 26; i++) {
        freq[i] /= 2;
    }
    
    // Build result (simplified approach)
    char* result = malloc((len + 1) * sizeof(char));
    int pos = 0;
    
    // First half
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < freq[i]; j++) {
            result[pos++] = 'a' + i;
        }
    }
    
    // Middle character
    if (middleChar != '\0') {
        result[pos++] = middleChar;
    }
    
    // Second half (reverse of first half)
    int halfLen = (len - (middleChar != '\0' ? 1 : 0)) / 2;
    for (int i = halfLen - 1; i >= 0; i--) {
        result[pos++] = result[i];
    }
    
    result[pos] = '\0';
    return result;
}

int main() {
    char s[100];
    int k;
    scanf("%s %d", s, &k);
    
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%s\n", solution(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, O(n/2) to build first half of palindrome

✓ Linear Growth

Space Complexity

O(1)

Only need frequency counter for 26 possible characters

✓ Linear Space

28.4K Views

Medium Frequency

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

Mathematical Combinatorial Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler