Break a Palindrome - Practice Coding Problems

Break a Palindrome - Problem

String Greedy Medium

You're given a palindromic string of lowercase English letters. Your mission is to break the palindrome by replacing exactly one character with any lowercase English letter, creating a string that is:

✅ Not a palindrome
✅ Lexicographically smallest possible

If it's impossible to break the palindrome (hint: think about single characters!), return an empty string.

Lexicographical order: String a comes before string b if at the first differing position, a has a smaller character. For example, "abcc" < "abcd" because 'c' < 'd' at position 3.

Example: "abccba" → "aaccba" (replace first 'b' with 'a')

Input & Output

example_1.py — Basic Case

$ Input: palindrome = "abccba"

› Output: "aaccba"

💡 Note: We can change the first 'b' to 'a' to get "aaccba", which is not a palindrome and is lexicographically smallest among all possible changes.

example_2.py — All Same Characters

$ Input: palindrome = "aa"

› Output: "ab"

💡 Note: Since the first half contains only 'a', we change the last character from 'a' to 'b' to break the palindrome while keeping it lexicographically smallest.

example_3.py — Single Character

$ Input: palindrome = "a"

› Output: ""

💡 Note: It's impossible to break a single character palindrome by changing exactly one character, so we return an empty string.

Visualization

Tap to expand

Understanding the Visualization

Scan from Left

Start from the leftmost position to ensure lexicographically smallest result

Find First Non-'a'

Look for the first character that isn't 'a' in the first half

Change to 'a'

Replace it with 'a' to get the smallest possible character

Fallback Strategy

If first half is all 'a', change last character to 'b'

Key Takeaway

🎯 Key Insight: The greedy approach works because changing the leftmost non-'a' character to 'a' always produces the lexicographically smallest valid result. This leverages the palindrome property efficiently!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we try 26 letters and check if result is palindrome (O(n)), giving us O(n × 26 × n) = O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

We create new strings for each attempt, each taking O(n) space

⚡ Linearithmic Space

Constraints

1 ≤ palindrome.length ≤ 1000
palindrome consists of only lowercase English letters
palindrome is guaranteed to be a valid palindrome

Asked in

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

The optimal approach uses a greedy strategy: scan the first half of the palindrome from left to right, find the first character that's not 'a', and change it to 'a'. If all characters in the first half are 'a', change the last character to 'b'. This guarantees the lexicographically smallest non-palindrome in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possibilities)	O(n²)	O(n)	Try changing each character to every possible letter and find the lexicographically smallest non-palindrome
Greedy Approach (Optimal)	O(n)	O(n)	Start from left, change first non-'a' character to 'a', or change last character to 'b'

Brute Force (Try All Possibilities) — Algorithm Steps

Handle edge case: if string length is 1, return empty string
Initialize result as empty string
For each position i in the string:
For each letter 'a' to 'z':
Create new string with character at position i replaced
Check if new string is not a palindrome
If valid and lexicographically smaller than current result, update result
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Test replacing first character with 'a', 'b', 'c', ... 'z'

Check Palindrome

For each replacement, verify if result is non-palindrome

Track Best

Keep lexicographically smallest valid result

Continue

Repeat for all positions until exhausted

Code -

solution.c — C

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

int isPalindrome(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

char* breakPalindrome(char* palindrome) {
    int len = strlen(palindrome);
    if (len <= 1) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = malloc(len + 1);
    result[0] = '\0';
    
    for (int i = 0; i < len; i++) {
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != palindrome[i]) {
                char* newStr = malloc(len + 1);
                strcpy(newStr, palindrome);
                newStr[i] = c;
                
                if (!isPalindrome(newStr)) {
                    if (strlen(result) == 0 || strcmp(newStr, result) < 0) {
                        strcpy(result, newStr);
                    }
                }
                free(newStr);
            }
        }
    }
    
    return result;
}

int main() {
    char palindrome[1001];
    scanf("%s", palindrome);
    // Remove quotes
    int len = strlen(palindrome);
    memmove(palindrome, palindrome + 1, len - 2);
    palindrome[len - 2] = '\0';
    
    char* result = breakPalindrome(palindrome);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we try 26 letters and check if result is palindrome (O(n)), giving us O(n × 26 × n) = O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

We create new strings for each attempt, each taking O(n) space

⚡ Linearithmic Space

Constraints

1 ≤ palindrome.length ≤ 1000
palindrome consists of only lowercase English letters
palindrome is guaranteed to be a valid palindrome

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler