Basic Calculator II LeetCode Solution

Last updated on January 20th, 2025 at 11:11 pm

Here, we see a Basic Calculator II LeetCode Solution. This Leetcode problem is solved using different approaches in many programming languages, such as C++, Java, JavaScript, Python, etc.

List of all LeetCode Solution

Topics

String

Companies

Airbnb

Level of Question

Medium

Basic Calculator II LeetCode Solution

Basic Calculator II LeetCode Solution

1. Problem Statement

Given a string which represents an expression, evaluate this expression and return its value. 

The 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 [-231, 231 – 1].

Example 1:
Input: s = "3+2*2"
Output: 7

Example 2:
Input: s = " 3/2 "
Output: 1

Example 3:
Input: s = " 3+5 / 2 "
Output: 5

2. Coding Pattern Used in Solution

The coding pattern used in all the provided implementations is “Expression Evaluation”. This pattern involves parsing a mathematical expression (given as a string) and evaluating it based on operator precedence and associativity.

3. Code Implementation in Different Languages

3.1 Basic Calculator II C++

class Solution {
public:
    int calculate(string s) {
    istringstream in('+' + s + '+');
    long long total = 0, term = 0, n;
    char op;
    while (in >> op) {
        if (op == '+' or op == '-') {
            total += term;
            in >> term;
            term *= 44 - op;
        } else {
            in >> n;
            if (op == '*')
                term *= n;
            else
                term /= n;
        }
    }
    return total;
 }
};

3.2 Basic Calculator II Java

class Solution {
    public int calculate(String s) {
        if (s == null || s.length() == 0) return 0;
        int num = 0, tmp = 0, res = 0;
        char op = '+';
        for (char c : s.toCharArray()) {
            if (Character.isDigit(c)) {
                tmp = tmp*10 + c - '0';
            } else if (c != ' ') {
				//process the numerical value of string so far; based on what 'op' we have before it
                num = cal(num, tmp, op);
                if (c == '+' || c == '-') {
                    res += num;
                    num = 0;
                }
				// reset
                tmp = 0;
                op = c;
            }
        }
        return res + cal(num, tmp, op);
    }
    private int cal(int num, int tmp, char op) {
        if (op == '+') return num + tmp;
        else if (op == '-') return num - tmp;
        else if (op == '*') return num * tmp;
        else    return num / tmp;
    }
}

3.3 Basic Calculator II JavaScript

var calculate = function(s) {
  let stack = [];
  let num = '';
  let sign = null
  for(let i = 0; i <= s.length; i++){    
    const curr = s[i];
    if(curr === ' ') continue;
    if(!isNaN(curr)) num+=curr;
    if(isNaN(curr)){
      num = Number(num)
      switch(sign){
        case '+':
        case null:
          stack.push(num)
          break;
        case '-':
          stack.push(-num)
          break; 
        case '*':
          stack.push(stack.pop()*num)
          break;
        case '/':
          stack.push(parseInt(stack.pop()/num, 10))
          break;           
      }
      sign = curr;
      num = '';
    }
  }
  return stack.reduce((a,b)=>{
    return a+b
  },0)
};

3.4 Basic Calculator II Python

class Solution:
    def calculate(self, s: str) -> int:
        num = 0
        res = 0
        pre_op = '+'
        s+='+'
        stack = []
        for c in s:
            if c.isdigit():
                num = num*10 + int(c)
            elif c == ' ':
                    pass
            else:
                if pre_op == '+':
                    stack.append(num)
                elif pre_op == '-':
                    stack.append(-num)
                elif pre_op == '*':
                    operant = stack.pop()
                    stack.append((operant*num))
                elif pre_op == '/':
                    operant = stack.pop()
                    stack.append(math.trunc(operant/num))
                num = 0
                pre_op = c
        return sum(stack)

4. Time and Space Complexity

Time ComplexitySpace Complexity
C++O(n)O(1)
JavaO(n)O(1)
JavaScriptO(n)O(n)
PythonO(n)O(n)
  • It efficiently evaluates a mathematical expression string using a single pass through the string.
  • The time complexity is O(n) for all implementations, while the space complexity varies between O(1) (C++/Java) and O(n) (JavaScript/Python) depending on the use of a stack.
Scroll to Top