Lexicographically Smallest Palindrome - Practice Coding Problems

Lexicographically Smallest Palindrome - Problem

You're given a string s consisting of lowercase English letters. Your mission is to transform it into a palindrome using the minimum number of character replacements possible.

Here's the twist: if multiple palindromes can be created with the same minimum operations, you must choose the lexicographically smallest one (the one that would appear first in a dictionary).

What makes a string lexicographically smaller?
String a is lexicographically smaller than string b if at the first position where they differ, a has a letter that comes earlier in the alphabet.

Goal: Return the lexicographically smallest palindrome that requires the minimum number of operations.

Example: "abcd" → "abba" (2 operations: change 'c' to 'b' and 'd' to 'a')

Input & Output

example_1.py — Basic Case

$ Input: s = "egcfe"

› Output: "efcfe"

💡 Note: The minimum operations needed are 2: change 'g' to 'f' and 'd' to 'f'. Among all possible palindromes with 2 operations, "efcfe" is lexicographically smallest.

example_2.py — Already Optimal

$ Input: s = "abcd"

› Output: "abba"

💡 Note: We need 2 operations: change 'c' to 'b' and 'd' to 'a'. This creates "abba" which is the lexicographically smallest palindrome with minimum operations.

example_3.py — Single Character

$ Input: s = "a"

› Output: "a"

💡 Note: Single character strings are already palindromes, so no operations needed.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Follow-up: Can you solve this in O(n) time with O(1) extra space?

Visualization

Tap to expand

Understanding the Visualization

Set Up Mirrors

Place two pointers at opposite ends of the string like mirrors facing each other

Check Reflection

Compare characters at mirror positions - do they match?

Choose Wisely

If they don't match, pick the lexicographically smaller character

Apply to Both

Set both mirror positions to the chosen character

Move Inward

Move both pointers toward the center and repeat

Key Takeaway

🎯 Key Insight: The greedy choice of always selecting the lexicographically smaller character for mismatched pairs guarantees both minimum operations and the smallest possible palindrome.

Asked in

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

The optimal solution uses a two-pointer approach in O(n) time. Start from both ends and for each mismatched pair, choose the lexicographically smaller character for both positions. This greedy choice guarantees both minimum operations and the lexicographically smallest result.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Possibilities)	O(26^(n/2))	O(n)	Generate all possible palindromes and find the lexicographically smallest one
Two Pointers (Optimal)	O(n)	O(1)	Use two pointers from both ends, choosing lexicographically smaller character for each pair

Brute Force (Check All Possibilities) — Algorithm Steps

Identify all positions that need to be changed to form a palindrome
Generate all possible combinations of character choices for mismatched pairs
For each combination, count the number of operations needed
Among combinations with minimum operations, find the lexicographically smallest
Return the optimal palindrome

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Mismatches

Identify positions where s[i] ≠ s[n-1-i]

Generate Options

For each mismatch, try all 26 possible characters

Count Operations

Calculate operations needed for each combination

Select Best

Choose lexicographically smallest with minimum operations

Code -

solution.c — C

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

int minOps = INT_MAX;
char bestResult[1001];

void generatePalindromes(int pos, char* currentS, int ops, int n) {
    if (pos >= n / 2) {
        int isPalindrome = 1;
        for (int i = 0; i < n; i++) {
            if (currentS[i] != currentS[n - 1 - i]) {
                isPalindrome = 0;
                break;
            }
        }
        
        if (isPalindrome) {
            if (ops < minOps || (ops == minOps && (strlen(bestResult) == 0 || strcmp(currentS, bestResult) < 0))) {
                minOps = ops;
                strcpy(bestResult, currentS);
            }
        }
        return;
    }
    
    int left = pos;
    int right = n - 1 - pos;
    
    if (left == right) {
        generatePalindromes(pos + 1, currentS, ops, n);
    } else {
        if (currentS[left] == currentS[right]) {
            generatePalindromes(pos + 1, currentS, ops, n);
        } else {
            for (char c = 'a'; c <= 'z'; c++) {
                char newS[1001];
                strcpy(newS, currentS);
                int newOps = ops;
                if (newS[left] != c) {
                    newS[left] = c;
                    newOps++;
                }
                if (newS[right] != c) {
                    newS[right] = c;
                    newOps++;
                }
                generatePalindromes(pos + 1, newS, newOps, n);
            }
        }
    }
}

char* makeSmallestPalindrome(char* s) {
    int n = strlen(s);
    minOps = INT_MAX;
    bestResult[0] = '\0';
    
    generatePalindromes(0, s, 0, n);
    return strlen(bestResult) > 0 ? bestResult : s;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%s\n", makeSmallestPalindrome(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^(n/2))

For each mismatched pair, we try all 26 possible characters, and there can be up to n/2 pairs

✓ Linear Growth

Space Complexity

O(n)

Space to store the string and temporary combinations

⚡ Linearithmic Space

82.0K Views

Medium Frequency

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

Brute Force (Check All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler