Different Ways to Add Parentheses

Different Ways to Add Parentheses - Problem

Given a string expression of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. You may return the answer in any order.

The test cases are generated such that the output values fit in a 32-bit integer and the number of different results does not exceed 10⁴.

Input & Output

Example 1 — Basic Case

$ Input: expression = "2-1-1"

› Output: [0,2]

💡 Note: Two ways to parenthesize: ((2-1)-1) = 0 and (2-(1-1)) = 2

Example 2 — Multiple Operators

$ Input: expression = "2*3-4*5"

› Output: [-34,-14,-10,-10,10]

💡 Note: Five ways to parenthesize giving different results based on operator precedence changes

Example 3 — Single Number

$ Input: expression = "2"

› Output: [2]

💡 Note: Only one way to evaluate a single number

Constraints

1 ≤ expression.length ≤ 20
expression consists of digits and the operators '+', '-', and '*'
All the integer values in the input expression are in the range [0, 99]

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Facebook 28 M Microsoft 22

The key insight is to use divide-and-conquer by treating each operator as the last operation performed. Best approach is recursion with memoization to avoid redundant calculations. Time: O(4ⁿ/n^1.5), Space: O(4ⁿ/n^1.5)

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(4ⁿ/n^1.5) Space: O(4ⁿ/n^1.5)

For each operator in the expression, treat it as the last operation and recursively solve the left and right parts. Combine all results from left and right using the current operator.

Recursion with Memoization

⏱️ Time: O(4ⁿ/n^1.5) Space: O(4ⁿ/n^1.5)

Use the same divide-and-conquer approach but store results for each substring in a hash map to avoid redundant calculations when the same subexpression appears multiple times.

Brute Force Recursion — Algorithm Steps

Step 1: For each operator, split expression into left and right parts
Step 2: Recursively get all results for left and right parts
Step 3: Combine all left results with all right results using current operator

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Expression

Try each operator as the last operation

Recursive Solve

Get all results for left and right parts

Combine Results

Apply operator to all combinations

Code -

solution.c — C

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

static int results[10000];
static int result_count;

void compute(const char* expr, int len) {
    int found_operator = 0;
    
    // Try splitting at each operator
    for (int i = 0; i < len; i++) {
        char ch = expr[i];
        if (ch == '+' || ch == '-' || ch == '*') {
            found_operator = 1;
            
            // Save current state
            int saved_results[10000];
            int saved_count = result_count;
            memcpy(saved_results, results, result_count * sizeof(int));
            
            // Compute left part
            result_count = 0;
            compute(expr, i);
            int left_results[10000];
            int left_count = result_count;
            memcpy(left_results, results, result_count * sizeof(int));
            
            // Compute right part
            result_count = 0;
            compute(expr + i + 1, len - i - 1);
            int right_results[10000];
            int right_count = result_count;
            memcpy(right_results, results, result_count * sizeof(int));
            
            // Restore state and add combinations
            result_count = saved_count;
            memcpy(results, saved_results, saved_count * sizeof(int));
            
            // Combine all left and right results
            for (int l = 0; l < left_count; l++) {
                for (int r = 0; r < right_count; r++) {
                    int value;
                    if (ch == '+') {
                        value = left_results[l] + right_results[r];
                    } else if (ch == '-') {
                        value = left_results[l] - right_results[r];
                    } else if (ch == '*') {
                        value = left_results[l] * right_results[r];
                    }
                    results[result_count++] = value;
                }
            }
        }
    }
    
    // Base case: if no operator found, it's a number
    if (!found_operator) {
        char temp[100];
        strncpy(temp, expr, len);
        temp[len] = '\0';
        results[result_count++] = atoi(temp);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
        len--;
    }
    
    result_count = 0;
    compute(line, len);
    
    // Print results in JSON format
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(",");
        printf("%d", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4ⁿ/n^1.5)

Catalan number of ways to parenthesize, approximately 4^n divided by n^1.5

✓ Linear Growth

Space Complexity

O(4ⁿ/n^1.5)

Recursion depth and storage for all possible results

⚡ Linearithmic Space

185.0K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler