Basic Calculator - Practice Coding Problems

Basic Calculator - Problem

You're building a smart calculator that can evaluate mathematical expressions from strings! Given a string s representing a valid mathematical expression, your task is to implement a basic calculator that can handle:

Addition (+) and subtraction (-)
Parentheses for grouping operations
Spaces that should be ignored

For example, "1 + 1" should return 2, and "(1+(4+5+2)-3)+(6+8)" should return 23.

Important: You cannot use built-in functions like eval() - you need to parse and evaluate the expression yourself!

This is a classic problem that tests your understanding of expression parsing, operator precedence, and data structures like stacks.

Input & Output

example_1.py — Simple Addition

$ Input: s = "1 + 1"

› Output: 2

💡 Note: Basic addition with spaces that should be ignored

example_2.py — Subtraction

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

› Output: 3

💡 Note: Mixed addition and subtraction: 2 - 1 + 2 = 1 + 2 = 3

example_3.py — Nested Parentheses

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

› Output: 23

💡 Note: Complex nested expression: inner (4+5+2)=11, then (1+11-3)=9, finally 9+(6+8)=9+14=23

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with result=0, number=0, sign=1, empty stack

Build Numbers

Accumulate digits to form complete numbers

Apply Operations

When hitting +/-, add current number to result and update sign

Handle Parentheses

Push current state on '(', pop and combine on ')'

Key Takeaway

🎯 Key Insight: The stack acts as a memory device - save your progress when diving into parentheses, restore and combine when coming back out!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each level of parentheses (O(n)), we scan the entire string (O(n)) and create new strings (O(n))

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls and string creation at each level

⚠ Quadratic Space

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)" is valid)
There will be no two consecutive operators in the input
Every number and running calculation will fit in a signed 32-bit integer

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The stack-based approach is optimal with O(n) time and O(n) space complexity. Use a stack to save the current result and sign when entering parentheses, then restore and combine when exiting. This handles nested parentheses elegantly in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Parsing (Brute Force)	O(n³)	O(n²)	Recursively handle each parentheses group by finding matching pairs
Stack-Based Parser (Optimal)	O(n)	O(n)	Use a stack to handle parentheses and track signs efficiently in one pass

Recursive Parsing (Brute Force) — Algorithm Steps

Find the innermost parentheses in the expression
Evaluate the expression inside those parentheses
Replace the parentheses and content with the result
Repeat until no parentheses remain
Evaluate the final expression left to right

Visualization

Tap to expand

Step-by-Step Walkthrough

Find innermost ()

Scan for the first ')' and its matching '('

Evaluate inside

Calculate the expression within those parentheses

Replace with result

Substitute the entire parentheses group with the calculated value

Repeat until done

Continue until no parentheses remain

Code -

solution.c — C

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

int evaluateSimple(char* expr) {
    int result = 0, num = 0, sign = 1;
    int len = strlen(expr);
    
    for (int i = 0; i < len; i++) {
        char c = expr[i];
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '+' || c == '-') {
            result += sign * num;
            sign = (c == '+') ? 1 : -1;
            num = 0;
        }
    }
    
    result += sign * num;
    return result;
}

int calculate(char* s) {
    int len = strlen(s);
    char* temp = malloc(len + 1);
    int j = 0;
    
    // Remove spaces
    for (int i = 0; i < len; i++) {
        if (s[i] != ' ') {
            temp[j++] = s[i];
        }
    }
    temp[j] = '\0';
    
    while (strchr(temp, '(')) {
        int start = -1, end = -1;
        len = strlen(temp);
        
        for (int i = 0; i < len; i++) {
            if (temp[i] == '(') start = i;
            else if (temp[i] == ')') {
                end = i;
                break;
            }
        }
        
        if (start != -1) {
            char innerExpr[1000];
            strncpy(innerExpr, temp + start + 1, end - start - 1);
            innerExpr[end - start - 1] = '\0';
            
            int result = evaluateSimple(innerExpr);
            char resultStr[100];
            sprintf(resultStr, "%d", result);
            
            char newTemp[1000];
            strncpy(newTemp, temp, start);
            newTemp[start] = '\0';
            strcat(newTemp, resultStr);
            strcat(newTemp, temp + end + 1);
            strcpy(temp, newTemp);
        }
    }
    
    int result = evaluateSimple(temp);
    free(temp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each level of parentheses (O(n)), we scan the entire string (O(n)) and create new strings (O(n))

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls and string creation at each level

⚠ Quadratic Space

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)" is valid)
There will be no two consecutive operators in the input
Every number and running calculation will fit in a signed 32-bit integer

38.5K Views

High Frequency

~25 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Parsing (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler