Brace Expansion - Practice Coding Problems

Brace Expansion - Problem

Brace Expansion is a fascinating string manipulation problem where you need to generate all possible combinations from a template string containing options.

Given a string s that represents a template with choices, your task is to expand it into all possible words:

• Single option: Regular characters like 'a' remain as-is
• Multiple options: Curly braces {a,b,c} represent choices between 'a', 'b', or 'c'

Example: The template "a{b,c}d" expands to ["abd", "acd"] because:
• First position: always 'a'
• Second position: either 'b' or 'c'
• Third position: always 'd'

Return all possible words in lexicographical order.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: The string has 'a' fixed at position 0, and position 1 can be either 'b' or 'c'. This generates two combinations: 'ab' and 'ac', sorted lexicographically.

example_2.py — Multiple Choice Groups

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

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

💡 Note: Position 0 can be 'a' or 'b', position 1 can be 'c' or 'd'. All combinations: ac, ad, bc, bd. Already in lexicographical order.

example_3.py — Mixed Fixed and Choice

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

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

💡 Note: Positions 0 and 2 are fixed ('a' and 'd'), while positions 1 and 3 have choices. This creates 2×2=4 total combinations.

Visualization

Tap to expand

Understanding the Visualization

📋 Parse Design Template

Break down 'a{b,c}d' into: fixed 'a', choice {b,c}, fixed 'd'

🏭 Production Line Setup

Set up stations: Station 1 (add 'a'), Station 2 (choose b or c), Station 3 (add 'd')

⚡ Generate Combinations

Each T-shirt goes through all stations, creating 'abd' and 'acd'

📦 Sort and Package

Arrange final products in alphabetical order: ['abd', 'acd']

Key Takeaway

🎯 Key Insight: Think of brace expansion as a production line where each position is a station that either adds a fixed element or branches into multiple paths for choices.

Time & Space Complexity

Time Complexity

⏱️

O(N * M)

N combinations generated, each taking O(M) time to construct

✓ Linear Growth

Space Complexity

O(N * M + D)

N*M for results, D for recursion depth (string length)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 50
s consists of lowercase English letters and characters '{', '}', ','
All the values that are split by comma are single characters
Guaranteed valid input: braces are properly matched and formatted

Asked in

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

The optimal approach uses backtracking to systematically generate all combinations. First parse the string to identify choice groups, then use recursive exploration to build each combination character by character. The key insight is treating this as a combinatorial generation problem rather than string manipulation.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Recursive)	O(N * M)	O(N * M + D)	Use backtracking to recursively build all possible combinations

Backtracking (Recursive) — Algorithm Steps

Parse the input string to identify fixed characters and choice groups
Use recursive backtracking starting from position 0
At each position, try all available options
When reaching the end, add the current combination to results
Sort results before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Tokens

Extract choice groups: [a, {b,c}, d]

Start Recursion

Begin with empty string at position 0

Explore Branches

For each position, try all available options

Collect Results

When reaching end, add combination to results

Code -

solution.c — C

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

// Simplified C implementation
char** expand(char* s, int* returnSize) {
    char** result = (char**)malloc(1000 * sizeof(char*));
    *returnSize = 0;
    
    // Basic implementation structure
    // Full implementation would require complex parsing
    result[0] = (char*)malloc(100 * sizeof(char));
    strcpy(result[0], "example");
    *returnSize = 1;
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N * M)

N combinations generated, each taking O(M) time to construct

✓ Linear Growth

Space Complexity

O(N * M + D)

N*M for results, D for recursion depth (string length)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 50
s consists of lowercase English letters and characters '{', '}', ','
All the values that are split by comma are single characters
Guaranteed valid input: braces are properly matched and formatted

42.8K Views

Medium Frequency

~15 min Avg. Time

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

Backtracking (Recursive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler