Shortest Completing Word

Shortest Completing Word - Problem

Given a string licensePlate and an array of strings words, find the shortest completing word in words.

A completing word is a word that contains all the letters in licensePlate. Ignore numbers and spaces in licensePlate, and treat letters as case insensitive.

If a letter appears more than once in licensePlate, then it must appear in the word the same number of times or more.

For example, if licensePlate = "aBc 12c", then it contains letters 'a', 'b' (ignoring case), and 'c' twice. Possible completing words are "abccdef", "caaacab", and "cbca".

Return the shortest completing word in words. It is guaranteed an answer exists. If there are multiple shortest completing words, return the first one that occurs in words.

Input & Output

Example 1 — Basic Case

$ Input: licensePlate = "1s3 PSt", words = ["step", "steps", "stripe", "stepple"]

› Output: "step"

💡 Note: The license plate contains letters 's', 'p', 't' (ignoring case and numbers). "step" has s:1, t:1, e:1, p:1 which covers all requirements and has length 4. "steps" also works but has length 5. "stripe" and "stepple" are longer, so "step" is the shortest completing word.

Example 2 — Multiple Same Letters

$ Input: licensePlate = "1s3 333", words = ["S", "sss", "look"]

› Output: "S"

💡 Note: The license plate contains only 's' (once). "S" has s:1 which satisfies the requirement and has length 1. "sss" also works but has length 3. "look" doesn't contain 's'. So "S" is the shortest completing word.

Example 3 — Case Sensitivity

$ Input: licensePlate = "Ah71752", words = ["suggest", "letter", "of", "husband", "easy", "education", "drug", "prevent", "writer", "old"]

› Output: "husband"

💡 Note: The license plate contains 'A' and 'h' (case insensitive, so 'a' and 'h'). "husband" contains both 'a' and 'h', and among valid words, it appears first in the array with reasonable length.

Constraints

1 ≤ licensePlate.length ≤ 7
1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 15
licensePlate consists of digits, letters, and spaces
words[i] consists of lowercase English letters

Visualization

Tap to expand

Asked in

A Amazon 25 M Microsoft 18 G Google 15

The key insight is to use frequency counting to efficiently match letter requirements. Extract letters from the license plate, build frequency maps for comparison, and find the shortest word that contains all required letters with correct counts. Best approach uses frequency maps with Time: O(n × m), Space: O(k).

Common Approaches

✓ Brute Force Character Counting

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

Extract letters from license plate, then for each word check if it contains all required letters with correct frequencies by counting characters one by one.

Frequency Map Approach

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

Create frequency maps for the license plate letters and each word, then compare frequency maps to check if a word is completing. This avoids repeated character counting.

Brute Force Character Counting — Algorithm Steps

Extract letters from license plate
For each word, count all characters
Check if word satisfies all letter requirements
Track shortest valid word

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Letters

Get letters from license plate: a, b, c, c

Check Each Word

Count characters manually in each word

Find Shortest

Return shortest word that satisfies requirements

Code -

solution.c — C

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

int myStrlen(char* str) {
    int len = 0;
    while (str[len] != '\0') {
        len++;
    }
    return len;
}

char myToLower(char ch) {
    if (ch >= 'A' && ch <= 'Z') {
        return ch + ('a' - 'A');
    }
    return ch;
}

int myIsAlpha(char ch) {
    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
}

void countCharacters(char* str, int* freq) {
    for (int i = 0; i < 26; i++) {
        freq[i] = 0;
    }
    
    int i = 0;
    while (str[i] != '\0') {
        if (myIsAlpha(str[i])) {
            char ch = myToLower(str[i]);
            freq[ch - 'a']++;
        }
        i++;
    }
}

int isCompletingWord(int* plateFreq, int* wordFreq) {
    for (int i = 0; i < 26; i++) {
        if (wordFreq[i] < plateFreq[i]) {
            return 0;
        }
    }
    return 1;
}

char* solution(char* licensePlate, char** words, int wordsSize) {
    int plateFreq[26];
    int wordFreq[26];
    
    countCharacters(licensePlate, plateFreq);
    
    char* result = NULL;
    int minLength = 1000000;
    
    for (int i = 0; i < wordsSize; i++) {
        countCharacters(words[i], wordFreq);
        
        if (isCompletingWord(plateFreq, wordFreq)) {
            int currentLength = myStrlen(words[i]);
            
            if (currentLength < minLength) {
                minLength = currentLength;
                result = words[i];
            }
        }
    }
    
    return result;
}

int main() {
    char line1[100000];
    char line2[100000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    
    int len = myStrlen(line1);
    if (len > 0 && line1[len - 1] == '\n') {
        line1[len - 1] = '\0';
    }
    
    len = myStrlen(line2);
    if (len > 0 && line2[len - 1] == '\n') {
        line2[len - 1] = '\0';
    }
    
    char** words = (char**)malloc(1000 * sizeof(char*));
    for (int i = 0; i < 1000; i++) {
        words[i] = (char*)malloc(100 * sizeof(char));
    }
    int wordsSize = 0;
    
    char* ptr = line2;
    int inWord = 0;
    int wordIdx = 0;
    
    while (*ptr) {
        if (*ptr == '"') {
            if (!inWord) {
                inWord = 1;
                wordIdx = 0;
            } else {
                words[wordsSize][wordIdx] = '\0';
                wordsSize++;
                inWord = 0;
            }
        } else if (inWord) {
            words[wordsSize][wordIdx++] = *ptr;
        }
        ptr++;
    }
    
    char* result = solution(line1, words, wordsSize);
    
    printf("%s\n", result);
    
    for (int i = 0; i < 1000; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n words, each with m characters, k comparisons for license plate letters

✓ Linear Growth

Space Complexity

O(1)

Only variables for counting, no extra data structures

✓ Linear Space

25.0K Views

Medium Frequency

~15 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 Character Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler