Prefix and Suffix Search

Prefix and Suffix Search - Problem

Design a special dictionary that searches words by both prefix and suffix. You need to implement the WordFilter class:

WordFilter(string[] words) - Initializes the object with the words in the dictionary.

f(string pref, string suff) - Returns the index of the word in the dictionary that has the prefix pref and the suffix suff. If there are multiple valid indices, return the largest one. If no such word exists, return -1.

Input & Output

Example 1 — Basic Prefix-Suffix Search

$ Input: words = ["apple", "application", "apply"], queries = [["ap", "e"]]

› Output: [0]

💡 Note: Only 'apple' starts with 'ap' and ends with 'e', so return its index 0

Example 2 — Multiple Matches

$ Input: words = ["cat", "bat", "rat"], queries = [["a", "t"]]

› Output: [-1]

💡 Note: None of the words start with 'a' and end with 't', so return -1

Example 3 — No Match

$ Input: words = ["hello", "world"], queries = [["he", "d"]]

› Output: [-1]

💡 Note: No word starts with 'he' and ends with 'd', so return -1

Constraints

1 ≤ words.length ≤ 10⁴
1 ≤ words[i].length ≤ 7
1 ≤ pref.length, suff.length ≤ 7

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

This problem requires efficient prefix and suffix matching in a dictionary. The key insight is to preprocess the data structure during initialization for fast queries. The optimal approach uses a Trie with suffix wrapping or Hash Map with all combinations. Time: O(n×m²) preprocessing + O(1) or O(p+s) per query, Space: O(n×m²)

Common Approaches

✓ Brute Force - Check Every Word

⏱️ Time: O(q*n*m) Space: O(n*m)

For each search query, we iterate through all words in the dictionary and check if each word starts with the given prefix and ends with the given suffix. Return the largest index that matches both conditions.

Hash Map - Preprocess All Combinations

⏱️ Time: O(n*m²) + O(q) Space: O(n*m²)

During initialization, we generate all possible prefix and suffix combinations for each word and store them in a hash map with their corresponding indices. For queries, we simply look up the combination in O(1) time.

Trie with Suffix Wrapping

⏱️ Time: O(n*m²) + O(p+s) Space: O(n*m²)

We create modified words by appending each word's suffixes to its beginning, separated by a special character. Store these in a Trie. For queries, we search for the pattern pref + '#' + suff in the Trie.

Brute Force - Check Every Word — Algorithm Steps

Step 1: Store all words in an array
Step 2: For each query, iterate through all words
Step 3: Check if word starts with prefix and ends with suffix
Step 4: Track the largest valid index

Visualization

Tap to expand

Step-by-Step Walkthrough

Check apple

startsWith('ap') ✓ and endsWith('e') ✓

Check application

startsWith('ap') ✓ but endsWith('e') ✗

Result

Return index 0 (apple matches both conditions)

Code -

solution.c — C

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

int startsWith(const char* word, const char* prefix) {
    return strncmp(word, prefix, strlen(prefix)) == 0;
}

int endsWith(const char* word, const char* suffix) {
    int wordLen = strlen(word);
    int suffLen = strlen(suffix);
    if (suffLen > wordLen) return 0;
    return strcmp(word + wordLen - suffLen, suffix) == 0;
}

int f(char** words, int wordCount, const char* pref, const char* suff) {
    int result = -1;
    for (int i = 0; i < wordCount; i++) {
        if (startsWith(words[i], pref) && endsWith(words[i], suff)) {
            result = i;
        }
    }
    return result;
}

// Remove leading/trailing whitespace and quotes
void trimQuotes(char* s) {
    int len = strlen(s);
    while (len > 0 && (s[len-1] == ' ' || s[len-1] == '\n' || s[len-1] == '\r' || s[len-1] == '"')) {
        s[--len] = '\0';
    }
    char* start = s;
    while (*start == ' ' || *start == '"') start++;
    if (start != s) memmove(s, start, strlen(start) + 1);
}

// Parse a JSON-like array of strings: ["apple","application","apply"]
int parseWords(char* line, char*** outWords) {
    int capacity = 100;
    char** words = malloc(capacity * sizeof(char*));
    int count = 0;

    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;

    while (*p) {
        while (*p && (*p == ' ' || *p == ',')) p++;
        if (*p == ']' || *p == '\0') break;

        if (*p == '"') {
            p++;
            char* start = p;
            while (*p && *p != '"') p++;
            int len = p - start;
            words[count] = malloc(len + 1);
            strncpy(words[count], start, len);
            words[count][len] = '\0';
            count++;
            if (*p == '"') p++;
        } else {
            char* start = p;
            while (*p && *p != ',' && *p != ']') p++;
            int len = p - start;
            words[count] = malloc(len + 1);
            strncpy(words[count], start, len);
            words[count][len] = '\0';
            trimQuotes(words[count]);
            count++;
        }
    }

    *outWords = words;
    return count;
}

// Parse queries: [["ap","e"]] or line by line
int parseQueries(char* line, char*** prefs, char*** suffs) {
    int capacity = 100;
    *prefs = malloc(capacity * sizeof(char*));
    *suffs = malloc(capacity * sizeof(char*));
    int count = 0;

    char* p = line;
    // Find pairs of strings
    while (*p) {
        // Find opening [ of a pair
        char* bracket = strchr(p, '[');
        if (!bracket) break;
        p = bracket + 1;

        // Find first quoted string
        char* q1 = strchr(p, '"');
        if (!q1) break;
        q1++;
        char* q1end = strchr(q1, '"');
        if (!q1end) break;

        int len1 = q1end - q1;
        (*prefs)[count] = malloc(len1 + 1);
        strncpy((*prefs)[count], q1, len1);
        (*prefs)[count][len1] = '\0';

        p = q1end + 1;

        // Find second quoted string
        char* q2 = strchr(p, '"');
        if (!q2) break;
        q2++;
        char* q2end = strchr(q2, '"');
        if (!q2end) break;

        int len2 = q2end - q2;
        (*suffs)[count] = malloc(len2 + 1);
        strncpy((*suffs)[count], q2, len2);
        (*suffs)[count][len2] = '\0';

        p = q2end + 1;
        count++;
    }

    return count;
}

int main() {
    char line1[100000];
    char line2[100000];

    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);

    char** words;
    int wordCount = parseWords(line1, &words);

    char** prefs;
    char** suffs;
    int queryCount = parseQueries(line2, &prefs, &suffs);

    printf("[");
    for (int i = 0; i < queryCount; i++) {
        if (i > 0) printf(",");
        printf("%d", f(words, wordCount, prefs[i], suffs[i]));
    }
    printf("]\n");

    for (int i = 0; i < wordCount; i++) free(words[i]);
    free(words);
    for (int i = 0; i < queryCount; i++) {
        free(prefs[i]);
        free(suffs[i]);
    }
    free(prefs);
    free(suffs);

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q*n*m)

q queries, each checks n words, each check takes O(m) time for string comparison

✓ Linear Growth

Space Complexity

O(n*m)

Store all words in memory, total space proportional to all characters

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Word — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler