Shortest Unique Prefix Finder - Problem

Given a list of words, find the shortest prefix for each word that uniquely identifies it from all other words in the list.

A unique prefix is the minimum number of characters from the beginning of a word that makes it distinguishable from every other word in the list. If a word is a prefix of another word, the entire word itself is the shortest unique prefix.

Return an array of strings where each string is the shortest unique prefix for the corresponding word at the same index.

Input & Output

Example 1 — Basic Words

$ Input: words = ["cat", "car", "card", "dog"]

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

💡 Note: 'cat' needs full word to distinguish from 'car'/'card', 'car' needs full word to distinguish from 'card', 'card' needs full word, 'dog' only needs 'd' since no other word starts with 'd'

Example 2 — Prefix Overlaps

$ Input: words = ["apple", "app", "application"]

› Output: ["appl", "app", "appli"]

💡 Note: 'apple' needs 'appl' to distinguish from 'app'/'application', 'app' is complete word so needs full 'app', 'application' needs 'appli' to distinguish from others

Example 3 — Single Character Differences

$ Input: words = ["a", "aa", "aaa"]

› Output: ["a", "aa", "aaa"]

💡 Note: Each word is a prefix of the next, so each word needs its full length to be unique

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 200
words[i] consists of lowercase English letters
All words are distinct

Visualization

Tap to expand

Asked in

G Google 42 M Microsoft 38 a Amazon 35 f Facebook 28

The key insight is using a trie (prefix tree) with frequency counts to efficiently identify when a prefix becomes unique. The trie-based approach builds the tree once and finds all unique prefixes in a single traversal. Time: O(n×m), Space: O(n×m) where n is number of words and m is average word length.

Common Approaches

✓ Brute Force Comparison

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

For each word, start with prefix of length 1, then check if this prefix appears in any other word. If it does, increase prefix length and check again. Continue until we find a unique prefix or use the entire word.

Trie-Based Solution

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

Build a trie (prefix tree) where each node stores the count of words passing through it. Then traverse each word down the trie until we reach a node with count 1, indicating a unique prefix.

Brute Force Comparison — Algorithm Steps

For each word, start with prefix length 1
Check if current prefix matches the beginning of any other word
If collision found, increase prefix length by 1
Repeat until unique prefix found or entire word used

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with word

Take first word and try prefix length 1

Compare prefix

Check if this prefix appears in any other word

Extend or finish

If collision, try longer prefix. If unique, we're done

Code -

solution.c — C

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

char** solution(char** words, int wordsSize, int* returnSize) {
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    *returnSize = wordsSize;
    
    for (int i = 0; i < wordsSize; i++) {
        char* word = words[i];
        int wordLen = strlen(word);
        int prefixLen = 1;
        
        while (prefixLen <= wordLen) {
            int isUnique = 1;
            
            // Check against all other words
            for (int j = 0; j < wordsSize; j++) {
                if (i != j && strncmp(words[j], word, prefixLen) == 0) {
                    isUnique = 0;
                    break;
                }
            }
            
            if (isUnique) {
                result[i] = (char*)malloc((prefixLen + 1) * sizeof(char));
                strncpy(result[i], word, prefixLen);
                result[i][prefixLen] = '\0';
                break;
            }
            
            prefixLen++;
        }
        
        // If we've used the entire word and still not unique
        if (prefixLen > wordLen) {
            result[i] = (char*)malloc((wordLen + 1) * sizeof(char));
            strcpy(result[i], word);
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    char** words = (char**)malloc(100 * sizeof(char*));
    int wordsSize = 0;
    
    char* token = strtok(line + 1, ",]"); // Skip opening [
    while (token != NULL) {
        // Remove quotes and spaces
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"')) {
            token[len-1] = '\0';
            len--;
        }
        words[wordsSize] = (char*)malloc((len + 1) * sizeof(char));
        strcpy(words[wordsSize], token);
        wordsSize++;
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    char** result = solution(words, wordsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

For each of n words, we compare prefixes against all other n words, with average prefix length m

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

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

Shortest Unique Prefix Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler