Generalized Abbreviation - Practice Coding Problems

Generalized Abbreviation - Problem

Imagine you're creating a smart text compression system that can abbreviate words in multiple creative ways! 🎯

A word's generalized abbreviation can be constructed by taking any number of non-overlapping and non-adjacent substrings and replacing them with their respective lengths.

Example: The word "abcde" can be abbreviated into:

"a3e" - Replace "bcd" with "3"
"1bcd1" - Replace "a" and "e" with "1" each
"5" - Replace entire word with "5"
"abcde" - No replacement (original word)

Invalid abbreviations:

"23" ❌ Adjacent substrings ("ab" → "2" and "cde" → "3")
"22de" ❌ Overlapping substrings ("ab" → "2" and "bc" → "2")

Goal: Given a string word, return all possible generalized abbreviations. The order doesn't matter!

Input & Output

example_1.py — Basic Word

$ Input: word = "word"

› Output: ["4", "3d", "2rd", "2r1", "1ord", "1or1", "1o1d", "wo2", "wo1d", "wor1", "word"]

💡 Note: We can abbreviate any non-overlapping and non-adjacent substrings. Each combination gives a unique abbreviation pattern.

example_2.py — Single Character

$ Input: word = "a"

› Output: ["1", "a"]

💡 Note: For a single character, we can either abbreviate it to '1' or keep it as 'a'.

example_3.py — Two Characters

$ Input: word = "hi"

› Output: ["2", "1i", "h1", "hi"]

💡 Note: With two characters, we can abbreviate both ('2'), first only ('1i'), second only ('h1'), or neither ('hi'). Note that we cannot have adjacent abbreviations.

Constraints

1 ≤ word.length ≤ 15
word consists of only lowercase English letters
No adjacent abbreviations allowed
No overlapping substrings can be abbreviated

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the first character with two possible routes

Make Choice

Either keep the character (scenic route) or abbreviate (shortcut)

Apply Constraints

If you took a shortcut last time, you must take the scenic route this time

Continue Journey

Repeat the process for each remaining character

Collect Results

Each complete path gives you a unique abbreviation

Key Takeaway

🎯 Key Insight: Backtracking naturally prevents adjacent abbreviations by tracking the previous choice, making it more efficient than generating all combinations and filtering invalid ones.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses backtracking to systematically generate all valid abbreviations. At each position, we have two choices: keep the character or abbreviate a substring starting from that position. The key insight is tracking whether the previous choice was an abbreviation to prevent adjacent abbreviations, naturally handling the constraint while exploring only valid combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(2^n)	O(n)	Use recursive backtracking to generate all valid abbreviations efficiently
Brute Force (Generate All Combinations)	O(2^n)	O(2^n * n)	Generate all 2^n possible combinations and filter valid ones

Backtracking (Optimal) — Algorithm Steps

Start from position 0 with empty result
At each position, try two choices: keep character or abbreviate
If abbreviating, count consecutive characters and skip ahead
Ensure no adjacent abbreviations by tracking previous choice
Recursively build abbreviation string
Backtrack and try alternative choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Position 0

Begin with empty path and two choices

Make Decision

Choose to keep character or abbreviate

Recurse Forward

Move to next position based on choice

Backtrack

Return and try alternative choices

Code -

solution.c — C

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

char** result;
int resultSize;
int resultCapacity;

void addResult(char* abbrev) {
    if (resultSize >= resultCapacity) {
        resultCapacity *= 2;
        result = (char**)realloc(result, resultCapacity * sizeof(char*));
    }
    result[resultSize] = (char*)malloc((strlen(abbrev) + 1) * sizeof(char));
    strcpy(result[resultSize], abbrev);
    resultSize++;
}

void backtrack(char* word, int pos, char* path, int pathLen, int prevAbbreviated) {
    if (pos == strlen(word)) {
        path[pathLen] = '\0';
        addResult(path);
        return;
    }
    
    // Choice 1: Keep the character
    path[pathLen] = word[pos];
    backtrack(word, pos + 1, path, pathLen + 1, 0);
    
    // Choice 2: Abbreviate (if previous wasn't abbreviated)
    if (!prevAbbreviated) {
        for (int length = 1; length <= strlen(word) - pos; length++) {
            char lengthStr[10];
            sprintf(lengthStr, "%d", length);
            int lengthStrLen = strlen(lengthStr);
            
            // Add length string to path
            for (int i = 0; i < lengthStrLen; i++) {
                path[pathLen + i] = lengthStr[i];
            }
            
            backtrack(word, pos + length, path, pathLen + lengthStrLen, 1);
        }
    }
}

char** generateAbbreviations(char* word, int* returnSize) {
    result = (char**)malloc(1000 * sizeof(char*));
    resultSize = 0;
    resultCapacity = 1000;
    
    char path[100];
    backtrack(word, 0, path, 0, 0);
    
    *returnSize = resultSize;
    return result;
}

int main() {
    char word[20];
    scanf("%s", word);
    
    // Remove quotes if present
    if (word[0] == '"') {
        memmove(word, word + 1, strlen(word));
        word[strlen(word) - 1] = '\0';
    }
    
    int returnSize;
    char** results = generateAbbreviations(word, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", results[i]);
        if (i < returnSize - 1) printf(", ");
        free(results[i]);
    }
    printf("]\n");
    free(results);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each character has 2 choices, but we only explore valid paths

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most n, plus space for storing results

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler