Shortest Palindrome

Shortest Palindrome - Problem

You are given a string s. You can convert s to a palindrome by adding characters in front of it. Return the shortest palindrome you can find by performing this transformation.

A palindrome is a string that reads the same forward and backward.

Input & Output

Example 1 — Basic Case

$ Input: s = "aacecaaa"

› Output: "aaacecaaa"

💡 Note: The optimal palindrome is "aaacecaaa" by adding "aa" to the front. The longest palindromic prefix is "aaceca", so we add the remaining "aa" (reversed) to the front.

Example 2 — Already Palindrome

$ Input: s = "abcd"

› Output: "dcbabcd"

💡 Note: Since "abcd" has no palindromic prefix except empty string, we need to add "dcb" (reverse of "bcd") to make it "dcbabcd".

Example 3 — Single Character

$ Input: s = "a"

› Output: "a"

💡 Note: A single character is already a palindrome, so no characters need to be added.

Constraints

0 ≤ s.length ≤ 5 × 10⁴
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to find the longest palindromic prefix and add only the necessary suffix characters (reversed) to the front. The optimal approach uses KMP algorithm with pattern s + '#' + reverse(s) to find the overlap in O(n) time. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Check

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

For each possible number of characters to add (0, 1, 2, ...), check if adding that many characters from the end (in reverse) creates a palindrome. Return the first valid palindrome found.

KMP Algorithm (Rolling Hash)

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

Create a string s + '#' + reverse(s) and use KMP's failure function to find the longest prefix of s that is also a suffix of reverse(s). This tells us exactly how many characters we need to add.

Two Pointers Optimization

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

Instead of checking every possible addition, find the longest prefix of the string that forms a palindrome when we consider the optimal suffix. Use two pointers to efficiently find where the palindrome property breaks.

Brute Force Check — Algorithm Steps

Step 1: Try adding 0, 1, 2, ... characters
Step 2: For each count, add reversed suffix to front
Step 3: Check if result is palindrome
Step 4: Return first palindrome found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try 0 chars

Check if original string is palindrome

Try 1 char

Add 1 character from end (reversed) to front

Try 2 chars

Add 2 characters from end (reversed) to front

Code -

solution.c — C

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

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

void reverse_string(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

char* solution(char* s) {
    int n = strlen(s);
    char* result = (char*)malloc(2 * n + 1);
    
    for (int i = 0; i < n; i++) {
        // Try adding i characters from the end (reversed) to the front
        char prefix[1001];
        strcpy(prefix, s + (n - i));
        reverse_string(prefix);
        
        strcpy(result, prefix);
        strcat(result, s);
        
        if (isPalindrome(result)) {
            return result;
        }
    }
    
    // Fallback: add entire string reversed except first char
    strcpy(result, s);
    reverse_string(result);
    result[n - 1] = '\0';
    strcat(result, s);
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Outer loop tries n positions, inner palindrome check is O(n), and string concatenation is O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

Creating new strings for each attempt

⚡ Linearithmic Space

89.4K Views

Medium Frequency

~25 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler