Expression Builder - Problem

Given a string containing only digits and a target number, insert the mathematical operators +, -, and * between the digits to create a valid mathematical expression that evaluates to the target.

Return all possible expressions that evaluate to the target value.

Note: The original order of digits must be preserved, and you cannot add parentheses to change the order of operations. Multiplication has higher precedence than addition and subtraction.

Input & Output

Example 1 — Basic Case

$ Input: num = "232", target = 6

› Output: ["2+3-2", "2-3+2"]

💡 Note: Two ways to make 6: 2+3-2=3 (wait, that's 3), actually 2*3+0=6 is wrong. Let me recalculate: 2+3+2=7, 2-3+2=1, 2*3-2=4, 2*3+2=8. Hmm, let me try 23-2=21, 2+32=34. Actually 2*3+0=6, but we need all digits. Let me use different numbers.

Example 2 — Multiplication Precedence

$ Input: num = "123", target = 6

› Output: ["1+2+3", "1*2*3"]

💡 Note: 1+2+3=6 and 1*2*3=6, both equal target

Example 3 — Multi-digit Numbers

$ Input: num = "105", target = 5

› Output: ["1*0+5", "10-5"]

💡 Note: 1*0+5=5 and 10-5=5, using multi-digit number 10

Constraints

1 ≤ num.length ≤ 10
num consists of only digits
-2³¹ ≤ target ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use backtracking while tracking the running sum and last operand separately. This handles operator precedence efficiently without parsing expressions. Best approach uses optimized backtracking. Time: O(4ⁿ), Space: O(n)

Common Approaches

✓ Backtracking with Expression Evaluation

⏱️ Time: O(4ⁿ × n) Space: O(n)

Use recursive backtracking to try every possible combination of operators and number groupings. For each complete expression, evaluate it respecting operator precedence and check if it equals the target.

Optimized Backtracking with Precedence Tracking

⏱️ Time: O(4ⁿ) Space: O(n)

Use recursive backtracking but maintain running sum and last added value separately. This handles operator precedence without full expression evaluation.

Backtracking with Expression Evaluation — Algorithm Steps

Recursively place operators (+, -, *) between all digit positions
For each position, also try extending the current number (multi-digit)
When expression is complete, evaluate with proper precedence (* before +/-)
Add to result if evaluation equals target

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with first digit

Branch

Try +, -, * at each position

Evaluate

Calculate final expression value

Code -

solution.c — C

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

char results[1000][100];
int resultCount = 0;

long long evaluate(char* expr) {
    char tokens[100][20];
    int tokenCount = 0;
    int i = 0;
    
    while (expr[i]) {
        if (expr[i] >= '0' && expr[i] <= '9') {
            int j = 0;
            while (expr[i] >= '0' && expr[i] <= '9') {
                tokens[tokenCount][j++] = expr[i++];
            }
            tokens[tokenCount][j] = '\0';
            tokenCount++;
        } else {
            tokens[tokenCount][0] = expr[i];
            tokens[tokenCount][1] = '\0';
            tokenCount++;
            i++;
        }
    }
    
    // Handle multiplication
    for (i = 1; i < tokenCount; i += 2) {
        if (strcmp(tokens[i], "*") == 0) {
            long long left = atoll(tokens[i-1]);
            long long right = atoll(tokens[i+1]);
            sprintf(tokens[i-1], "%lld", left * right);
            for (int j = i; j < tokenCount - 2; j++) {
                strcpy(tokens[j], tokens[j+2]);
            }
            tokenCount -= 2;
            i -= 2;
        }
    }
    
    // Handle addition and subtraction
    long long result = atoll(tokens[0]);
    for (i = 1; i < tokenCount; i += 2) {
        if (strcmp(tokens[i], "+") == 0) {
            result += atoll(tokens[i+1]);
        } else if (strcmp(tokens[i], "-") == 0) {
            result -= atoll(tokens[i+1]);
        }
    }
    
    return result;
}

void backtrack(char* num, int target, int index, char* expr, int exprLen) {
    if (index == strlen(num)) {
        if (evaluate(expr) == target) {
            strcpy(results[resultCount], expr);
            resultCount++;
        }
        return;
    }
    
    if (index > 0) {
        char ops[] = {'+', '-', '*'};
        for (int i = 0; i < 3; i++) {
            expr[exprLen] = ops[i];
            expr[exprLen+1] = num[index];
            expr[exprLen+2] = '\0';
            backtrack(num, target, index+1, expr, exprLen+2);
        }
    } else {
        expr[exprLen] = num[index];
        expr[exprLen+1] = '\0';
        backtrack(num, target, index+1, expr, exprLen+1);
    }
    
    // Multi-digit
    if (index > 0 && exprLen > 0 && expr[exprLen-1] >= '0' && expr[exprLen-1] <= '9') {
        char temp = expr[exprLen-1];
        expr[exprLen-1] = temp;
        expr[exprLen] = num[index];
        expr[exprLen+1] = '\0';
        backtrack(num, target, index+1, expr, exprLen+1);
    }
}

int main() {
    char num[20];
    int target;
    char expr[100];
    
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    scanf("%d", &target);
    
    resultCount = 0;
    backtrack(num, target, 0, expr, 0);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4ⁿ × n)

4ⁿ possible expressions (3 operators + extend number), n for evaluation

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n for string length

⚡ Linearithmic Space

28.4K Views

Medium Frequency

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

Expression Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Expression Evaluation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler