Minimize Result by Adding Parentheses to Expression

Minimize Result by Adding Parentheses to Expression - Problem

String Enumeration Medium

Given a mathematical expression in the form "<num1>+<num2>" where both numbers are positive integers, your goal is to minimize the result by strategically adding exactly one pair of parentheses.

The challenge lies in understanding that parentheses can split the numbers, not just group the entire addition. For example, with "247+38", you could place parentheses to create "2(47+3)8" which evaluates to 2 × 50 × 8 = 800.

Rules:

The left parenthesis must be placed to the left of the '+' sign
The right parenthesis must be placed to the right of the '+' sign
The resulting expression must be mathematically valid
Return any valid solution that produces the minimum result

Key Insight: Think of this as splitting num1 into left1 + right1 and num2 into left2 + right2, then computing left1 × (right1 + left2) × right2. When left1 or right2 are empty, they default to 1.

Input & Output

example_1.py — Basic Case

$ Input: expression = "247+38"

› Output: "(247+38)"

💡 Note: We can place parentheses at positions (0,2) to get "(247+38)" = 1×285×1 = 285. Other placements like "2(47+3)8" = 2×50×8 = 800 give larger results, so the minimum is achieved by wrapping the entire addition.

example_2.py — Split Strategy

$ Input: expression = "12+34"

› Output: "1(2+3)4"

💡 Note: Placing parentheses at positions (1,1) gives "1(2+3)4" = 1×5×4 = 20. This is better than "(12+34)" = 46 or "12(+34)" which would be invalid. The key is finding the right split points.

example_3.py — Edge Case

$ Input: expression = "1+1"

› Output: "(1+1)"

💡 Note: With single digits, we have limited options. "(1+1)" = 2 is optimal since any other placement like trying to split single digits would still result in the same or worse outcome.

Constraints

3 ≤ expression.length ≤ 10
expression consists of digits from '1' to '9' and '+'
expression starts and ends with a digit
expression contains exactly one '+' sign
The original expression and result fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Split at Plus

Identify the '+' sign and split the expression into left number and right number

Enumerate Positions

Try every possible position for left parenthesis (in num1) and right parenthesis (in num2)

Calculate Formula

For each position pair, compute: left_part × (middle_sum) × right_part

Find Minimum

Track the position combination that produces the smallest result

Key Takeaway

🎯 Key Insight: The problem transforms addition into multiplication by strategic parentheses placement, where empty outer sections become 1, often making full expression wrapping optimal for minimization.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach is brute force enumeration of all possible parentheses positions. Since the expression format is constrained, we try every valid placement and calculate left_multiplier × (sum_inside_parentheses) × right_multiplier, where empty parts default to 1. The key insight is that parentheses can split individual numbers, not just group the addition, leading to potentially much smaller results through strategic multiplication.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration (Optimal)	O(n²)	O(1)	Try all possible parentheses positions and find the minimum result

Brute Force Enumeration (Optimal) — Algorithm Steps

Find the position of the '+' sign in the expression
Split the expression into num1 and num2
Try every position for left parenthesis (0 to len(num1))
Try every position for right parenthesis (0 to len(num2))
For each combination, calculate: left × (right1 + left2) × right
Track the minimum result and corresponding expression
Return the expression that produces minimum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Expression

Split the expression at '+' to get num1 and num2

Try Positions

For each possible left parenthesis position in num1 and right parenthesis position in num2

Calculate Result

Compute left_part × (sum_in_parentheses) × right_part

Track Minimum

Keep track of the position combination that gives minimum result

Code -

solution.c — C

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

char* minimizeResult(char* expression) {
    int len = strlen(expression);
    int plusIdx = -1;
    
    // Find the '+' position
    for (int k = 0; k < len; k++) {
        if (expression[k] == '+') {
            plusIdx = k;
            break;
        }
    }
    
    char num1[20], num2[20];
    strncpy(num1, expression, plusIdx);
    num1[plusIdx] = '\0';
    strcpy(num2, expression + plusIdx + 1);
    
    int minResult = INT_MAX;
    char* bestExpr = (char*)malloc(100 * sizeof(char));
    
    int num1Len = strlen(num1);
    int num2Len = strlen(num2);
    
    // Try all possible positions for left and right parentheses
    for (int i = 0; i <= num1Len; i++) {
        for (int j = 0; j <= num2Len; j++) {
            char left1[20] = {0}, right1[20] = {0};
            char left2[20] = {0}, right2[20] = {0};
            
            // Split numbers
            strncpy(left1, num1, i);
            strcpy(right1, num1 + i);
            strncpy(left2, num2, j);
            strcpy(right2, num2 + j);
            
            // Calculate result
            int leftMult = (strlen(left1) == 0) ? 1 : atoi(left1);
            int rightMult = (strlen(right2) == 0) ? 1 : atoi(right2);
            int val1 = (strlen(right1) == 0) ? 0 : atoi(right1);
            int val2 = (strlen(left2) == 0) ? 0 : atoi(left2);
            
            int result = leftMult * (val1 + val2) * rightMult;
            
            if (result < minResult) {
                minResult = result;
                sprintf(bestExpr, "%s(%s+%s)%s", left1, right1, left2, right2);
            }
        }
    }
    
    return bestExpr;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try all combinations of left parenthesis positions (n) and right parenthesis positions (m), resulting in O(n×m) = O(n²) where n is the total length

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store current best result and temporary calculations

✓ Linear Space

28.4K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Enumeration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler