Basic Calculator

Basic Calculator - Problem

Given a string s representing a valid mathematical expression, implement a basic calculator to evaluate it and return the result.

The expression contains:

Non-negative integers
Addition (+) and subtraction (-) operators
Parentheses ( and ) for grouping
Spaces (which should be ignored)

Note: 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

$ Input: s = "1 + 1"

› Output: 2

💡 Note: Simple addition: 1 + 1 = 2

Example 2 — With Parentheses

$ Input: s = " 2-1 + 2 "

› Output: 3

💡 Note: Left to right evaluation: 2 - 1 + 2 = 1 + 2 = 3

Example 3 — Nested Parentheses

$ Input: s = "(1+(4+5+2)-3)+(6+8)"

› Output: 23

💡 Note: Inner parentheses first: (4+5+2)=11, then (1+11-3)=9, finally 9+14=23

Constraints

1 ≤ s.length ≤ 3 × 10⁵
s consists of digits, '+', '-', '(', ')', and ' '
s represents a valid expression
'+' is not used as a unary operation
'-' could be used as a unary operation (i.e., "-1" and "-(2 + 3)" are valid)
There will be no two consecutive operators in the input
Every number and running calculation will fit in a 32-bit integer

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is to use a stack to manage state across different parentheses levels. Best approach is the stack-based solution which processes each character once while maintaining previous results and signs. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Parsing	O(n)	O(n)	Use recursion to evaluate expressions inside parentheses first
Stack-Based Approach	O(n)	O(n)	Use stack to track signs and partial results at each parentheses level

Recursive Parsing — Algorithm Steps

Parse characters one by one
Use recursion for parentheses
Track current number and operation
Return result when parentheses close

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Characters

Process each character, building numbers and applying operations

Handle Parentheses

Recursively evaluate expressions inside parentheses

Return Result

Return the computed value back to parent level

Code -

solution.c — C

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

typedef struct {
    int index;
    const char* s;
} Calculator;

int parse(Calculator* calc) {
    int result = 0;
    int sign = 1;
    int num = 0;
    int len = strlen(calc->s);
    
    while (calc->index < len) {
        char c = calc->s[calc->index];
        
        if (isdigit(c)) {
            num = num * 10 + (c - '0');
        } else if (c == '+') {
            result += sign * num;
            num = 0;
            sign = 1;
        } else if (c == '-') {
            result += sign * num;
            num = 0;
            sign = -1;
        } else if (c == '(') {
            calc->index++;
            result += sign * parse(calc);
            num = 0;
        } else if (c == ')') {
            result += sign * num;
            calc->index++;
            return result;
        }
        
        calc->index++;
    }
    
    return result + sign * num;
}

int solution(const char* s) {
    Calculator calc = {0, s};
    return parse(&calc);
}

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)

Each character is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can be O(n) with nested parentheses

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

2.1K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler