Prefix and Suffix Search - Practice Coding Problems

Prefix and Suffix Search - Problem

You need to design a smart dictionary that can quickly find words based on both their prefix (beginning) and suffix (ending). This is like having a super-powered search engine that can handle queries like "find me all words that start with 'app' and end with 'le'" (which would match 'apple').

Your task is to implement the WordFilter class with two methods:
• WordFilter(words) - Initialize with an array of dictionary words
• f(prefix, suffix) - Find the word that matches both conditions and return its largest index (most recent occurrence)

If multiple words match the criteria, return the one with the highest index. If no word matches, return -1.

Example: Given words ["apple", "application", "app"], searching for prefix="app" and suffix="le" should return index 0 ("apple").

Input & Output

example_1.py — Basic Usage

$ Input: WordFilter(["apple"]) f("a", "e")

› Output: 0

💡 Note: The word "apple" starts with "a" and ends with "e", so we return its index 0.

example_2.py — Multiple Matches

$ Input: WordFilter(["apple", "app", "application"]) f("app", "")

› Output: 2

💡 Note: All three words start with "app" and end with empty string, so we return the largest index 2 ("application").

example_3.py — No Match

$ Input: WordFilter(["apple", "banana"]) f("app", "na")

› Output: -1

💡 Note: No word starts with "app" AND ends with "na", so we return -1.

Constraints

1 ≤ words.length ≤ 10⁴
1 ≤ words[i].length ≤ 7
1 ≤ pref.length, suff.length ≤ 7
words[i], pref and suff consist of lowercase English letters only
At most 10⁴ calls will be made to f

Visualization

Tap to expand

Understanding the Visualization

Preprocess Words

For each word like 'apple', create all combinations: 'apple#', 'pple#a', 'ple#ap', 'le#app', 'e#appl', '#apple'

Build Trie

Insert all combinations into a trie structure, storing the maximum index at each node

Handle Queries

For query f('app', 'le'), search for 'le#app' in the trie

Return Result

Return the stored index from trie traversal, or -1 if path doesn't exist

Key Takeaway

🎯 Key Insight: Pre-computing all suffix#prefix combinations allows us to answer any prefix-suffix query in O(P+S) time, making this approach optimal for systems with many queries!

Asked in

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

The optimal approach uses a Trie with suffix-prefix combinations. For each word, we generate all possible suffix#prefix combinations and store them in a trie with the word's index. This transforms the complex prefix-suffix search into a simple trie lookup, achieving O(P+S) query time where P and S are the lengths of prefix and suffix.

Common Approaches

Approach	Time	Space	Notes
✓ Trie with Suffix-Prefix Combinations	O(N*M²) preprocessing, O(P+S) per query	O(N*M³)	Build a trie with all suffix#prefix combinations for instant lookup

Trie with Suffix-Prefix Combinations — Algorithm Steps

For each word, generate all suffix#prefix combinations
Insert each combination into a trie with the word's index
For queries, construct the suffix#prefix string
Search the trie and return the maximum index found
Return -1 if the combination doesn't exist in trie

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate combinations

For each word, create all suffix#prefix pairs

Insert into trie

Add each combination to trie with word index

Update max index

Each node stores the maximum index seen

Query trie

Search for suffix#prefix pattern in O(P+S) time

Code -

solution.c — C

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

#define MAX_CHILDREN 128

typedef struct TrieNode {
    struct TrieNode* children[MAX_CHILDREN];
    int index;
} TrieNode;

typedef struct {
    TrieNode* root;
} WordFilter;

TrieNode* createNode() {
    TrieNode* node = malloc(sizeof(TrieNode));
    for (int i = 0; i < MAX_CHILDREN; i++) {
        node->children[i] = NULL;
    }
    node->index = -1;
    return node;
}

void insert(TrieNode* root, char* word, int index) {
    TrieNode* node = root;
    for (int i = 0; word[i]; i++) {
        int idx = (int)word[i];
        if (!node->children[idx]) {
            node->children[idx] = createNode();
        }
        node = node->children[idx];
        node->index = index; // Keep updating to get max index
    }
}

WordFilter* wordFilterCreate(char** words, int wordsSize) {
    WordFilter* obj = malloc(sizeof(WordFilter));
    obj->root = createNode();
    
    for (int index = 0; index < wordsSize; index++) {
        char* word = words[index];
        int len = strlen(word);
        
        // Generate all suffix#prefix combinations
        for (int i = 0; i <= len; i++) {
            for (int j = 0; j <= len; j++) {
                char combination[2000];
                strcpy(combination, word + i); // suffix
                strcat(combination, "#");
                strncat(combination, word, j); // prefix
                insert(obj->root, combination, index);
            }
        }
    }
    
    return obj;
}

int wordFilterF(WordFilter* obj, char* pref, char* suff) {
    char searchStr[1000];
    strcpy(searchStr, suff);
    strcat(searchStr, "#");
    strcat(searchStr, pref);
    
    TrieNode* node = obj->root;
    for (int i = 0; searchStr[i]; i++) {
        int idx = (int)searchStr[i];
        if (!node->children[idx]) {
            return -1;
        }
        node = node->children[idx];
    }
    
    return node->index;
}

void wordFilterFree(WordFilter* obj) {
    // Should implement proper memory cleanup
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(N*M²) preprocessing, O(P+S) per query

N words × M² combinations for preprocessing, P+S for trie traversal per query

✓ Linear Growth

Space Complexity

O(N*M³)

Storing all suffix#prefix combinations in trie structure

✓ Linear Space

52.3K Views

Medium-High 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

Trie with Suffix-Prefix Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler