Generalized Abbreviation

Generalized Abbreviation - Problem

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.

For example, "abcde" can be abbreviated into:

"a3e" ("bcd" turned into "3")
"1bcd1" ("a" and "e" both turned into "1")
"5" ("abcde" turned into "5")
"abcde" (no substrings replaced)

However, these abbreviations are invalid:

"23" ("ab" turned into "2" and "cde" turned into "3") is invalid as the substrings chosen are adjacent.
"22de" ("ab" turned into "2" and "bc" turned into "2") is invalid as the substring chosen overlap.

Given a string word, return a list of all the possible generalized abbreviations of word. Return the answer in any order.

Input & Output

Example 1 — Basic Case

$ Input: word = "word"

› Output: ["4","3d","2r1","2rd","1o1d","1o2","1od1","1ord","w2d","w3","w1r1","w1rd","wo1d","wo2","wor1","word"]

💡 Note: All possible ways to abbreviate "word" by replacing non-adjacent substrings with their lengths

Example 2 — Short Word

$ Input: word = "a"

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

💡 Note: Single character can either be abbreviated as "1" or kept as "a"

Example 3 — Two Characters

$ Input: word = "hi"

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

💡 Note: Two characters give us 4 combinations: abbreviate both, abbreviate first, abbreviate second, or keep both

Constraints

1 ≤ word.length ≤ 15
word consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is that each character can either be kept as-is or included in an abbreviation group. We can use backtracking to systematically try both choices at each position. Best approach is backtracking with O(2ⁿ × n) time and space complexity.

Common Approaches

✓ Bit Manipulation Approach

⏱️ Time: O(2ⁿ × n) Space: O(2ⁿ × n)

Each bit position represents whether to abbreviate (1) or keep (0) a character. Generate all possible bit patterns from 0 to 2^n-1 and convert each pattern to a valid abbreviation.

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × n) Space: O(2ⁿ × n)

For each character, we have two choices: keep it as-is or include it in an abbreviation. We recursively try both choices and collect all valid combinations.

Optimized Backtracking

⏱️ Time: O(2ⁿ × n) Space: O(2ⁿ × n)

Instead of generating all combinations first, we build valid abbreviations character by character, making decisions at each step and backtracking when needed.

Bit Manipulation Approach — Algorithm Steps

Generate all numbers from 0 to 2^n - 1
For each number, check its binary representation
Build abbreviation string based on bit pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all bit patterns from 0 to 2^n-1

Map

0 bit = keep character, 1 bit = abbreviate

Build

Convert each pattern to abbreviation string

Code -

solution.c — C

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

char** solution(char* word, int* returnSize) {
    int n = strlen(word);
    int totalCombos = 1 << n;
    char** result = malloc(totalCombos * sizeof(char*));
    *returnSize = 0;
    
    // Generate all possible bit patterns
    for (int mask = 0; mask < totalCombos; mask++) {
        char abbrev[200] = "";
        int count = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {  // Bit is set, abbreviate this character
                count++;
            } else {  // Bit is not set, keep this character
                if (count > 0) {
                    char countStr[10];
                    sprintf(countStr, "%d", count);
                    strcat(abbrev, countStr);
                    count = 0;
                }
                char temp[2] = {word[i], '\0'};
                strcat(abbrev, temp);
            }
        }
        
        // Handle remaining count at the end
        if (count > 0) {
            char countStr[10];
            sprintf(countStr, "%d", count);
            strcat(abbrev, countStr);
        }
        
        result[*returnSize] = malloc(strlen(abbrev) + 1);
        strcpy(result[*returnSize], abbrev);
        (*returnSize)++;
    }
    
    return result;
}

int main() {
    char word[100];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    
    // Remove quotes
    char* cleanWord = word + 1;
    cleanWord[strlen(cleanWord) - 1] = 0;
    
    int returnSize;
    char** result = solution(cleanWord, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n bit patterns, each taking O(n) time to process into abbreviation

✓ Linear Growth

Space Complexity

O(2ⁿ × n)

Stores all 2^n abbreviations, each of average length n/2

⚡ Linearithmic Space

33.0K Views

Medium Frequency

~25 min Avg. Time

847 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

Bit Manipulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler