Unique Word Abbreviation

Unique Word Abbreviation - Problem

The abbreviation of a word is a concatenation of its first letter, the number of characters between the first and last letter, and its last letter. If a word has only two characters, then it is an abbreviation of itself.

For example:

dog → d1g because there is one letter between the first letter 'd' and the last letter 'g'.
internationalization → i18n because there are 18 letters between the first letter 'i' and the last letter 'n'.
it → it because any word with only two characters is an abbreviation of itself.

Implement the ValidWordAbbr class:

ValidWordAbbr(String[] dictionary) Initializes the object with a dictionary of words.
boolean isUnique(string word) Returns true if either of the following conditions are met (otherwise returns false):

There is no word in dictionary whose abbreviation is equal to word's abbreviation.
For any word in dictionary whose abbreviation is equal to word's abbreviation, that word and word are the same.

Input & Output

Example 1 — Basic Dictionary Operations

$ Input: dictionary = ["deer", "door", "cake", "card"], operations = ["dear", "cart", "cane", "make"]

› Output: [false, true, false, true]

💡 Note: dear→d2r conflicts with deer and door. cart→c2t is unique. cane→c2e conflicts with cake. make→m2e is unique.

Example 2 — Word Matches Dictionary

$ Input: dictionary = ["hello", "world"], operations = ["hello", "hallo"]

› Output: [true, false]

💡 Note: hello is in dictionary with abbreviation h3o, so it's unique to itself. hallo→h3o conflicts with hello.

Example 3 — Short Words

$ Input: dictionary = ["it", "is"], operations = ["it", "at"]

› Output: [true, true]

💡 Note: Short words are their own abbreviations: it→it, is→is, at→at. All unique.

Constraints

1 ≤ dictionary.length ≤ 3 × 10⁴
1 ≤ dictionary[i].length ≤ 20
dictionary[i] consists of lowercase English letters
1 ≤ operations.length ≤ 5 × 10³
1 ≤ word.length ≤ 20
word consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to preprocess dictionary words by grouping them by their abbreviations using a hash map. For each query, check if the abbreviation exists and whether all words with that abbreviation match the query word. Best approach uses hash map preprocessing for O(1) queries. Time: O(1) per query, Space: O(n)

Common Approaches

✓ Brute Force - Check All Words Each Time

⏱️ Time: O(n) Space: O(1)

Generate abbreviation for query word, then check every dictionary word to see if it has same abbreviation but different spelling. Simple but inefficient for multiple queries.

Hash Map - Preprocess Abbreviations

⏱️ Time: O(1) Space: O(n)

During construction, generate abbreviations for all dictionary words and group them by abbreviation in a hash map. For queries, check if abbreviation exists and whether all words with that abbreviation are identical to query word.

Brute Force - Check All Words Each Time — Algorithm Steps

Step 1: Generate abbreviation for the query word
Step 2: Iterate through all dictionary words
Step 3: Check if any word has same abbreviation but different spelling

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Word

Generate abbreviation for query word

Check Dictionary

Compare with each dictionary word's abbreviation

Result

Return false if conflict found, true otherwise

Code -

solution.c — C

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

typedef struct {
    char dictionary[100][50];
    int size;
} ValidWordAbbr;

void getAbbr(const char* word, char* abbr) {
    int len = strlen(word);
    if (len <= 2) {
        strcpy(abbr, word);
        return;
    }
    sprintf(abbr, "%c%d%c", word[0], len - 2, word[len - 1]);
}

bool isUnique(ValidWordAbbr* obj, const char* word) {
    char abbr[20], dictAbbr[20];
    getAbbr(word, abbr);
    
    for (int i = 0; i < obj->size; i++) {
        getAbbr(obj->dictionary[i], dictAbbr);
        if (strcmp(dictAbbr, abbr) == 0 && strcmp(obj->dictionary[i], word) != 0) {
            return false;
        }
    }
    return true;
}

void parseStringArray(const char* str, char words[][50], int* count) {
    *count = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '"') {
            p++;
            int i = 0;
            while (*p && *p != '"' && i < 49) {
                words[*count][i++] = *p++;
            }
            words[*count][i] = '\0';
            (*count)++;
            if (*p == '"') p++;
        } else {
            p++;
        }
    }
}

int main() {
    ValidWordAbbr obj;
    obj.size = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* dictStart = strstr(line, "[");
    char* dictEnd = strchr(dictStart, ']');
    if (dictEnd) {
        char dictStr[500];
        int dictLen = dictEnd - dictStart + 1;
        strncpy(dictStr, dictStart, dictLen);
        dictStr[dictLen] = '\0';
        parseStringArray(dictStr, obj.dictionary, &obj.size);
    }
    
    fgets(line, sizeof(line), stdin);
    
    char operations[100][50];
    int opCount = 0;
    char* opStart = strstr(line, "[");
    char* opEnd = strchr(opStart, ']');
    if (opEnd) {
        char opStr[500];
        int opLen = opEnd - opStart + 1;
        strncpy(opStr, opStart, opLen);
        opStr[opLen] = '\0';
        parseStringArray(opStr, operations, &opCount);
    }
    
    bool results[100];
    for (int i = 0; i < opCount; i++) {
        results[i] = isUnique(&obj, operations[i]);
    }
    
    printf("[");
    for (int i = 0; i < opCount; i++) {
        printf("%s", results[i] ? "true" : "false");
        if (i < opCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each query checks all n dictionary words

✓ Linear Growth

Space Complexity

O(1)

Only stores input dictionary, no extra data structures

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 - Check All Words Each Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler