Longest Happy Prefix - Practice Coding Problems

Longest Happy Prefix - Problem

Imagine a string that has a special property: its beginning and end share the same pattern! 🎭

A "happy prefix" is a non-empty substring that appears at both the beginning (prefix) and end (suffix) of a string, but is not the entire string itself.

Your Mission: Given a string s, find the longest happy prefix and return it. If no such prefix exists, return an empty string "".

Example: In the string "ababab", the substring "abab" appears at both the beginning and end, making it a happy prefix!

Input & Output

example_1.py — Basic Happy Prefix

$ Input: s = "level"

› Output: "l"

💡 Note: The only happy prefix is "l" which appears at both beginning and end. Other prefixes like "le" don't match their corresponding suffixes.

example_2.py — Longer Happy Prefix

$ Input: s = "ababab"

› Output: "abab"

💡 Note: The longest happy prefix is "abab". Other happy prefixes include "ab" and "abab", but "abab" is the longest.

example_3.py — No Happy Prefix

$ Input: s = "leetcodeleet"

› Output: "leet"

💡 Note: The string starts and ends with "leet", making it the longest happy prefix.

Visualization

Tap to expand

Understanding the Visualization

Examine the Evidence

Look at the string and identify potential patterns

Check for Matches

Compare patterns from start with patterns at the end

Find the Longest

Among all matches, identify the longest one

Key Takeaway

🎯 Key Insight: The KMP failure function is perfectly designed for this problem - it computes exactly what we need: the longest proper prefix that is also a suffix!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build KMP failure function

✓ Linear Growth

Space Complexity

O(n)

Space for the failure function array

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Happy prefix must be non-empty and not equal to the entire string

Asked in

G Google 12 f Facebook 8 a Amazon 6 ⊞ Microsoft 4

The KMP algorithm provides the optimal O(n) solution by computing the failure function, which directly gives us the longest proper prefix that is also a suffix. The rolling hash approach offers another efficient O(n) solution, while the brute force method, though O(n³), is more intuitive for understanding the problem.

Common Approaches

Approach	Time	Space	Notes
✓ Rolling Hash (Two Pass)	O(n)	O(n)	Use rolling hash to efficiently compute and compare prefix/suffix hashes
Brute Force (Nested Loops)	O(n³)	O(n)	Check every possible prefix against every possible suffix
KMP Algorithm (Optimal)	O(n)	O(n)	Use KMP failure function to find longest proper prefix that is also suffix

Rolling Hash (Two Pass) — Algorithm Steps

Compute rolling hash for all prefixes (length 1 to n-1)
Store prefix hashes in a hash table with their lengths
Compute rolling hash for all suffixes (length 1 to n-1)
For each suffix hash, check if matching prefix hash exists
Return the longest matching prefix

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Prefix Hashes

Calculate rolling hash for each prefix and store in hash table

Compute Suffix Hashes

Calculate rolling hash for each suffix from right to left

Find Matches

Check if suffix hash matches any prefix hash of same length

Code -

solution.c — C

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

#define MOD 1000000007
#define BASE 256
#define HASH_SIZE 100003

typedef struct HashNode {
    long long hash;
    int length;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

void insertHash(long long hash, int length) {
    int index = hash % HASH_SIZE;
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->hash = hash;
    node->length = length;
    node->next = hashTable[index];
    hashTable[index] = node;
}

int findHash(long long hash) {
    int index = hash % HASH_SIZE;
    HashNode* node = hashTable[index];
    while (node) {
        if (node->hash == hash) return node->length;
        node = node->next;
    }
    return -1;
}

char* longestPrefix(char* s) {
    int n = strlen(s);
    if (n <= 1) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // First pass: compute prefix hashes
    long long hashVal = 0;
    for (int i = 0; i < n - 1; i++) {
        hashVal = (hashVal * BASE + s[i]) % MOD;
        insertHash(hashVal, i + 1);
    }
    
    // Second pass: compute suffix hashes and check matches
    hashVal = 0;
    long long power = 1;
    int maxLen = 0;
    
    for (int i = n - 1; i > 0; i--) {
        hashVal = (s[i] * power + hashVal) % MOD;
        power = (power * BASE) % MOD;
        int length = n - i;
        
        int prefixLen = findHash(hashVal);
        if (prefixLen == length && length > maxLen) {
            maxLen = length;
        }
    }
    
    char* result = (char*)malloc((maxLen + 1) * sizeof(char));
    strncpy(result, s, maxLen);
    result[maxLen] = '\0';
    return result;
}

int main() {
    char input[100001];
    fgets(input, sizeof(input), stdin);
    int len = strlen(input);
    if (input[len-1] == '\n') input[len-1] = '\0';
    char* s = input + 1;
    s[strlen(s)-1] = '\0';
    
    char* result = longestPrefix(s);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string, each taking O(n) time for rolling hash computation

✓ Linear Growth

Space Complexity

O(n)

Hash table to store prefix hashes and their lengths

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Happy prefix must be non-empty and not equal to the entire string

28.4K Views

Medium Frequency

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

Rolling Hash (Two Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler