Codestin Search App

Shortest Palindrome - Problem

You are given a string s and your goal is to create the shortest possible palindrome by adding characters only to the beginning of the string.

A palindrome reads the same forwards and backwards (like "racecar" or "madam"). Your task is to find the minimum number of characters needed to prepend to make the entire string a palindrome.

Example: Given s = "aacecaaa", you can prepend "aaacecaa" to get "aaacecaaaacecaaa", but the optimal solution is to prepend "aa" to get "aaaacecaaa".

The key insight is finding the longest prefix of s that is also a suffix of reverse(s).

Input & Output

example_1.py — Basic Case

$ Input: s = "aacecaaa"

› Output: "aaacecaaa"

💡 Note: We need to find the shortest palindrome by prepending characters. The optimal solution prepends "aa" to get "aaacecaaa", which reads the same forwards and backwards.

example_2.py — Single Character

$ Input: s = "abcd"

› Output: "dcbabcd"

💡 Note: Since no prefix of "abcd" forms a palindrome with any suffix, we need to prepend the reverse of "bcd" which is "dcb", resulting in "dcbabcd".

example_3.py — Already Palindrome

$ Input: s = "racecar"

› Output: "racecar"

💡 Note: The string is already a palindrome, so no characters need to be prepended. The result is the original string.

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Find how much of the original already acts as a 'mirror'

Calculate Missing Pieces

Determine what needs to be added to complete the reflection

Construct Solution

Add the minimal required pieces to create perfect symmetry

Key Takeaway

🎯 Key Insight: Use KMP algorithm to find the optimal split point where the string overlaps with its reverse, minimizing the characters needed to prepend.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build LPS array using KMP algorithm

✓ Linear Growth

Space Complexity

O(n)

Space for the combined string and LPS array

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 5 × 10⁴
s consists of lowercase English letters only
Goal: Find the shortest possible palindrome by prepending characters

Asked in

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

The optimal solution uses the KMP algorithm to find the longest prefix that matches a suffix in the combined string. By creating s + '#' + reverse(s) and finding the LPS array, we can determine exactly how many characters to prepend in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ KMP Pattern Matching (Optimal)	O(n)	O(n)	Use KMP algorithm to find the longest proper prefix that is also a suffix
Brute Force (Check All Positions)	O(n³)	O(n)	Try prepending characters at each position until a palindrome is formed

KMP Pattern Matching (Optimal) — Algorithm Steps

Create a new string: original + separator + reverse(original)
Build the KMP failure function (LPS array) for this combined string
The last value in the LPS array tells us the length of overlap
Prepend the non-overlapping part of the reverse to form the shortest palindrome

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Combined String

Combine s + '#' + reverse(s)

Build LPS Array

Find longest proper prefix which is also suffix

Extract Overlap

Last LPS value gives us the overlap length

Code -

solution.c — C

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

int* buildLPS(char* pattern, int len) {
    int* lps = (int*)calloc(len, sizeof(int));
    int length = 0;
    int i = 1;
    
    while (i < len) {
        if (pattern[i] == pattern[length]) {
            length++;
            lps[i] = length;
            i++;
        } else {
            if (length != 0) {
                length = lps[length - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

void reverseString(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* shortestPalindrome(char* s) {
    int len = strlen(s);
    if (len == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Create combined string
    char* reversed = malloc(len + 1);
    strcpy(reversed, s);
    reverseString(reversed);
    
    int combinedLen = 2 * len + 1;
    char* combined = malloc(combinedLen + 1);
    sprintf(combined, "%s#%s", s, reversed);
    
    int* lps = buildLPS(combined, combinedLen);
    int overlap = lps[combinedLen - 1];
    
    // Create result
    char* toAdd = malloc(len - overlap + 1);
    strcpy(toAdd, s + overlap);
    reverseString(toAdd);
    
    char* result = malloc(len + strlen(toAdd) + 1);
    sprintf(result, "%s%s", toAdd, s);
    
    free(reversed);
    free(combined);
    free(lps);
    free(toAdd);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build LPS array using KMP algorithm

✓ Linear Growth

Space Complexity

O(n)

Space for the combined string and LPS array

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 5 × 10⁴
s consists of lowercase English letters only
Goal: Find the shortest possible palindrome by prepending characters

58.0K Views

Medium-High Frequency

~35 min Avg. Time

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

KMP Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler