Word Abbreviation - Practice Coding Problems

Word Abbreviation - Problem

Array String Greedy Trie Sorting Hard

You're building a smart text compression system that creates minimal unique abbreviations for words. Given an array of distinct strings, your goal is to generate the shortest possible abbreviations for each word while ensuring all abbreviations remain unique.

How abbreviations work:

Start with: first_char + count_of_middle_chars + last_char
Example: "hello" → "h3o" (h + 3 middle chars + o)

Conflict resolution: When multiple words share the same abbreviation, incrementally increase the prefix length until all abbreviations become unique.

Special rule: If the final abbreviation isn't shorter than the original word, keep the original word instead.

Example walkthrough:

For ["abcdef", "abndef"]:

Initial: both become "a4f" ❌ (conflict!)
Expand prefix: both become "ab3f" ❌ (still conflict!)
Expand again: "abc2f" and "abn2f" ✅ (unique!)

Input & Output

example_1.py — Basic Conflict Resolution

$ Input: ["internal", "internet", "interstate", "interval"]

› Output: ["int4l", "i6t", "i8e", "int4l"]

💡 Note: "internal" and "interval" both initially become "i6l", so we expand prefixes until they become unique: "int4l" for both (but they're different words). "internet" becomes "i6t" and "interstate" becomes "i8e" with no conflicts.

example_2.py — No Conflicts Needed

$ Input: ["apple", "banana", "cherry"]

› Output: ["a3e", "b4a", "c4y"]

💡 Note: All words have different first and last characters, so no conflicts occur. Each gets abbreviated to first + middle_count + last format.

example_3.py — Abbreviation Not Shorter

$ Input: ["dog", "cat", "rat"]

› Output: ["dog", "cat", "rat"]

💡 Note: These 3-letter words would abbreviate to 3-character strings (like "d1g"), which aren't shorter than originals, so we keep the original words.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n words, each processed once through Trie of depth m (average word length)

✓ Linear Growth

Space Complexity

O(n × m)

Trie storage for all word prefixes, in worst case all prefixes are different

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters only
All strings in words are distinct

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Grouping)	O(n × m × k)	O(n × m)	First pass groups words by abbreviation, second pass resolves conflicts within each group
Brute Force (Repeated Conflict Detection)	O(n² × m)	O(n × m)	Generate initial abbreviations, then repeatedly find conflicts and expand prefixes until all are unique
Optimal: Trie-Based Solution	O(n × m)	O(n × m)	Use Trie data structure to efficiently determine minimal prefix length needed for uniqueness

Two-Pass Hash Table (Grouping) — Algorithm Steps

Generate initial abbreviations for all words
Group words by their current abbreviations using hash map
For each group with multiple words, expand prefix length incrementally
Repeat grouping and expansion until all groups have unique abbreviations
Replace with original words if abbreviation isn't shorter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Initial Abbreviations

Create abbreviations for all words

Group by Abbreviation

Collect words that share the same abbreviation

Identify Conflicts

Groups with multiple words have conflicts

Expand Conflicting Groups

Increase prefix length only for conflicting words

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 100

typedef struct {
    char abbrev[MAX_LEN];
    int indices[MAX_WORDS];
    int count;
} AbbrevGroup;

char* abbreviate(const char* word, int prefixLen) {
    int len = strlen(word);
    if (prefixLen >= len - 2) {
        char* result = malloc((len + 1) * sizeof(char));
        strcpy(result, word);
        return result;
    }
    
    char* result = malloc(MAX_LEN * sizeof(char));
    int middleCount = len - prefixLen - 1;
    sprintf(result, "%.*s%d%c", prefixLen, word, middleCount, word[len-1]);
    return result;
}

char** wordsAbbreviation(char** words, int n) {
    int* prefixLens = malloc(n * sizeof(int));
    char** result = malloc(n * sizeof(char*));
    int* active = malloc(n * sizeof(int));
    int activeCount = n;
    
    // Initialize
    for (int i = 0; i < n; i++) {
        prefixLens[i] = 1;
        result[i] = malloc(MAX_LEN * sizeof(char));
        active[i] = i;
    }
    
    while (activeCount > 0) {
        AbbrevGroup groups[MAX_WORDS];
        int groupCount = 0;
        
        // First pass: group by abbreviations
        for (int i = 0; i < activeCount; i++) {
            int wordIdx = active[i];
            char* abbrev = abbreviate(words[wordIdx], prefixLens[wordIdx]);
            
            // Find existing group or create new one
            int groupIdx = -1;
            for (int j = 0; j < groupCount; j++) {
                if (strcmp(groups[j].abbrev, abbrev) == 0) {
                    groupIdx = j;
                    break;
                }
            }
            
            if (groupIdx == -1) {
                strcpy(groups[groupCount].abbrev, abbrev);
                groups[groupCount].count = 0;
                groupIdx = groupCount++;
            }
            
            groups[groupIdx].indices[groups[groupIdx].count++] = wordIdx;
            free(abbrev);
        }
        
        // Second pass: resolve conflicts
        int nextActiveCount = 0;
        for (int i = 0; i < groupCount; i++) {
            if (groups[i].count == 1) {
                int wordIdx = groups[i].indices[0];
                strcpy(result[wordIdx], groups[i].abbrev);
            } else {
                for (int j = 0; j < groups[i].count; j++) {
                    int wordIdx = groups[i].indices[j];
                    prefixLens[wordIdx]++;
                    active[nextActiveCount++] = wordIdx;
                }
            }
        }
        
        activeCount = nextActiveCount;
    }
    
    free(prefixLens);
    free(active);
    return result;
}

int main() {
    char* words[] = {"internal", "internet", "interstate", "interval"};
    int n = 4;
    char** result = wordsAbbreviation(words, n);
    
    for (int i = 0; i < n; i++) {
        printf("%s ", result[i]);
        free(result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n words, m average word length, k rounds of conflict resolution (usually small)

✓ Linear Growth

Space Complexity

O(n × m)

Hash maps to store groups and abbreviations

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters only
All strings in words are distinct

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table (Grouping) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler