Expression Add Operators - Practice Coding Problems

Expression Add Operators - Problem

You are given a string of digits and a target number. Your mission is to transform this string into a valid mathematical expression by inserting the operators +, -, and * between the digits to make the expression evaluate to the target value.

The Challenge:

You can split the digit string into multiple numbers (e.g., "123" can become "1", "2", "3" or "12", "3" or "1", "23", etc.)
No leading zeros allowed in numbers (except for single digit "0")
You must find all possible valid expressions that equal the target
Operator precedence matters: multiplication happens before addition/subtraction

Example: Given num = "123" and target = 6, valid expressions include "1+2+3", "1*2*3", etc.

Input & Output

basic_case.py — Python

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

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

💡 Note: Both expressions evaluate to 6: 1+2+3=6 and 1*2*3=6

complex_case.py — Python

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

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

💡 Note: 2+3*2 = 2+6 = 8 (multiplication first), and 2*3+2 = 6+2 = 8

edge_case.py — Python

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

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

💡 Note: Valid expressions: 1*0+5=0+5=5 and 10-5=5. Note '05' is invalid due to leading zero

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty expression, sum=0, prev=0

Build Numbers

At each digit, decide to continue current number or start new one

Add Operators

When starting new number, try +, -, and * operators

Handle Precedence

For *, undo previous operation and multiply instead

Check Target

When string is consumed, check if sum equals target

Key Takeaway

🎯 Key Insight: By tracking the running sum and previous operand during backtracking, we can handle operator precedence efficiently without needing to parse and evaluate complete expressions. This reduces the time complexity significantly while maintaining correctness.

Time & Space Complexity

Time Complexity

⏱️

O(4^n * n)

4^n possible expressions (3 operators + continue number at each position), n for evaluation

✓ Linear Growth

Space Complexity

O(4^n)

Space to store all generated expressions

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10
num consists of only digits
-2³¹ ≤ target ≤ 2³¹ - 1
No leading zeros in operands except single digit '0'
Return expressions in any order

Asked in

G Google 85 f Facebook 72 a Amazon 68 ⊞ Microsoft 45

The optimal solution uses backtracking with running evaluation to efficiently generate all valid expressions. The key insight is tracking both the cumulative sum and previous operand to handle multiplication precedence without expensive expression parsing. Time complexity is O(4ⁿ) where n is the string length, representing 4 choices at each position (continue number or add +, -, * operators).

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Possible Expressions	O(4^n * n)	O(4^n)	Generate every possible way to split numbers and place operators, then evaluate each expression
Backtracking with On-the-fly Evaluation	O(4^n)	O(n)	Use backtracking to build expressions while tracking running totals to handle operator precedence efficiently

Generate All Possible Expressions — Algorithm Steps

Generate all ways to split the digit string into numbers
For each split, generate all combinations of operators between numbers
Evaluate each complete expression using proper operator precedence
Collect expressions that evaluate to the target

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Generation

Try all ways to split '123' into numbers

Operator Placement

For each split, try all operator combinations

Expression Evaluation

Evaluate each complete expression

Target Check

Keep expressions that equal target

Code -

solution.c — C

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

#define MAX_RESULTS 1000
#define MAX_EXPR_LEN 100

char results[MAX_RESULTS][MAX_EXPR_LEN];
int resultCount = 0;

long long evaluate(char* expr) {
    char parts[50][20];
    int partCount = 0;
    char current[20] = "";
    int currentLen = 0;
    
    for (int i = 0; expr[i]; i++) {
        if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*') {
            if (currentLen > 0) {
                current[currentLen] = '\0';
                strcpy(parts[partCount++], current);
                currentLen = 0;
            }
            parts[partCount][0] = expr[i];
            parts[partCount][1] = '\0';
            partCount++;
        } else {
            current[currentLen++] = expr[i];
        }
    }
    if (currentLen > 0) {
        current[currentLen] = '\0';
        strcpy(parts[partCount++], current);
    }
    
    // Handle multiplication first
    for (int i = 1; i < partCount; i += 2) {
        if (parts[i][0] == '*') {
            long long left = atoll(parts[i-1]);
            long long right = atoll(parts[i+1]);
            long long result = left * right;
            sprintf(parts[i-1], "%lld", result);
            
            // Shift remaining parts
            for (int j = i; j < partCount - 2; j++) {
                strcpy(parts[j], parts[j+2]);
            }
            partCount -= 2;
            i -= 2;
        }
    }
    
    // Handle addition and subtraction
    long long result = atoll(parts[0]);
    for (int i = 1; i < partCount; i += 2) {
        char op = parts[i][0];
        long long val = atoll(parts[i+1]);
        if (op == '+') {
            result += val;
        } else {
            result -= val;
        }
    }
    
    return result;
}

void generateExpressions(char* num, int target, int pos, char* currentExpr, int exprLen) {
    if (pos == strlen(num)) {
        if (evaluate(currentExpr) == target) {
            strcpy(results[resultCount++], currentExpr);
        }
        return;
    }
    
    for (int end = pos + 1; end <= strlen(num); end++) {
        char number[20];
        strncpy(number, num + pos, end - pos);
        number[end - pos] = '\0';
        
        if (strlen(number) > 1 && number[0] == '0') continue;
        
        if (pos == 0) {
            strcpy(currentExpr, number);
            generateExpressions(num, target, end, currentExpr, strlen(number));
        } else {
            char ops[] = {'+', '-', '*'};
            for (int i = 0; i < 3; i++) {
                char newExpr[MAX_EXPR_LEN];
                sprintf(newExpr, "%s%c%s", currentExpr, ops[i], number);
                generateExpressions(num, target, end, newExpr, strlen(newExpr));
            }
        }
    }
}

char** addOperators(char* num, int target, int* returnSize) {
    resultCount = 0;
    char currentExpr[MAX_EXPR_LEN];
    generateExpressions(num, target, 0, currentExpr, 0);
    
    char** result = (char**)malloc(resultCount * sizeof(char*));
    for (int i = 0; i < resultCount; i++) {
        result[i] = (char*)malloc(strlen(results[i]) + 1);
        strcpy(result[i], results[i]);
    }
    *returnSize = resultCount;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n * n)

4^n possible expressions (3 operators + continue number at each position), n for evaluation

✓ Linear Growth

Space Complexity

O(4^n)

Space to store all generated expressions

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10
num consists of only digits
-2³¹ ≤ target ≤ 2³¹ - 1
No leading zeros in operands except single digit '0'
Return expressions in any order

89.0K Views

Medium-High 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

Generate All Possible Expressions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler