Basic Calculator III - Practice Coding Problems

Basic Calculator III - Problem

Build a Mathematical Expression Evaluator

You're tasked with implementing a basic calculator that can evaluate complex mathematical expressions containing:

• Non-negative integers (e.g., 123, 0, 99)
• Basic operators: +, -, *, /
• Parentheses for grouping: ( and )

The calculator must respect operator precedence (multiplication and division before addition and subtraction) and handle nested parentheses. For division, use integer division that truncates toward zero (e.g., 7/3 = 2, -7/3 = -2).

Goal: Parse the expression string and return the calculated result as an integer.

Example: "2*(5+5*2)/3+(6/2+8)" should evaluate to 21

Input & Output

example_1.py — Basic Expression

$ Input: s = "1 + 1"

› Output: 2

💡 Note: Simple addition of two numbers gives us 2

example_2.py — Expression with Precedence

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

› Output: 4

💡 Note: Division has higher precedence: 6 - (4/2) = 6 - 2 = 4

example_3.py — Complex with Parentheses

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

› Output: 21

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed once

✓ Linear Growth

Space Complexity

O(n)

Stack space for intermediate numbers and recursion depth for parentheses

⚡ Linearithmic Space

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 [-2³¹, 2³¹ - 1]
Integer division should truncate toward zero

Asked in

The optimal solution uses a single-pass stack approach that handles operator precedence elegantly. For high-precedence operations (*, /), we compute immediately with the stack top. For low-precedence operations (+, -), we push numbers to the stack with appropriate signs. Parentheses are handled recursively, and the final result is the sum of all stack elements. This achieves O(n) time complexity with clean, maintainable code.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Stack Solution (Optimal)	O(n)	O(n)	Single stack approach handling precedence and parentheses in one pass
Brute Force (Recursive Parsing)	O(n²)	O(n)	Recursively parse and evaluate the expression without optimization
Stack-Based Two-Pass Approach	O(n)	O(n)	Use one stack for numbers and another for operators, processing in two phases

One-Pass Stack Solution (Optimal) — Algorithm Steps

Use one stack to store numbers for addition/subtraction
Track current number and last operator
For * and /, compute immediately with last stack element
For + and -, push current number to stack (with sign)
Handle parentheses with recursive calls
Sum the stack at the end for final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Start with empty stack and '+' operator

Process Numbers

Build multi-digit numbers character by character

Handle High Precedence

For * and /, compute immediately with stack top

Handle Low Precedence

For + and -, push number to stack with appropriate sign

Sum Stack

Final result is sum of all stack elements

Code -

solution.c — C

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

int helper(char* s, int* index) {
    int stack[1000];
    int top = -1;
    int num = 0;
    char op = '+';
    int len = strlen(s);
    
    while (*index < len) {
        char c = s[*index];
        
        if (c == ' ') {
            (*index)++;
            continue;
        }
        
        if (isdigit(c)) {
            num = num * 10 + (c - '0');
        }
        
        if (c == '(') {
            (*index)++;
            num = helper(s, index);
        }
        
        if (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || *index == len - 1) {
            switch (op) {
                case '+':
                    stack[++top] = num;
                    break;
                case '-':
                    stack[++top] = -num;
                    break;
                case '*':
                    stack[top] *= num;
                    break;
                case '/':
                    stack[top] /= num;
                    break;
            }
            
            if (c == ')') {
                break;
            }
            
            op = c;
            num = 0;
        }
        
        (*index)++;
    }
    
    int result = 0;
    for (int i = 0; i <= top; i++) {
        result += stack[i];
    }
    return result;
}

int calculate(char* s) {
    int index = 0;
    return helper(s, &index);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed once

✓ Linear Growth

Space Complexity

O(n)

Stack space for intermediate numbers and recursion depth for parentheses

⚡ Linearithmic Space

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 [-2³¹, 2³¹ - 1]
Integer division should truncate toward zero

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Stack Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler