Basic Calculator II - Practice Coding Problems

Basic Calculator II - Problem

🧮 Build Your Own Calculator

You're tasked with creating a mathematical expression evaluator that can handle basic arithmetic operations. Given a string s containing an expression with integers and operators (+, -, *, /), your job is to evaluate it and return the result.

Key Requirements:

Handle operator precedence correctly (* and / before + and -)
Integer division should truncate toward zero (not floor division)
No built-in eval() functions allowed
All expressions are guaranteed to be valid

Example: "3+2*2" should return 7 (not 10), because multiplication has higher precedence.

Input & Output

example_1.py — Basic Expression

$ Input: s = "3+2*2"

› Output: 7

💡 Note: Multiplication has higher precedence: 3 + (2*2) = 3 + 4 = 7

example_2.py — Division with Truncation

$ Input: s = "3/2"

› Output: 1

💡 Note: Integer division truncates toward zero: 3/2 = 1.5 → 1

example_3.py — Complex Expression

$ Input: s = "3+5/2"

› Output: 5

💡 Note: Division first, then addition: 3 + (5/2) = 3 + 2 = 5

Visualization

Tap to expand

Understanding the Visualization

Scan & Build Numbers

Read digits and build complete numbers while tracking the last operator

Decision Point

When encountering an operator, decide: compute now (*, /) or defer (+, -)?

Stack Management

High precedence ops modify stack top immediately, low precedence ops add to stack

Final Computation

Sum everything in the stack - all precedence has been handled!

Key Takeaway

🎯 Key Insight: The stack approach elegantly solves precedence by making high-precedence operations execute immediately while deferring low-precedence operations. This transforms a complex parsing problem into simple stack operations!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n/2 numbers in worst case (alternating numbers and + operators)

⚡ 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 the integers in the expression are non-negative integers in the range [0, 2³¹ - 1]
The answer is guaranteed to fit in a 32-bit integer

Asked in

G Google 48 a Amazon 35 f Facebook 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses a stack-based approach to handle operator precedence in a single pass. For addition and subtraction, we push numbers to the stack with appropriate signs. For multiplication and division, we immediately compute the result with the stack's top element. Finally, we sum all stack values. This naturally respects precedence rules while maintaining O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Single Pass (Optimal)	O(n)	O(n)	Use a stack to handle operator precedence in one pass through the expression

Stack-Based Single Pass (Optimal) — Algorithm Steps

Initialize a stack and variables for current number and last operator
Iterate through each character in the expression
Build numbers digit by digit, ignoring spaces
When encountering an operator or at the end:
- For + or -, push number to stack (with sign based on last operator)
- For * or /, pop from stack, compute result, push back
Sum all values in the stack for final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Numbers

Build numbers digit by digit as we scan

Handle Low Precedence

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

Handle High Precedence

For * and /, immediately compute with stack top

Final Sum

Sum all remaining values in stack

Code -

solution.c — C

int calculate(char* s) {
    if (!s || !*s) return 0;
    
    int stack[10000];
    int top = -1;
    int num = 0;
    char op = '+';
    
    for (int i = 0; s[i]; i++) {
        char c = s[i];
        
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        }
        
        if (c == '+' || c == '-' || c == '*' || c == '/' || s[i+1] == '\0') {
            if (op == '+') {
                stack[++top] = num;
            } else if (op == '-') {
                stack[++top] = -num;
            } else if (op == '*') {
                stack[top] *= num;
            } else if (op == '/') {
                stack[top] /= num;
            }
            
            op = c;
            num = 0;
        }
    }
    
    int result = 0;
    for (int i = 0; i <= top; i++) {
        result += stack[i];
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n/2 numbers in worst case (alternating numbers and + operators)

⚡ 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 the integers in the expression are non-negative integers in the range [0, 2³¹ - 1]
The answer is guaranteed to fit in a 32-bit integer

142.4K Views

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

🧮 Build Your Own Calculator

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-Based Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler