Brace Expansion

Brace Expansion - Problem

You are given a string s representing a list of words. Each letter in the word has one or more options.

If there is one option, the letter is represented as is.

If there is more than one option, then curly braces delimit the options. For example, {a,b,c} represents options ["a", "b", "c"].

For example, if s = "a{b,c}", the first character is always 'a', but the second character can be 'b' or 'c'. The original list is ["ab", "ac"].

Return all words that can be formed in this manner, sorted in lexicographical order.

Input & Output

Example 1 — Basic Expansion

$ Input: s = "a{b,c}"

› Output: ["ab","ac"]

💡 Note: The first character is 'a', the second can be 'b' or 'c', giving us "ab" and "ac". Results are sorted lexicographically.

Example 2 — Multiple Options

$ Input: s = "{a,b}{c,d}"

› Output: ["ac","ad","bc","bd"]

💡 Note: First position has options {a,b}, second has {c,d}. All combinations: ac, ad, bc, bd. Already in lexicographical order.

Example 3 — Mixed Fixed and Variable

$ Input: s = "a{b,c}d{e,f}"

› Output: ["abde","abdf","acde","acdf"]

💡 Note: Fixed 'a', options {b,c}, fixed 'd', options {e,f}. Generate all 4 combinations and sort.

Constraints

1 ≤ s.length ≤ 50
s consists of lowercase English letters, '{', '}', and ','
All the values in s are unique

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is to parse the string to identify fixed characters and option groups, then systematically generate all combinations. The best approach uses iterative expansion or queue-based BFS to avoid recursion overhead. Time: O(k × n × log k), Space: O(k × n) where k is the number of combinations.

Common Approaches

✓ Backtracking with Stack

⏱️ Time: O(k × n × log(k)) Space: O(k × n)

Parse the input string and use an iterative approach with a stack to generate all possible combinations. This avoids deep recursion and handles the expansion systematically.

Brute Force with Recursion

⏱️ Time: O(k × n × log(k)) Space: O(k × n)

Parse the input string to identify fixed characters and option groups, then use recursion to generate all possible combinations by exploring each option at each position.

Queue-Based BFS

⏱️ Time: O(k × n × log(k)) Space: O(k × n)

Process the string character by character using a queue-based approach. For each character or option group, expand all current combinations in the queue, ensuring systematic generation without recursion.

Backtracking with Stack — Algorithm Steps

Parse input to extract option groups
Use stack to track current combinations
Expand each combination with next options
Sort final results

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty string

Expand

For each option group, multiply combinations

Result

Sort all generated combinations

Code -

solution.c — C

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

char result[1000][100];
int resultCount = 0;

int compare(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

void solution(char* s) {
    char options[50][10][10];
    int optionCounts[50] = {0};
    int totalOptions = 0;
    int i = 0;
    
    while (i < strlen(s)) {
        if (s[i] == '{') {
            int j = i + 1;
            while (j < strlen(s) && s[j] != '}') j++;
            char optionStr[100];
            strncpy(optionStr, s + i + 1, j - i - 1);
            optionStr[j - i - 1] = '\0';
            
            char* token = strtok(optionStr, ",");
            while (token != NULL) {
                strcpy(options[totalOptions][optionCounts[totalOptions]], token);
                optionCounts[totalOptions]++;
                token = strtok(NULL, ",");
            }
            totalOptions++;
            i = j + 1;
        } else {
            options[totalOptions][0][0] = s[i];
            options[totalOptions][0][1] = '\0';
            optionCounts[totalOptions] = 1;
            totalOptions++;
            i++;
        }
    }
    
    strcpy(result[0], "");
    resultCount = 1;
    
    for (int opt = 0; opt < totalOptions; opt++) {
        int currentCount = resultCount;
        resultCount = 0;
        char temp[1000][100];
        for (int i = 0; i < currentCount; i++) {
            strcpy(temp[i], result[i]);
        }
        
        for (int i = 0; i < currentCount; i++) {
            for (int j = 0; j < optionCounts[opt]; j++) {
                strcpy(result[resultCount], temp[i]);
                strcat(result[resultCount], options[opt][j]);
                resultCount++;
            }
        }
    }
    
    qsort(result, resultCount, sizeof(result[0]), compare);
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    solution(s);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n × log(k))

k combinations generated, each of length n, plus sorting k results

⚡ Linearithmic

Space Complexity

O(k × n)

Stack stores intermediate combinations, final result stores k strings

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler