Short Encoding of Words - Practice Coding Problems

Short Encoding of Words - Problem

Short Encoding of Words is a fascinating string compression problem that challenges you to find the most efficient way to encode an array of words.

Imagine you have a list of words and you want to create a reference string that can represent all of them using the minimum amount of space. The encoding works like this:

Create a reference string s that ends with '#'
For each word, store an index pointing to where that word appears in the reference string
Each word must be followed by a '#' character in the reference string

Example: For words ["time", "me", "bell"], one valid encoding could be the reference string "time#bell#" with indices [0, 2, 5], but a shorter encoding would be "time#bell#" with indices [0, 2, 5].

Your goal is to find the minimum length of such a reference string. The key insight is that if one word is a suffix of another (like "me" is a suffix of "time"), you can save space by only storing the longer word!

Input & Output

example_1.py — Basic Case

$ Input: ["time", "me", "bell"]

› Output: 10

💡 Note: We can encode as "time#bell#" since "me" is a suffix of "time". Total length = 4 + 1 + 4 + 1 = 10.

example_2.py — No Common Suffixes

$ Input: ["t"]

› Output: 2

💡 Note: Single word case results in "t#" with length 2.

example_3.py — Multiple Suffix Relationships

$ Input: ["time", "me", "e", "atime"]

› Output: 7

💡 Note: "e" is suffix of "me" and "time", "me" is suffix of "time" and "atime". Only "atime" needed: length = 5 + 1 + 1 = 7.

Visualization

Tap to expand

Understanding the Visualization

Collect All Titles

Start with your list of book titles: "time", "me", "bell"

Find Overlaps

Notice that "me" appears at the end of "time" - it's a suffix relationship

Optimize Storage

Store only "time#bell#" since "me" can be found within "time"

Calculate Savings

Final catalog length is 10 characters instead of 13 if stored separately

Key Takeaway

🎯 Key Insight: By using a reverse trie, we efficiently identify all suffix relationships in O(nm) time, allowing us to exclude redundant words and achieve the minimum encoding length.

Time & Space Complexity

Time Complexity

⏱️

O(nm)

Building trie takes O(nm) where n is number of words and m is average length, checking each word takes O(m)

✓ Linear Growth

Space Complexity

O(nm)

Trie can store up to nm characters in worst case when no words share common suffixes

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 2000
1 ≤ words[i].length ≤ 7
words[i] consists of only lowercase letters

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25

The optimal solution uses a reverse trie approach. By reversing all words and building a trie, we transform the suffix detection problem into a prefix problem. Words that end at leaf nodes in the trie are not suffixes of other words and must be included in the encoding. Time complexity: O(nm), where n is the number of words and m is the average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Set Elimination	O(n*m²)	O(n*m)	First pass builds a set, second pass removes words that are suffixes of others
Brute Force (Check All Suffixes)	O(n²m)	O(1)	Check every word against every other word to see if it's a suffix
Reverse Trie (Optimal)	O(nm)	O(nm)	Build a trie with reversed words to efficiently find suffix relationships

Two-Pass with Set Elimination — Algorithm Steps

Create a set from the input words to eliminate duplicates
For each word, generate all its possible suffixes
Remove any suffix that exists in the set (except the word itself)
Calculate total length of remaining words plus '#' characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Word Set

Create a hash set with all unique words

Find Suffixes

For each word, check if its suffixes exist in the set

Remove & Count

Remove suffix words and count remaining lengths

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 100

int minimumLengthEncoding(char** words, int wordsSize) {
    // Simple approach without hash table (C doesn't have built-in)
    bool included[MAX_WORDS];
    for (int i = 0; i < wordsSize; i++) {
        included[i] = true;
    }
    
    // Mark words that are suffixes of others
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < wordsSize; j++) {
            if (i != j && included[i] && included[j]) {
                int len_i = strlen(words[i]);
                int len_j = strlen(words[j]);
                if (len_i < len_j) {
                    // Check if words[i] is suffix of words[j]
                    if (strcmp(words[i], words[j] + len_j - len_i) == 0) {
                        included[i] = false;
                    }
                }
            }
        }
    }
    
    // Calculate total length
    int totalLength = 0;
    for (int i = 0; i < wordsSize; i++) {
        if (included[i]) {
            totalLength += strlen(words[i]) + 1;
        }
    }
    
    return totalLength;
}

int main() {
    char* words[] = {"time", "me", "bell"};
    printf("%d\n", minimumLengthEncoding(words, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m²)

For each word of length m, we generate O(m) suffixes and check each in the set, doing this for n words

✓ Linear Growth

Space Complexity

O(n*m)

Hash set stores all unique words, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 2000
1 ≤ words[i].length ≤ 7
words[i] consists of only lowercase letters

73.2K Views

Medium Frequency

~25 min Avg. Time

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

Two-Pass with Set Elimination — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler