Basic Calculator III

Basic Calculator III - Problem

Implement a basic calculator to evaluate a simple expression string.

The expression string contains only:

Non-negative integers
'+', '-', '*', '/' operators
Open '(' and closing parentheses ')'

Important notes:

Integer division should truncate toward zero
You may assume that the given expression is always valid
All intermediate results will be in the range of [-2³¹, 2³¹ - 1]
You are not allowed to use any built-in function which evaluates strings as mathematical expressions, such as eval()

Input & Output

Example 1 — Basic Expression with Parentheses

$ Input: s = "1 + 1"

› Output: 2

💡 Note: Simple addition: 1 + 1 = 2

Example 2 — Complex Expression with All Operations

$ Input: s = "6-4/2"

› Output: 4

💡 Note: Following order of operations: 6 - (4/2) = 6 - 2 = 4

Example 3 — Nested Parentheses

$ Input: s = "2*(5+5*2)/3+(6/2+8)"

› Output: 21

💡 Note: Step by step: 2*(5+10)/3+(3+8) = 2*15/3+11 = 30/3+11 = 10+11 = 21

Constraints

1 ≤ s.length ≤ 3 × 10⁴
s consists of integers and operators ('+', '-', '*', '/', '(', ')') separated by some number of spaces
s represents a valid expression
All intermediate results will be in the range of [-2³¹, 2³¹ - 1]
You are guaranteed that no division by zero will occur

Visualization

Tap to expand

Asked in

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

The key insight is to use a stack-based approach that handles operator precedence naturally. Parse the expression left-to-right, using the stack to manage operands while applying operators based on precedence rules. For parentheses, use recursion to evaluate sub-expressions. Best approach is Stack-Based Evaluation with Time: O(n), Space: O(n).

Common Approaches

✓ Recursive Parsing with Multiple Passes

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

Use recursive approach where each parentheses group is evaluated separately. Parse numbers and operators step by step, creating multiple recursive calls for nested expressions.

Stack-Based Evaluation

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

Parse expression left to right, using stack to manage operators based on precedence. Handle parentheses by recursive calls or separate stacks for different precedence levels.

Recursive Parsing with Multiple Passes — Algorithm Steps

Step 1: Find and evaluate innermost parentheses first
Step 2: Replace evaluated parts with results
Step 3: Continue until no parentheses remain
Step 4: Evaluate final expression left to right

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Innermost

Locate innermost parentheses group

Evaluate

Calculate result of that group

Replace

Substitute result and recurse

Code -

solution.c — C

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

int evaluateSimple(char* expr) {
    int len = strlen(expr);
    if (len == 0) return 0;
    
    int numbers[1000];
    char operators[1000];
    int numCount = 0, opCount = 0;
    int i = 0;
    
    while (i < len) {
        if (isdigit(expr[i])) {
            int num = 0;
            while (i < len && isdigit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            numbers[numCount++] = num;
        } else if (expr[i] != ' ') {
            operators[opCount++] = expr[i];
            i++;
        } else {
            i++;
        }
    }
    
    // Handle * and /
    int j = 0;
    while (j < opCount) {
        if (operators[j] == '*') {
            numbers[j] = numbers[j] * numbers[j + 1];
            for (int k = j + 1; k < numCount - 1; k++) {
                numbers[k] = numbers[k + 1];
            }
            for (int k = j; k < opCount - 1; k++) {
                operators[k] = operators[k + 1];
            }
            numCount--;
            opCount--;
        } else if (operators[j] == '/') {
            numbers[j] = numbers[j] / numbers[j + 1];
            for (int k = j + 1; k < numCount - 1; k++) {
                numbers[k] = numbers[k + 1];
            }
            for (int k = j; k < opCount - 1; k++) {
                operators[k] = operators[k + 1];
            }
            numCount--;
            opCount--;
        } else {
            j++;
        }
    }
    
    // Handle + and -
    int result = numbers[0];
    for (int k = 0; k < opCount; k++) {
        if (operators[k] == '+') {
            result += numbers[k + 1];
        } else {
            result -= numbers[k + 1];
        }
    }
    
    return result;
}

char* solveRecursive(char* expr) {
    char* result = malloc(1000);
    char* parenPos = strchr(expr, '(');
    
    if (parenPos == NULL) {
        sprintf(result, "%d", evaluateSimple(expr));
        return result;
    }
    
    int start = -1;
    int len = strlen(expr);
    for (int i = 0; i < len; i++) {
        if (expr[i] == '(') {
            start = i;
        } else if (expr[i] == ')') {
            char inner[1000];
            strncpy(inner, expr + start + 1, i - start - 1);
            inner[i - start - 1] = '\0';
            
            int innerResult = evaluateSimple(inner);
            
            char* newExpr = malloc(1000);
            strncpy(newExpr, expr, start);
            newExpr[start] = '\0';
            sprintf(newExpr + start, "%d%s", innerResult, expr + i + 1);
            
            char* finalResult = solveRecursive(newExpr);
            free(newExpr);
            free(result);
            return finalResult;
        }
    }
    
    sprintf(result, "%d", evaluateSimple(expr));
    return result;
}

int solution(char* s) {
    char* resultStr = solveRecursive(s);
    int result = atoi(resultStr);
    free(resultStr);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes through string, string replacement operations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to nesting level

⚡ Linearithmic Space

78.0K Views

High Frequency

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

Recursive Parsing with Multiple Passes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler