Longest Word With All Prefixes - Practice Coding Problems

Longest Word With All Prefixes - Problem

Find the longest word that can be built one character at a time!

Given an array of strings words, you need to find the longest string where every prefix of it also exists in the array. Think of it as building a word letter by letter, where each intermediate step must also be a valid word in your collection.

For example, with words = ["a", "app", "ap"]:
• The word "app" has prefixes "a" and "ap"
• Both prefixes exist in the original array
• So "app" is valid!

Special Rules:
• If multiple words have the same longest length, return the lexicographically smallest one
• If no valid word exists, return an empty string
• A word is considered its own prefix

Input & Output

example_1.py — Basic Case

$ Input: ["w","wo","wor","worl","world"]

› Output: "world"

💡 Note: The word "world" has all its prefixes ("w", "wo", "wor", "worl") present in the array, making it the longest valid word.

example_2.py — Lexicographic Tie

$ Input: ["a", "banana", "app", "appl", "ap", "apply", "apple"]

› Output: "apple"

💡 Note: Both "apple" and "apply" have length 5 and all prefixes present. "apple" comes first lexicographically.

example_3.py — No Valid Word

$ Input: ["abc", "bc", "ab", "qwe"]

› Output: ""

💡 Note: No word has all its prefixes in the array. For example, "abc" needs "a" and "ab", but "a" is missing.

Visualization

Tap to expand

Understanding the Visualization

Start Simple

Begin with single-letter words that exist in your array

Build Gradually

Add one letter at a time, ensuring each step creates a valid word

Track Progress

Keep building as long as intermediate results remain valid words

Find Longest

The longest word you can build following this rule is your answer

Key Takeaway

🎯 Key Insight: Use a Trie to naturally validate prefix chains - each path from root represents a buildable word sequence where every intermediate step is guaranteed to be a complete word.

Time & Space Complexity

Time Complexity

⏱️

O(n × m + result_length)

O(n × m) to build the Trie, plus O(result_length) for DFS traversal to find the longest path

✓ Linear Growth

Space Complexity

O(n × m × 26)

Trie can store up to n×m×26 nodes in worst case (each character can have 26 children)

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 30
words[i] consists of only lowercase English letters
All strings in words are unique

Asked in

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

The optimal solution uses a Trie data structure to efficiently build and validate word prefixes. Build the Trie from all words, then use DFS traversal following only complete word paths to find the longest valid word. This approach has O(n×m) time complexity and naturally handles prefix validation through the tree structure.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Set Approach	O(n × m²)	O(n × m)	Build a hash set of all words first, then check prefixes efficiently
Brute Force (Check All Prefixes)	O(n² × m)	O(1)	For each word, manually check if all its prefixes exist in the array
Trie-Based Solution (Optimal)	O(n × m + result_length)	O(n × m × 26)	Use a Trie data structure to efficiently build and validate words character by character

Two-Pass Hash Set Approach — Algorithm Steps

Create a hash set and add all words to it for fast lookup
Iterate through each word in the original array
For each word, generate all its prefixes
Check if each prefix exists in the hash set (O(1) operation)
Track the longest valid word, handling lexicographic ordering for ties

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

First pass: add all words to hash set for O(1) lookups

Select Word

Choose a word to validate from the array

Fast Lookup

Check each prefix against hash set instantly

Track Best

Update result if current word is longer/lexicographically smaller

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char* word;
    struct HashNode* next;
} HashNode;

unsigned int hash(char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

void insert(HashNode** table, char* word) {
    unsigned int index = hash(word);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->word = strdup(word);
    newNode->next = table[index];
    table[index] = newNode;
}

int contains(HashNode** table, char* word) {
    unsigned int index = hash(word);
    HashNode* current = table[index];
    while (current) {
        if (strcmp(current->word, word) == 0) {
            return 1;
        }
        current = current->next;
    }
    return 0;
}

char* longestWord(char** words, int wordsSize) {
    HashNode* table[HASH_SIZE] = {NULL};
    
    // Build hash table
    for (int i = 0; i < wordsSize; i++) {
        insert(table, words[i]);
    }
    
    char* result = (char*)malloc(1001 * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < wordsSize; i++) {
        int valid = 1;
        int len = strlen(words[i]);
        char prefix[1001];
        
        // Check all prefixes
        for (int j = 1; j < len; j++) {
            strncpy(prefix, words[i], j);
            prefix[j] = '\0';
            if (!contains(table, prefix)) {
                valid = 0;
                break;
            }
        }
        
        if (valid) {
            int wordLen = strlen(words[i]);
            int resultLen = strlen(result);
            if (wordLen > resultLen || (wordLen == resultLen && strcmp(words[i], result) < 0)) {
                strcpy(result, words[i]);
            }
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"w","wo","wor","worl","world"};
    int size = 5;
    printf("%s\n", longestWord(words, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m²)

For each of n words, we generate up to m prefixes, and each prefix check is now O(1) instead of O(n)

✓ Linear Growth

Space Complexity

O(n × m)

Hash set stores all n words, each potentially of length m

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 30
words[i] consists of only lowercase English letters
All strings in words are unique

42.0K Views

High Frequency

~15 min Avg. Time

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

Two-Pass Hash Set Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler