Expression Add Operators

Expression Add Operators - Problem

Given a string num that contains only digits and an integer target, return all possibilities to insert the binary operators '+', '-', and/or '*' between the digits of num so that the resultant expression evaluates to the target value.

Note: Operands in the returned expressions should not contain leading zeros unless the operand is 0 itself. A number can contain multiple digits.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: 2*3+2 = 8 and 2+3*2 = 8. Both expressions evaluate to target 8.

Example 2 — Single Digit

$ Input: num = "3", target = 3

› Output: ["3"]

💡 Note: Only one way: the number itself equals the target.

Example 3 — No Solution

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

› Output: []

💡 Note: No combination of +, -, * operators can make 123 digits equal 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is tracking the last operand separately to handle multiplication precedence correctly. The backtracking approach recursively builds expressions while maintaining current sum and last operand state. Time: O(3^n), Space: O(n).

Common Approaches

✓ Backtracking with Precedence

⏱️ Time: O(3^n) Space: O(n)

Use backtracking to build expressions digit by digit, keeping track of current value and the last operand separately to handle multiplication precedence. This avoids generating all combinations upfront.

Generate All Combinations

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

For each position in the string, try all ways to form numbers (handling leading zeros), and for each split try all three operators. Evaluate each complete expression to check if it equals target.

Backtracking with Precedence — Algorithm Steps

For each position, try all possible number formations (no leading zeros)
For each number, try all three operators (+, -, *)
Track current sum and last operand to handle * precedence
Backtrack when we reach the end and check if sum equals target

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with first digit/number

Branch

Try +, -, * with next number

Track

Maintain sum and last operand for * precedence

Code -

solution.c — C

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

#define MAX_RESULTS 1000
#define MAX_PATH 100

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

void backtrack(char* num, int target, int index, char* path, 
               long long currentSum, long long lastOperand) {
    if (index == strlen(num)) {
        if (currentSum == target && resultCount < MAX_RESULTS) {
            strcpy(results[resultCount], path);
            resultCount++;
        }
        return;
    }
    
    char numStr[20];
    for (int i = index; i < strlen(num); i++) {
        strncpy(numStr, num + index, i - index + 1);
        numStr[i - index + 1] = '\0';
        
        // Skip numbers with leading zeros except "0" itself
        if (strlen(numStr) > 1 && numStr[0] == '0') {
            break;
        }
        
        long long currNum = atoll(numStr);
        
        if (index == 0) {
            // First number, no operator needed
            backtrack(num, target, i + 1, numStr, currNum, currNum);
        } else {
            char newPath[MAX_PATH];
            
            // Try addition
            sprintf(newPath, "%s+%s", path, numStr);
            backtrack(num, target, i + 1, newPath, currentSum + currNum, currNum);
            
            // Try subtraction
            sprintf(newPath, "%s-%s", path, numStr);
            backtrack(num, target, i + 1, newPath, currentSum - currNum, -currNum);
            
            // Try multiplication - handle precedence
            sprintf(newPath, "%s*%s", path, numStr);
            long long newSum = currentSum - lastOperand + (lastOperand * currNum);
            backtrack(num, target, i + 1, newPath, newSum, lastOperand * currNum);
        }
    }
}

char** solution(char* num, int target, int* returnSize) {
    resultCount = 0;
    if (strlen(num) > 0) {
        backtrack(num, target, 0, "", 0, 0);
    }
    
    *returnSize = resultCount;
    char** result = malloc(resultCount * sizeof(char*));
    for (int i = 0; i < resultCount; i++) {
        result[i] = malloc(strlen(results[i]) + 1);
        strcpy(result[i], results[i]);
    }
    
    return result;
}

int main() {
    char num[20];
    int target;
    
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    scanf("%d", &target);
    
    int returnSize;
    char** result = solution(num, target, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each digit position, try 3 operators in recursive calls

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n characters

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~25 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Precedence — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler