Word Abbreviation - Practice Coding Problems

Word Abbreviation - Problem

Array String Greedy Trie Sorting Hard

Given an array of distinct strings words, return the minimal possible abbreviations for every word.

The following are the rules for a string abbreviation:

The initial abbreviation for each word is: the first character, then the number of characters in between, followed by the last character.
If more than one word shares the same abbreviation, then perform the following operation: Increase the prefix (characters in the first part) of each of their abbreviations by 1.
This operation is repeated until every abbreviation is unique.
At the end, if an abbreviation did not make a word shorter, then keep it as the original word.

Example: For words ["abcdef","abndef"], both initially abbreviated as "a4f". The sequence would be ["a4f","a4f"] → ["ab3f","ab3f"] → ["abc2f","abn2f"].

Input & Output

Example 1 — Basic Conflict Resolution

$ Input: words = ["like", "god", "internal", "me", "internet", "interval", "intension", "face", "intrusion"]

› Output: ["l2e","god","internal","me","i6t","interval","inte4n","f2e","intr4n"]

💡 Note: Words with conflicts need longer prefixes: 'internal', 'internet', 'interval', 'intension', 'intrusion' all start with 'i', so they need different prefix lengths to become unique.

Example 2 — Simple Case

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

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

💡 Note: Both words are too short to abbreviate meaningfully, so they remain unchanged.

Example 3 — No Conflicts

$ Input: words = ["word", "test", "sample"]

› Output: ["w2d","t2t","s4e"]

💡 Note: All words have different first characters, so simple abbreviation with 1-character prefix works for all.

Constraints

1 ≤ words.length ≤ 400
2 ≤ words[i].length ≤ 400
words[i] consists of lowercase English letters
All the strings of words are unique

Visualization

Tap to expand

Understanding the Visualization

Input Words

Array of distinct strings

Find Conflicts

Identify words with same initial abbreviation

Resolve Conflicts

Extend prefixes until all abbreviations are unique

Key Takeaway

🎯 Key Insight: Extend prefixes incrementally only for conflicting words to achieve minimal unique abbreviations

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to incrementally extend prefixes only for conflicting abbreviations until all become unique. The optimal approach uses a trie structure to efficiently find minimal unique prefixes in O(n × m) time and space.

Common Approaches

Approach	Time	Space	Notes
✓ Trie-based Approach	O(n × m)	O(n × m)	Use a trie to efficiently find minimal unique prefixes for each word
Brute Force Simulation	O(n² × m)	O(n × m)	Simulate the abbreviation process by repeatedly checking conflicts and extending prefixes

Trie-based Approach — Algorithm Steps

Build trie from all input words
For each word, traverse trie to find minimal unique prefix
Generate abbreviation using the minimal prefix
Return original word if abbreviation is not shorter

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all words into trie with count tracking

Find Prefix

For each word, find shortest path with count = 1

Generate

Create abbreviation using minimal prefix

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 100
#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int count;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->count = 0;
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        node->children[i] = NULL;
    }
    return node;
}

char result[MAX_WORDS][MAX_LEN];
char words[MAX_WORDS][MAX_LEN];

void solution(int n) {
    // Build trie
    TrieNode* root = createNode();
    for (int i = 0; i < n; i++) {
        TrieNode* node = root;
        for (int j = 0; words[i][j]; j++) {
            int index = words[i][j] - 'a';
            if (node->children[index] == NULL) {
                node->children[index] = createNode();
            }
            node = node->children[index];
            node->count++;
        }
    }
    
    for (int i = 0; i < n; i++) {
        // Find minimal unique prefix
        TrieNode* node = root;
        int prefixLen = 0;
        int wordLen = strlen(words[i]);
        
        for (int j = 0; j < wordLen; j++) {
            int index = words[i][j] - 'a';
            node = node->children[index];
            prefixLen = j + 1;
            if (node->count == 1) {
                break;
            }
        }
        
        // Generate abbreviation
        if (wordLen <= prefixLen + 1) {
            strcpy(result[i], words[i]);
        } else {
            int middleCount = wordLen - prefixLen - 1;
            char abbrev[MAX_LEN];
            strncpy(abbrev, words[i], prefixLen);
            abbrev[prefixLen] = '\0';
            char numStr[20];
            sprintf(numStr, "%d", middleCount);
            strcat(abbrev, numStr);
            abbrev[strlen(abbrev) + 1] = '\0';
            abbrev[strlen(abbrev)] = words[i][wordLen - 1];
            
            if (strlen(abbrev) >= wordLen) {
                strcpy(result[i], words[i]);
            } else {
                strcpy(result[i], abbrev);
            }
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* start = strchr(line, '[');
    if (start) {
        start++;
        char* token = strtok(start, ",]");
        while (token && n < MAX_WORDS) {
            while (*token == ' ' || *token == '"') token++;
            char* end = token + strlen(token) - 1;
            while (end > token && (*end == ' ' || *end == '"' || *end == '\n')) end--;
            *(end + 1) = '\0';
            strcpy(words[n], token);
            n++;
            token = strtok(NULL, ",]");
        }
    }
    
    solution(n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Building trie takes O(n × m) where n is number of words and m is average word length, finding prefixes takes O(n × m)

✓ Linear Growth

Space Complexity

O(n × m)

Trie structure stores all characters of all words in worst case

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

842 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

Trie-based Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler