Auto-Complete System - Problem

Design and implement an auto-complete system that suggests words based on a given prefix from a dictionary of words.

You need to implement a class AutoComplete with the following methods:

AutoComplete(dictionary) - Initialize the system with a list of words
search(prefix) - Return all words that start with the given prefix, sorted alphabetically

The system should efficiently handle multiple search queries and return results in lexicographical order.

Input & Output

Example 1 — Basic Auto-Complete

$ Input: dictionary = ["apple", "app", "application", "apply", "car", "card", "care"], prefix = "app"

› Output: ["app", "apple", "application", "apply"]

💡 Note: All words starting with 'app' are: app, apple, application, apply. They are returned in alphabetical order.

Example 2 — Single Character Prefix

$ Input: dictionary = ["cat", "car", "card", "dog", "door"], prefix = "c"

› Output: ["car", "card", "cat"]

💡 Note: Words starting with 'c' are: car, card, cat (sorted alphabetically).

Example 3 — No Matches

$ Input: dictionary = ["hello", "world", "test"], prefix = "xyz"

› Output: []

💡 Note: No words in the dictionary start with 'xyz', so return empty array.

Constraints

1 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
1 ≤ prefix.length ≤ 100
dictionary[i] and prefix consist only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using a Trie (prefix tree) data structure to efficiently store and search words by prefix. The optimal approach builds a trie from the dictionary, then traverses it to find all words with the given prefix. Time: O(p + k), Space: O(n × m).

Common Approaches

✓ Linear Search Through Dictionary

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

For each search query, iterate through the entire dictionary and check if each word starts with the given prefix. Collect matching words and sort them before returning.

Trie (Prefix Tree) Data Structure

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

Construct a trie (prefix tree) where each node represents a character and paths from root to leaf spell out words. This allows efficient prefix-based searches by traversing the tree.

Linear Search Through Dictionary — Algorithm Steps

Iterate through all words in dictionary
Check if each word starts with the given prefix
Collect matching words in a list
Sort the results alphabetically
Return sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

Begin checking each word in dictionary

Check Prefix

Compare prefix with start of each word

Collect Matches

Add matching words to result list

Sort Results

Sort collected words alphabetically

Code -

solution.c — C

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

int solution(char dictionary[][100], int dictSize, char* prefix, char result[][100]) {
    int count = 0;
    int prefixLen = strlen(prefix);
    
    for (int i = 0; i < dictSize; i++) {
        if (strncmp(dictionary[i], prefix, prefixLen) == 0) {
            strcpy(result[count++], dictionary[i]);
        }
    }
    
    // Sort results
    for (int i = 0; i < count - 1; i++) {
        for (int j = i + 1; j < count; j++) {
            if (strcmp(result[i], result[j]) > 0) {
                char temp[100];
                strcpy(temp, result[i]);
                strcpy(result[i], result[j]);
                strcpy(result[j], temp);
            }
        }
    }
    
    return count;
}

int main() {
    char dictionary[1000][100];
    char result[1000][100];
    char prefix[100];
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    // Parse JSON array manually
    int dictSize = 0;
    char* token = strtok(line, "[\"]}");
    while (token != NULL && dictSize < 1000) {
        if (strlen(token) > 0 && strcmp(token, ",") != 0) {
            strcpy(dictionary[dictSize++], token);
        }
        token = strtok(NULL, "\",");
    }
    
    fgets(prefix, sizeof(prefix), stdin);
    prefix[strcspn(prefix, "\n")] = 0;
    
    int count = solution(dictionary, dictSize, prefix, result);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("\"%s\"", result[i]);
        if (i < count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each query, we check n words, each taking O(m) time for prefix comparison

✓ Linear Growth

Space Complexity

O(k)

We store k matching words in the result list

✓ Linear Space

52.0K Views

High Frequency

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

Auto-Complete System - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search Through Dictionary — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler