Brace Expansion II

Brace Expansion II - Problem

Hash Table String Backtracking Stack Breadth-First Search Sorting Hard

Under a specific grammar, strings can represent a set of lowercase words. Given an expression following this grammar, return the sorted list of words that the expression represents.

The grammar rules are:

Single letters: R("a") = {"a"}
Union (comma-separated): R("{a,b,c}") = {"a","b","c"}
Concatenation: R("{a,b}{c,d}") = {"ac","ad","bc","bd"}

More complex example: R("a{b,c}{d,e}f{g,h}") = {"abdfg", "abdfh", "abefg", "abefh", "acdfg", "acdfh", "acefg", "acefh"}

Note that union removes duplicates, so R("{{a,b},{b,c}}") = {"a","b","c"}

Input & Output

Example 1 — Basic Union and Concatenation

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

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

💡 Note: First group {a,b} gives {a,b}, second group {c,d} gives {c,d}. Cartesian product: a×{c,d} = {ac,ad}, b×{c,d} = {bc,bd}. Final result sorted: ["ac","ad","bc","bd"]

Example 2 — Nested Braces with Duplicates

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

› Output: ["a","b","c"]

💡 Note: Inner group {a,b} gives {a,b}, inner group {b,c} gives {b,c}. Union of both groups: {a,b} ∪ {b,c} = {a,b,c}. Duplicates removed, sorted: ["a","b","c"]

Example 3 — Complex Mixed Expression

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

› Output: ["abdf","abef","acdf","acef"]

💡 Note: Start with 'a'. Group {b,c} gives {b,c}. Concatenate: a×{b,c} = {ab,ac}. Group {d,e} gives {d,e}. Concatenate: {ab,ac}×{d,e} = {abd,abe,acd,ace}. Finally add 'f': {abdf,abef,acdf,acef}

Constraints

1 ≤ expression.length ≤ 60
expression[i] consists of '{', '}', ',', and lowercase English letters
The given expression represents a set of words based on the grammar given in the description

Visualization

Tap to expand

Asked in

G Google 45 F Facebook 32 a Amazon 28 M Microsoft 25

The key insight is to parse the nested brace structure recursively, handling union operations (comma-separated) and concatenation operations (adjacent elements). Best approach uses recursive parsing with sets for deduplication. Time: O(N × M), Space: O(M)

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Recursive Parsing with Set Operations

⏱️ Time: O(N × M) Space: O(M)

Parse the brace expression by identifying unions (comma-separated) and concatenations (adjacent elements). Use recursion to handle nested braces and combine results using set operations.

Stack-based Parsing

⏱️ Time: O(N × M) Space: O(M + D)

Process the expression character by character using a stack to track nested levels. When encountering braces, push current state and handle inner expressions, then pop and combine results.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_RESULTS 10000
#define MAX_STRING_LEN 1000

static char results[MAX_RESULTS][MAX_STRING_LEN];
static int result_count;

void add_result(const char* str) {
    // Check for duplicates
    for (int i = 0; i < result_count; i++) {
        if (strcmp(results[i], str) == 0) {
            return;
        }
    }
    strcpy(results[result_count], str);
    result_count++;
}

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

void parse_expression(const char* expr, int start, int end, char* prefix, char current_results[][MAX_STRING_LEN], int* current_count) {
    *current_count = 0;
    strcpy(current_results[0], prefix);
    *current_count = 1;
    
    int i = start;
    while (i < end) {
        if (expr[i] == '{') {
            // Find matching closing brace
            int brace_count = 1;
            int j = i + 1;
            while (j < end && brace_count > 0) {
                if (expr[j] == '{') {
                    brace_count++;
                } else if (expr[j] == '}') {
                    brace_count--;
                }
                j++;
            }
            
            // Parse the content inside braces
            int inner_start = i + 1;
            int inner_end = j - 1;
            
            // Split by comma at top level
            static char groups[100][MAX_STRING_LEN];
            int group_count = 0;
            int group_start = inner_start;
            brace_count = 0;
            
            for (int k = inner_start; k <= inner_end; k++) {
                if (k < inner_end) {
                    if (expr[k] == '{') {
                        brace_count++;
                    } else if (expr[k] == '}') {
                        brace_count--;
                    } else if (expr[k] == ',' && brace_count == 0) {
                        // End of current group
                        int len = k - group_start;
                        strncpy(groups[group_count], expr + group_start, len);
                        groups[group_count][len] = '\0';
                        group_count++;
                        group_start = k + 1;
                        continue;
                    }
                }
                if (k == inner_end) {
                    // Last group
                    int len = k - group_start + 1;
                    strncpy(groups[group_count], expr + group_start, len);
                    groups[group_count][len] = '\0';
                    group_count++;
                }
            }
            
            // Get union of all groups
            static char group_results[MAX_RESULTS][MAX_STRING_LEN];
            int total_group_results = 0;
            
            for (int g = 0; g < group_count; g++) {
                static char temp_results[MAX_RESULTS][MAX_STRING_LEN];
                int temp_count;
                parse_expression(groups[g], 0, strlen(groups[g]), "", temp_results, &temp_count);
                
                for (int t = 0; t < temp_count; t++) {
                    // Check for duplicates in group_results
                    int duplicate = 0;
                    for (int gr = 0; gr < total_group_results; gr++) {
                        if (strcmp(group_results[gr], temp_results[t]) == 0) {
                            duplicate = 1;
                            break;
                        }
                    }
                    if (!duplicate) {
                        strcpy(group_results[total_group_results], temp_results[t]);
                        total_group_results++;
                    }
                }
            }
            
            // Concatenate with current results
            static char new_results[MAX_RESULTS][MAX_STRING_LEN];
            int new_count = 0;
            
            for (int r = 0; r < *current_count; r++) {
                for (int g = 0; g < total_group_results; g++) {
                    strcpy(new_results[new_count], current_results[r]);
                    strcat(new_results[new_count], group_results[g]);
                    new_count++;
                }
            }
            
            // Copy back to current_results
            for (int nr = 0; nr < new_count; nr++) {
                strcpy(current_results[nr], new_results[nr]);
            }
            *current_count = new_count;
            
            i = j;
        } else {
            // Regular character
            for (int r = 0; r < *current_count; r++) {
                int len = strlen(current_results[r]);
                current_results[r][len] = expr[i];
                current_results[r][len + 1] = '\0';
            }
            i++;
        }
    }
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    
    // Remove newline
    int len = strlen(expression);
    if (len > 0 && expression[len-1] == '\n') {
        expression[len-1] = '\0';
    }
    
    static char temp_results[MAX_RESULTS][MAX_STRING_LEN];
    int temp_count;
    
    parse_expression(expression, 0, strlen(expression), "", temp_results, &temp_count);
    
    // Add to final results and remove duplicates
    result_count = 0;
    for (int i = 0; i < temp_count; i++) {
        add_result(temp_results[i]);
    }
    
    // Sort results
    qsort(results, result_count, MAX_STRING_LEN, compare_strings);
    
    // Print as JSON array
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.2K Views

Medium Frequency

~35 min Avg. Time

892 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