Minimize Result by Adding Parentheses to Expression

Minimize Result by Adding Parentheses to Expression - Problem

String Enumeration Medium

You are given a 0-indexed string expression of the form "<num1>+<num2>" where <num1> and <num2> represent positive integers.

Add a pair of parentheses to expression such that after the addition of parentheses, expression is a valid mathematical expression and evaluates to the smallest possible value. The left parenthesis must be added to the left of '+' and the right parenthesis must be added to the right of '+'.

Return expression after adding a pair of parentheses such that expression evaluates to the smallest possible value. If there are multiple answers that yield the same result, return any of them.

The input has been generated such that the original value of expression, and the value of expression after adding any pair of parentheses that meets the requirements fits within a signed 32-bit integer.

Input & Output

Example 1 — Basic Case

$ Input: expression = "247+38"

› Output: "2(47+38)"

💡 Note: We can place parentheses as: (247+38)=285, 2(47+38)=2*85=170, 24(7+38)=24*45=1080. The minimum is 170.

Example 2 — Different Numbers

$ Input: expression = "12+34"

› Output: "1(2+34)"

💡 Note: Possible placements: (12+34)=46, 1(2+34)=1*36=36. The minimum is 36, so we return "1(2+34)".

Example 3 — Single Digits

$ Input: expression = "2+3"

› Output: "(2+3)"

💡 Note: Only one valid placement: (2+3)=5. This is the minimum and only option.

Constraints

1 ≤ expression.length ≤ 10
expression consists of digits and exactly one '+'
All numbers in expression are positive integers

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is that we need to try all valid parentheses placements since multiplication can make results smaller or larger unpredictably. Best approach is systematic enumeration with Time: O(n²), Space: O(1).

Common Approaches

✓ Enumerate All Positions

⏱️ Time: O(n²) Space: O(1)

For each possible position of the left parenthesis (before the '+') and each possible position of the right parenthesis (after the '+'), calculate the resulting expression value and track the minimum.

Systematic Enumeration

⏱️ Time: O(n²) Space: O(1)

The same enumeration approach but with more structured code. Since we need to check all possibilities to guarantee the minimum, this is essentially the optimal solution for this problem.

Enumerate All Positions — Algorithm Steps

Step 1: Find the '+' sign position in the expression
Step 2: Try all positions for '(' from start to before '+'
Step 3: Try all positions for ')' from after '+' to end
Step 4: For each combination, evaluate the expression and track minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Plus

Locate the '+' sign in expression

Try Positions

Test all valid (left, right) parentheses positions

Track Minimum

Keep the expression that gives smallest value

Code -

solution.c — C

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

int parseInt(const char* s) {
    if (strlen(s) == 0) return 0;
    return atoi(s);
}

char* solution(char* expression) {
    static char result[1000];
    char* plusPos = strchr(expression, '+');
    int plusIdx = plusPos - expression;
    int minVal = INT_MAX;
    
    // Try all positions for left parenthesis (from 0 to plus_idx)
    for (int left = 0; left <= plusIdx; left++) {
        // Try all positions for right parenthesis (from plus_idx+1 to len)
        for (int right = plusIdx + 1; right <= (int)strlen(expression); right++) {
            // The substring must contain the '+'
            char substring[1000];
            strncpy(substring, expression + left, right - left);
            substring[right - left] = '\0';
            if (strchr(substring, '+') == NULL) {
                continue;
            }
            
            // Create expression with parentheses
            char newExpr[1000];
            strncpy(newExpr, expression, left);
            newExpr[left] = '\0';
            strcat(newExpr, "(");
            strcat(newExpr, substring);
            strcat(newExpr, ")");
            strcat(newExpr, expression + right);
            
            // Parse parts
            char leftPart[1000];
            strncpy(leftPart, expression, left);
            leftPart[left] = '\0';
            
            char rightPart[1000];
            strcpy(rightPart, expression + right);
            
            // Parse middle part (the sum inside parentheses)
            char* plusInSubstring = strchr(substring, '+');
            char num1[1000], num2[1000];
            int plusPosInSubstring = plusInSubstring - substring;
            strncpy(num1, substring, plusPosInSubstring);
            num1[plusPosInSubstring] = '\0';
            strcpy(num2, substring + plusPosInSubstring + 1);
            
            if (strlen(num1) == 0 || strlen(num2) == 0) {
                continue;
            }
            
            int middleVal = parseInt(num1) + parseInt(num2);
            
            // Calculate final value
            int val;
            if (strlen(leftPart) == 0 && strlen(rightPart) == 0) {
                val = middleVal;
            } else if (strlen(leftPart) == 0) {
                if (strlen(rightPart) == 0) continue;
                val = middleVal * parseInt(rightPart);
            } else if (strlen(rightPart) == 0) {
                if (strlen(leftPart) == 0) continue;
                val = parseInt(leftPart) * middleVal;
            } else {
                val = parseInt(leftPart) * middleVal * parseInt(rightPart);
            }
            
            // Update minimum if this is better
            if (val < minVal) {
                minVal = val;
                strcpy(result, newExpr);
            }
        }
    }
    
    return result;
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    char* result = solution(expression);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop for left parenthesis position (n positions), inner loop for right parenthesis position (n positions)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track minimum value and best expression

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

800 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

Enumerate All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler