Minimum Unique Word Abbreviation - Practice Coding Problems

Minimum Unique Word Abbreviation - Problem

Find the shortest unique abbreviation for a target word!

You're given a target string and a dictionary of words. Your mission is to create the shortest possible abbreviation of the target that doesn't conflict with any word in the dictionary.

Abbreviation Rules:
• Replace any non-adjacent substrings with their lengths
• Example: "substitution" → "s10n" (replace middle 10 chars)
• Invalid: "s55n" (adjacent replacements)

Abbreviation Length: Count of remaining letters + count of replaced substrings
• "s10n" has length 3 (2 letters + 1 replacement)
• "su3i1u2on" has length 9 (6 letters + 3 replacements)

Your goal: Return the shortest abbreviation of target that uniquely identifies it from all dictionary words.

Input & Output

example_1.py — Basic Case

$ Input: target = "apple", dictionary = ["blade"]

› Output: "a4"

💡 Note: "apple" can be abbreviated as "a4" (a + 4 characters). Since "blade" has the same length but different pattern, "a4" uniquely identifies "apple".

example_2.py — Multiple Conflicts

$ Input: target = "apple", dictionary = ["plain", "amber", "blade"]

› Output: "1p3"

💡 Note: We need to avoid conflicts with all dictionary words. "1p3" represents (1 char + p + 3 chars) which uniquely identifies "apple" from the given words.

example_3.py — No Dictionary

$ Input: target = "apple", dictionary = []

› Output: "5"

💡 Note: When dictionary is empty, the shortest abbreviation is just the length of the target word, since there are no conflicts to avoid.

Visualization

Tap to expand

Understanding the Visualization

Analyze Conflicts

Check which existing plates could conflict with your desired word

Try Abbreviations

Start with shortest possible abbreviations and work up

Check Uniqueness

For each abbreviation, verify it doesn't match any existing plate pattern

Return First Valid

Return the first abbreviation that's unique among all existing plates

Key Takeaway

🎯 Key Insight: Use backtracking with pruning to find the shortest abbreviation that doesn't conflict with any dictionary word, similar to finding the shortest available license plate!

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m × n)

2^n abbreviations to generate, m dictionary words to check against, n characters per check

⚠ Quadratic Growth

Space Complexity

O(2^n)

Store all possible abbreviations before sorting

⚠ Quadratic Space

Constraints

1 ≤ target.length ≤ 21
0 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
target and dictionary[i] consist of lowercase English letters
Target and dictionary words contain only lowercase letters

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses backtracking with pruning to efficiently find the shortest unique abbreviation. Instead of generating all 2ⁿ possible abbreviations, we build them recursively and prune branches that cannot lead to better solutions. The key insight is using bit manipulation concepts within backtracking to represent which characters to keep versus abbreviate, while early termination dramatically reduces the search space in practice.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Abbreviations)	O(2^n × m × n)	O(2^n)	Generate all possible abbreviations and check uniqueness
Backtracking with Early Pruning	O(2^n × m × n)	O(n)	Use backtracking to find minimum length abbreviation efficiently

Brute Force (Generate All Abbreviations) — Algorithm Steps

Generate all possible abbreviations using bit manipulation (2^n possibilities)
Sort abbreviations by length (shortest first)
For each abbreviation, check if it conflicts with any dictionary word
Return the first abbreviation with no conflicts

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Masks

Create all possible bitmasks from 0 to 2^n-1

Create Abbreviations

For each mask, generate abbreviation (1=keep char, 0=count)

Sort by Length

Sort all abbreviations by length to try shortest first

Check Uniqueness

Return first abbreviation that doesn't match any dictionary word

Code -

solution.c — C

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

typedef struct {
    int length;
    char* abbrev;
} AbbrevPair;

char* abbreviate(char* word, int mask) {
    int len = strlen(word);
    char* result = malloc(len * 2);
    int pos = 0, i = 0;
    
    while (i < len) {
        if (mask & (1 << i)) {
            result[pos++] = word[i];
            i++;
        } else {
            int count = 0;
            while (i < len && !(mask & (1 << i))) {
                count++;
                i++;
            }
            pos += sprintf(result + pos, "%d", count);
        }
    }
    result[pos] = '\0';
    return result;
}

bool isAbbreviation(char* word, char* abbrev) {
    int i = 0, j = 0;
    int wordLen = strlen(word), abbrevLen = strlen(abbrev);
    
    while (i < wordLen && j < abbrevLen) {
        if (abbrev[j] >= '0' && abbrev[j] <= '9') {
            if (abbrev[j] == '0') return false;
            int num = 0;
            while (j < abbrevLen && abbrev[j] >= '0' && abbrev[j] <= '9') {
                num = num * 10 + (abbrev[j] - '0');
                j++;
            }
            i += num;
        } else {
            if (word[i] != abbrev[j]) return false;
            i++;
            j++;
        }
    }
    return i == wordLen && j == abbrevLen;
}

int compareAbbrev(const void* a, const void* b) {
    AbbrevPair* pairA = (AbbrevPair*)a;
    AbbrevPair* pairB = (AbbrevPair*)b;
    return pairA->length - pairB->length;
}

char* minAbbreviation(char* target, char** dictionary, int dictSize) {
    if (dictSize == 0) {
        char* result = malloc(10);
        sprintf(result, "%d", (int)strlen(target));
        return result;
    }
    
    int n = strlen(target);
    int totalAbbrevs = 1 << n;
    AbbrevPair* abbreviations = malloc(totalAbbrevs * sizeof(AbbrevPair));
    
    for (int mask = 0; mask < totalAbbrevs; mask++) {
        char* abbrev = abbreviate(target, mask);
        abbreviations[mask].length = strlen(abbrev);
        abbreviations[mask].abbrev = abbrev;
    }
    
    qsort(abbreviations, totalAbbrevs, sizeof(AbbrevPair), compareAbbrev);
    
    for (int i = 0; i < totalAbbrevs; i++) {
        char* abbrev = abbreviations[i].abbrev;
        bool valid = true;
        for (int j = 0; j < dictSize; j++) {
            if (strlen(dictionary[j]) == strlen(target) && isAbbreviation(dictionary[j], abbrev)) {
                valid = false;
                break;
            }
        }
        if (valid) {
            char* result = malloc(strlen(abbrev) + 1);
            strcpy(result, abbrev);
            // Free memory
            for (int k = 0; k < totalAbbrevs; k++) {
                free(abbreviations[k].abbrev);
            }
            free(abbreviations);
            return result;
        }
    }
    
    // Free memory
    for (int k = 0; k < totalAbbrevs; k++) {
        free(abbreviations[k].abbrev);
    }
    free(abbreviations);
    
    char* result = malloc(strlen(target) + 1);
    strcpy(result, target);
    return result;
}

int main() {
    printf("Implementation complete\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m × n)

2^n abbreviations to generate, m dictionary words to check against, n characters per check

⚠ Quadratic Growth

Space Complexity

O(2^n)

Store all possible abbreviations before sorting

⚠ Quadratic Space

Constraints

1 ≤ target.length ≤ 21
0 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
target and dictionary[i] consist of lowercase English letters
Target and dictionary words contain only lowercase letters

20.9K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Abbreviations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler