Basic Calculator II

You're given a string s containing a valid arithmetic expression. It is made of non-negative integers, the operators +, -, * and /, and any number of spaces. There are no parentheses and no unary minus signs.

Evaluate it with the usual precedence: * and / bind tighter than + and -, and operators of the same precedence are applied left to right. Integer division truncates toward zero, so 7 / 2 is 3 and -7 / 2 is -3.

Return the result as an integer. Don't use a built-in expression evaluator such as eval.

Without parentheses, an expression is a sum of terms, where each term is a run of numbers joined by * and /. For 9-8/4*3 the terms are +9 and -(8/4*3).

So read left to right and keep the term you're still building separately from the total. A number after + or - starts a new term (with that sign), which means the previous term is finished and can be added to the total. A number after * or / folds into the current term right away. Because you always know the operator before a number, you only ever need to remember one pending operator.

A stack works too: push each signed term and fold * / / into the top. The running-term version is the same idea with the stack collapsed into two variables, since only the top is ever touched.

def calculate(s: str) -> int:
    total = 0
    term = 0
    num = 0
    op = "+"
    for i, ch in enumerate(s):
        if ch.isdigit():
            num = num * 10 + int(ch)
        if ch in "+-*/" or i == len(s) - 1:
            if op == "+":
                total += term
                term = num
            elif op == "-":
                total += term
                term = -num
            elif op == "*":
                term *= num
            else:
                quotient = abs(term) // num
                term = quotient if term >= 0 else -quotient
            op = ch
            num = 0
    return total + term

function calculate(s) {
  let total = 0;
  let term = 0;
  let num = 0;
  let op = '+';
  for (let i = 0; i < s.length; i++) {
    const ch = s[i];
    if (ch >= '0' && ch <= '9') num = num * 10 + Number(ch);
    if ('+-*/'.includes(ch) || i === s.length - 1) {
      if (op === '+') {
        total += term;
        term = num;
      } else if (op === '-') {
        total += term;
        term = -num;
      } else if (op === '*') {
        term *= num;
      } else {
        term = Math.trunc(term / num);
      }
      op = ch;
      num = 0;
    }
  }
  return total + term;
}

Explain the structure before coding: "with no parentheses, it's a sum of terms, and each term is a product or quotient chain." Interviewers listen for whether you see why you only need one pending operator, instead of reaching for a full parser.

Call out truncation toward zero explicitly, and test a case where a negative term gets divided, like "1-6/4". That's the bug most Python solutions ship with.