Search Suggestions System

Search Suggestions System - Problem

Array String Binary Search Trie Sorting Heap (Priority Queue) Medium

You are given an array of strings products and a string searchWord. Design a system that suggests at most three product names from products after each character of searchWord is typed.

Suggested products should have common prefix with searchWord. If there are more than three products with a common prefix, return the three lexicographically minimum products.

Return a list of lists of the suggested products after each character of searchWord is typed.

Input & Output

Example 1 — Basic Case

$ Input: products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"

› Output: [["mobile","moneypot","monitor"],["mobile","moneypot","monitor"],["mouse","mousepad"],["mouse","mousepad"],["mouse","mousepad"]]

💡 Note: Typing 'm': products starting with 'm' are ["mobile","moneypot","monitor","mouse","mousepad"], first 3 lexicographically are ["mobile","moneypot","monitor"]. Typing 'mo': same products match 'mo' prefix, so same result ["mobile","moneypot","monitor"]. Typing 'mou': only ["mouse","mousepad"] match, so return ["mouse","mousepad"]. For 'mous' and 'mouse': same result ["mouse","mousepad"].

Example 2 — No Matches

$ Input: products = ["havana"], searchWord = "havana"

› Output: [["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]

💡 Note: Each character of 'havana' matches the product 'havana', so we return ['havana'] for each prefix.

Example 3 — Empty Results

$ Input: products = ["bags","baggage","banner","box","cloths"], searchWord = "bags"

› Output: [["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]

💡 Note: Typing 'b': ['baggage','bags','banner']. 'ba': ['baggage','bags','banner']. 'bag': ['baggage','bags']. 'bags': ['bags'].

Constraints

1 ≤ products.length ≤ 1000
1 ≤ products[i].length ≤ 3000
1 ≤ searchWord.length ≤ 1000
products[i] and searchWord consist of lowercase English letters only

Visualization

Tap to expand

Asked in

a Amazon 85 M Microsoft 45 G Google 30 🍎 Apple 25

The key insight is to sort products first to enable efficient prefix matching. The optimal approach uses two pointers to maintain a sliding window of matching products as we extend the search prefix character by character. Time: O(n log n + m × 3), Space: O(1)

Common Approaches

✓ Brute Force - Filter and Sort for Each Prefix

⏱️ Time: O(n × m × k × log k) Space: O(k)

For each prefix of searchWord, iterate through all products to find those that start with the current prefix. Sort the matching products lexicographically and take the first 3.

Sort First - Optimized Filtering

⏱️ Time: O(n log n + m × n) Space: O(1)

First sort all products lexicographically. Then for each prefix, use binary search to find the first product that matches the prefix, and take the next 3 products that also match.

Two Pointers - Optimized Range Tracking

⏱️ Time: O(n log n + m × 3) Space: O(1)

After sorting products, use two pointers to maintain a window of products that match the current prefix. As we add each character, narrow down this window by moving the pointers inward.

Brute Force - Filter and Sort for Each Prefix — Algorithm Steps

Step 1: For each character position in searchWord, build the current prefix
Step 2: Scan all products to find those starting with this prefix
Step 3: Sort matching products and take first 3
Step 4: Add these 3 suggestions to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Type 'm'

Find products starting with 'm', sort them

Type 'mo'

Find products starting with 'mo', sort them

Continue

Repeat for each character in searchWord

Code -

solution.c — C

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

static char products_storage[1000][3001];
static char* products[1000];
static char* matches[1000];
static char*** result;
static int* returnColumnSizes;

int compare(const void *a, const void *b) {
    return strcmp(*(char**)a, *(char**)b);
}

char*** solution(char** products, int productsSize, char* searchWord, int* returnSize, int** returnColumnSizes) {
    int wordLen = strlen(searchWord);
    *returnSize = wordLen;
    *returnColumnSizes = (int*)malloc(wordLen * sizeof(int));
    char*** result = (char***)malloc(wordLen * sizeof(char**));
    
    for (int i = 0; i < wordLen; i++) {
        int matchCount = 0;
        
        for (int j = 0; j < productsSize; j++) {
            if (strncmp(products[j], searchWord, i + 1) == 0) {
                matches[matchCount] = products[j];
                matchCount++;
            }
        }
        
        qsort(matches, matchCount, sizeof(char*), compare);
        
        int topCount = matchCount < 3 ? matchCount : 3;
        (*returnColumnSizes)[i] = topCount;
        result[i] = (char**)malloc(topCount * sizeof(char*));
        
        for (int k = 0; k < topCount; k++) {
            result[i][k] = matches[k];
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int productsSize = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* p = line;
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        
        while (*p && *p != ']') {
            while (*p && (*p == ' ' || *p == ',' || *p == '"')) p++;
            if (*p == ']' || *p == '\0') break;
            
            char* start = p;
            while (*p && *p != '"' && *p != ',' && *p != ']') p++;
            int len = p - start;
            
            strncpy(products_storage[productsSize], start, len);
            products_storage[productsSize][len] = '\0';
            products[productsSize] = products_storage[productsSize];
            productsSize++;
            
            while (*p && *p != ',' && *p != ']') p++;
        }
    }
    
    char searchWord[1001];
    fgets(searchWord, sizeof(searchWord), stdin);
    searchWord[strcspn(searchWord, "\n")] = 0;
    
    int returnSize;
    char*** result = solution(products, productsSize, searchWord, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("\"%s\"", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k × log k)

For each of m characters, we scan n products (k avg length), sort matches

⚡ Linearithmic

Space Complexity

O(k)

Temporary array to store matching products for each prefix

✓ Linear Space

127.0K Views

High Frequency

~15 min Avg. Time

2.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

Brute Force - Filter and Sort for Each Prefix — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler