Shortest Palindrome - Practice Coding Problems

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
✓ Brute Force (Check All Positions)	O(n³)	O(n)	Try prepending characters at each position until a palindrome is formed
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) — Algorithm Steps

Start from the end of the string and work backwards
For each position i, take the suffix after position i
Reverse this suffix and prepend it to the original string
Check if the resulting string is a palindrome
Return the first valid palindrome found (shortest one)

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Prepend entire reverse and check if palindrome

Try Position 1

Prepend reverse of suffix from position 1

Continue Testing

Keep trying positions until palindrome found

Code -

solution.c — C

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

int isPalindrome(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 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;
    }
    
    for (int i = 0; i < len; i++) {
        char* suffix = malloc(len - i + 1);
        strcpy(suffix, s + i);
        reverseString(suffix);
        
        char* candidate = malloc(len + strlen(suffix) + 1);
        strcpy(candidate, suffix);
        strcat(candidate, s);
        
        if (isPalindrome(candidate)) {
            free(suffix);
            return candidate;
        }
        
        free(suffix);
        free(candidate);
    }
    
    char* result = malloc(len + 1);
    strcpy(result, s);
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    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³)

O(n) positions to try × O(n) to build each candidate × O(n) to check palindrome

⚠ Quadratic Growth

Space Complexity

O(n)

Space for creating candidate palindrome strings

⚡ 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

Brute Force (Check All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler