Unique Word Abbreviation - Practice Coding Problems

Unique Word Abbreviation - Problem

Imagine you're building a smart text compression system that creates abbreviations for words. Your task is to implement a ValidWordAbbr class that can determine if a word's abbreviation is unique within a given dictionary.

📝 How Abbreviations Work:

Regular words: dog → d1g (first letter + count of middle letters + last letter)
Long words: internationalization → i18n (18 letters between 'i' and 'n')
Short words: it → it (words with ≤2 characters stay as-is)

🎯 Your Mission:

Build a system that returns true if a word's abbreviation is unique in the dictionary, meaning:

No collision: No other word in the dictionary has the same abbreviation, OR
Same word: Only the exact same word shares this abbreviation

Example: If dictionary contains ["deer", "door"], both have abbreviation d2r. So isUnique("dear") returns false (collision), but isUnique("deer") returns true (same word).

Input & Output

example_1.py — Basic Dictionary

$ Input: ValidWordAbbr(["deer", "door", "cake", "card"]) validator.isUnique("dear") validator.isUnique("cart") validator.isUnique("cane") validator.isUnique("make")

› Output: false false true true

💡 Note: "dear" → "d2r" conflicts with "deer" and "door". "cart" → "c2t" conflicts with "card" → "c2d" (different abbreviations but both start with c and end with different letters). "cane" → "c2e" conflicts with "cake", but wait - "cake" → "c2e" too! So "cane" is not unique. "make" → "m2e" has no conflicts.

example_2.py — Edge Cases

$ Input: ValidWordAbbr(["a", "aa"]) validator.isUnique("a") validator.isUnique("aa") validator.isUnique("aaa")

› Output: true true true

💡 Note: Short words (≤2 chars) keep original form: "a" → "a", "aa" → "aa", "aaa" → "a1a". Each has unique abbreviation.

example_3.py — Same Word Check

$ Input: ValidWordAbbr(["deer", "door", "deer"]) validator.isUnique("deer") validator.isUnique("door") validator.isUnique("dear")

› Output: false false false

💡 Note: Even though "deer" appears twice in dictionary, both "deer" and "door" map to "d2r", so neither is unique. "dear" also maps to "d2r" but isn't in the dictionary.

Visualization

Tap to expand

Understanding the Visualization

Build the catalog

Create index cards mapping each abbreviation to all books with that code

Handle new requests

When someone asks about a book code, instantly check the card catalog

Check for conflicts

If multiple different books share the same code, it's not unique

Return result

Only return 'unique' if no other books use this code, or if all books with this code are identical

Key Takeaway

🎯 Key Insight: By preprocessing the dictionary into a hash map grouped by abbreviations, we transform an O(n) search problem into an O(1) lookup problem, making the system highly efficient for repeated queries.

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) preprocessing + O(1) per query, where n = dictionary size, q = number of queries

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all dictionary words grouped by abbreviation

⚡ Linearithmic Space

Constraints

1 ≤ dictionary.length ≤ 3 × 10⁴
1 ≤ dictionary[i].length ≤ 20
dictionary[i] consists of lowercase English letters only
1 ≤ word.length ≤ 20
word consists of lowercase English letters only
At most 5000 calls will be made to isUnique

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses hash map preprocessing to achieve O(1) query time. During initialization, we build a hash map where keys are abbreviations and values are sets of words with that abbreviation. For each query, we simply check if the abbreviation exists and whether all words sharing it are identical to the query word.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n·m)	O(1)	Check every dictionary word's abbreviation against the query word
Hash Map Preprocessing (Optimal)	O(n + q)	O(n)	Precompute abbreviations into a hash map for O(1) lookups

Brute Force (Linear Search) — Algorithm Steps

Generate abbreviation for the query word
Iterate through all dictionary words
Generate abbreviation for each dictionary word
Count how many words share the same abbreviation
Return true only if no conflicts or all conflicts are the same word

Visualization

Tap to expand

Step-by-Step Walkthrough

Query arrives

Generate abbreviation for query word 'dear' → 'd2r'

Scan dictionary

Check each dictionary word: 'deer' → 'd2r', 'door' → 'd2r', 'cake' → 'c2e'

Find conflicts

Found 'd2r' matches with 'deer' and 'door' (both different from 'dear')

Return result

Since conflicts exist with different words, return false

Code -

solution.c — C

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

typedef struct {
    char** dictionary;
    int size;
} ValidWordAbbr;

char* abbreviate(const char* word) {
    int len = strlen(word);
    if (len <= 2) {
        char* result = malloc((len + 1) * sizeof(char));
        strcpy(result, word);
        return result;
    }
    
    char* result = malloc(20 * sizeof(char));
    sprintf(result, "%c%d%c", word[0], len - 2, word[len - 1]);
    return result;
}

ValidWordAbbr* createValidWordAbbr(char** dictionary, int size) {
    ValidWordAbbr* obj = malloc(sizeof(ValidWordAbbr));
    obj->dictionary = dictionary;
    obj->size = size;
    return obj;
}

int isUnique(ValidWordAbbr* obj, char* word) {
    char* abbr = abbreviate(word);
    
    for (int i = 0; i < obj->size; i++) {
        char* dictAbbr = abbreviate(obj->dictionary[i]);
        if (strcmp(dictAbbr, abbr) == 0 && strcmp(obj->dictionary[i], word) != 0) {
            free(abbr);
            free(dictAbbr);
            return 0;
        }
        free(dictAbbr);
    }
    
    free(abbr);
    return 1;
}

int main() {
    char* dictionary[] = {"deer", "door", "cake", "card"};
    ValidWordAbbr* validator = createValidWordAbbr(dictionary, 4);
    printf("%d\n", isUnique(validator, "dear")); // 0 (false)
    printf("%d\n", isUnique(validator, "cart")); // 0 (false)
    printf("%d\n", isUnique(validator, "cane")); // 1 (true)
    free(validator);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n·m)

n queries × m dictionary words, where each abbreviation calculation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only storing the input dictionary, no additional data structures

✓ Linear Space

Constraints

1 ≤ dictionary.length ≤ 3 × 10⁴
1 ≤ dictionary[i].length ≤ 20
dictionary[i] consists of lowercase English letters only
1 ≤ word.length ≤ 20
word consists of lowercase English letters only
At most 5000 calls will be made to isUnique

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

📝 How Abbreviations Work:

🎯 Your Mission:

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler