Generate Parentheses - Practice Coding Problems

Generate Parentheses - Problem

Imagine you're designing a bracket balancer that needs to generate all possible valid combinations of parentheses for mathematical expressions. Given n pairs of parentheses, your task is to write a function that generates all combinations of well-formed parentheses.

A well-formed parentheses string means:

Every opening parenthesis ( has a corresponding closing parenthesis )
Parentheses are properly nested (no closing before opening)
The string is balanced (equal number of opening and closing)

Example: For n = 3, valid combinations include "((()))", "(()())", "(())()", "()(())", "()()()"

This problem tests your ability to generate all valid sequences while avoiding invalid ones - a perfect application of backtracking with constraint validation!

Input & Output

example_1.py — Basic Case

$ Input: n = 3

› Output: ["((()))","(()())","(())()","()(())","()()()"]

💡 Note: For n=3, we need 3 pairs of parentheses. All 5 possible well-formed combinations are shown, each using exactly 3 opening and 3 closing parentheses in valid order.

example_2.py — Small Case

$ Input: n = 1

› Output: ["()"]

💡 Note: With only 1 pair of parentheses, there's exactly one valid combination: one opening followed by one closing parenthesis.

example_3.py — Two Pairs

$ Input: n = 2

› Output: ["(())","()()"]

💡 Note: For n=2, there are exactly 2 valid combinations: nested parentheses "(())" and sequential parentheses "()()".

Constraints

1 ≤ n ≤ 8
The number of valid combinations follows the Catalan numbers: C(n) = (2n)! / ((n+1)! × n!)
Result size will be at most 1430 combinations (when n=8)

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with empty string and zero counts

Smart Decisions

At each node, add '(' if open < n, add ')' if close < open

Valid Paths Only

Never explore invalid combinations

Collect Results

When length = 2n, we have a valid combination

Key Takeaway

🎯 Key Insight: Use backtracking with smart constraints (open < n, close < open) to generate only valid parentheses combinations, achieving optimal Catalan number complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses backtracking with constraints to generate only valid parentheses combinations. By tracking open and close counts, we ensure we never create invalid strings. Key insight: only add ')' when closeCount < openCount and only add '(' when openCount < n. This achieves O(4^n/√n) complexity, which is optimal since that's exactly how many valid combinations exist (Catalan numbers).

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Constraints (Optimal)	O(4^n / √n)	O(4^n / √n)	Use backtracking to build only valid parentheses combinations

Backtracking with Constraints (Optimal) — Algorithm Steps

Start with empty string and counters for open and close parentheses
At each step, add '(' if open count < n
Add ')' if close count < open count (ensures validity)
When string length equals 2n, add to result
Backtrack and try other possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Smart Choices

Only add '(' if openCount < n

Validity Check

Only add ')' if closeCount < openCount

Efficient Exploration

Never explores invalid paths

Code -

solution.c — C

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

void backtrack(char* current, int pos, int openCount, int closeCount, int n, char** result, int* returnSize) {
    // Base case: we've used all n pairs
    if (pos == 2 * n) {
        result[*returnSize] = malloc((2 * n + 1) * sizeof(char));
        strcpy(result[*returnSize], current);
        (*returnSize)++;
        return;
    }
    
    // Add opening parenthesis if we haven't used all n
    if (openCount < n) {
        current[pos] = '(';
        current[pos + 1] = '\0';
        backtrack(current, pos + 1, openCount + 1, closeCount, n, result, returnSize);
    }
    
    // Add closing parenthesis if it won't make string invalid
    if (closeCount < openCount) {
        current[pos] = ')';
        current[pos + 1] = '\0';
        backtrack(current, pos + 1, openCount, closeCount + 1, n, result, returnSize);
    }
}

char** generateParenthesis(int n, int* returnSize) {
    char** result = malloc(10000 * sizeof(char*));
    char* current = malloc((2 * n + 1) * sizeof(char));
    *returnSize = 0;
    
    backtrack(current, 0, 0, 0, n, result, returnSize);
    free(current);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    char** result = generateParenthesis(n, &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(4^n / √n)

Catalan number complexity - only valid paths explored

✓ Linear Growth

Space Complexity

O(4^n / √n)

Space for storing valid results plus recursion stack depth O(n)

⚡ Linearithmic Space

87.6K Views

High Frequency

~15 min Avg. Time

2.1K 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 Constraints (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler