Different Ways to Add Parentheses - Practice Coding Problems

Different Ways to Add Parentheses - Problem

Ever wondered how mathematical expressions can be evaluated in different ways? Given a string expression containing numbers and operators (+, -, *), your task is to return all possible results from computing all the different ways to group numbers and operators using parentheses.

Think of it as exploring every possible way to parenthesize an arithmetic expression. For example, "2-1-1" can be computed as ((2-1)-1) = 0 or (2-(1-1)) = 2.

Key Points:

You can add parentheses anywhere to change the order of operations
Return results in any order
All results fit in a 32-bit integer
Number of different results ≤ 10⁴

Input & Output

example_1.py — Basic Expression

$ Input: "2-1-1"

› Output: [0, 2]

💡 Note: ((2-1)-1) = 0 and (2-(1-1)) = 2. Two different ways to parenthesize give different results.

example_2.py — Mixed Operations

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

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

💡 Note: Different parenthesizations: (2*(3-(4*5))) = -34, ((2*3)-(4*5)) = -14, ((2*(3-4))*5) = -10, (2*((3-4)*5)) = -10, (((2*3)-4)*5) = 10

example_3.py — Single Number

$ Input: "5"

› Output: [5]

💡 Note: No operators present, so only one possible result which is the number itself.

Visualization

Tap to expand

Understanding the Visualization

Root Expression

Start with the complete expression "2*3-4"

Split at Operators

Create branches for each possible operator split point

Recursive Calculation

Each branch recursively evaluates its left and right parts

Combine Results

Merge all possible combinations from left and right subtrees

Key Takeaway

🎯 Key Insight: Every arithmetic expression can be viewed as a binary tree where internal nodes are operators and leaves are operands. By exploring all possible tree structures, we find all possible evaluation results!

Time & Space Complexity

Time Complexity

⏱️

O(n * 4^n)

Memoization reduces redundant calculations but we still explore all possible splits

✓ Linear Growth

Space Complexity

O(n * 4^n)

Space for memoization cache plus recursion stack and result storage

⚡ Linearithmic Space

Constraints

1 ≤ expression.length ≤ 20
expression consists of digits and the operator +, -, and *
All the integer values in the input expression are in the range [0, 99]
The number of different results ≤ 10⁴

Asked in

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

The optimal approach uses divide and conquer with memoization. Split the expression at each operator, recursively compute results for left and right parts, then combine them. Memoization prevents recalculating the same subproblems, improving efficiency while maintaining the intuitive recursive structure.

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer with Memoization	O(n * 4^n)	O(n * 4^n)	Cache previously computed subproblems to avoid redundant calculations

Divide and Conquer with Memoization — Algorithm Steps

Create a memoization dictionary to store results for substrings
Check if current expression is already computed
If cached, return the stored result
Otherwise, compute using divide-and-conquer approach
Store the result in cache before returning
Base case: if no operators, return the number itself

Visualization

Tap to expand

Step-by-Step Walkthrough

First Calculation

Compute "1+2" and cache result [3]

Cache Hit

When "1+2" appears again, return cached [3]

Memory Savings

Avoid recalculating the same subproblem

Final Result

Combine all cached and new results

Code -

solution.c — C

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

#define MAX_RESULTS 10000
#define MAX_CACHE 1000

typedef struct CacheEntry {
    char expression[100];
    int* results;
    int count;
    int used;
} CacheEntry;

CacheEntry cache[MAX_CACHE];
int cache_size = 0;

CacheEntry* findInCache(char* expression) {
    for (int i = 0; i < cache_size; i++) {
        if (cache[i].used && strcmp(cache[i].expression, expression) == 0) {
            return &cache[i];
        }
    }
    return NULL;
}

void addToCache(char* expression, int* results, int count) {
    if (cache_size >= MAX_CACHE) return;
    
    strcpy(cache[cache_size].expression, expression);
    cache[cache_size].results = malloc(count * sizeof(int));
    memcpy(cache[cache_size].results, results, count * sizeof(int));
    cache[cache_size].count = count;
    cache[cache_size].used = 1;
    cache_size++;
}

int isOperator(char c) {
    return c == '+' || c == '-' || c == '*';
}

int compute(int left, int right, char op) {
    switch(op) {
        case '+': return left + right;
        case '-': return left - right;
        case '*': return left * right;
    }
    return 0;
}

void diffWaysToCompute(char* expression, int* temp_results, int* temp_count) {
    CacheEntry* cached = findInCache(expression);
    if (cached) {
        memcpy(temp_results, cached->results, cached->count * sizeof(int));
        *temp_count = cached->count;
        return;
    }
    
    *temp_count = 0;
    int len = strlen(expression);
    
    for (int i = 0; i < len; i++) {
        if (isOperator(expression[i])) {
            char left_expr[100], right_expr[100];
            strncpy(left_expr, expression, i);
            left_expr[i] = '\0';
            strcpy(right_expr, expression + i + 1);
            
            int left_results[MAX_RESULTS], left_count;
            int right_results[MAX_RESULTS], right_count;
            
            diffWaysToCompute(left_expr, left_results, &left_count);
            diffWaysToCompute(right_expr, right_results, &right_count);
            
            for (int l = 0; l < left_count; l++) {
                for (int r = 0; r < right_count; r++) {
                    temp_results[*temp_count] = compute(left_results[l], right_results[r], expression[i]);
                    (*temp_count)++;
                }
            }
        }
    }
    
    if (*temp_count == 0) {
        temp_results[0] = atoi(expression);
        *temp_count = 1;
    }
    
    addToCache(expression, temp_results, *temp_count);
}

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

int main() {
    char expression[100];
    fgets(expression, sizeof(expression), stdin);
    
    char* start = strchr(expression, '"');
    if (start) start++;
    else start = expression;
    char* end = strrchr(start, '"');
    if (end) *end = '\0';
    else {
        end = strchr(start, '\n');
        if (end) *end = '\0';
    }
    
    int results[MAX_RESULTS];
    int result_count;
    diffWaysToCompute(start, results, &result_count);
    
    qsort(results, result_count, sizeof(int), compare);
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        printf("%d", results[i]);
        if (i < result_count - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < cache_size; i++) {
        free(cache[i].results);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 4^n)

Memoization reduces redundant calculations but we still explore all possible splits

✓ Linear Growth

Space Complexity

O(n * 4^n)

Space for memoization cache plus recursion stack and result storage

⚡ Linearithmic Space

Constraints

1 ≤ expression.length ≤ 20
expression consists of digits and the operator +, -, and *
All the integer values in the input expression are in the range [0, 99]
The number of different results ≤ 10⁴

68.3K Views

Medium Frequency

~25 min Avg. Time

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

Divide and Conquer with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler