The core approach: Evaluate Reverse Polish Notation is solved using a stack in O(n) time and O(n) space. Scan tokens left to right: push numbers onto the stack. When an operator is encountered, pop two operands, apply the operation, and push the result. The single remaining value on the stack is the final answer.

You’re in a coding interview. The interviewer says: “Evaluate an arithmetic expression in Reverse Polish Notation.” This is a classic stack problem — operators consume the two operands on top of the stack. Recognizing the stack pattern makes the implementation trivially short, but the details — operand order and Python division truncation — are what separate clean answers from buggy ones.

---

Already know how to solve Evaluate Reverse Polish Notation? Try a Evaluate Reverse Polish Notation mock interview on Intervu →

The Problem

Evaluate an expression in Reverse Polish Notation (postfix notation). Valid operators are +, -, *, /. Integer division should truncate toward zero.

Example

Input: tokens = ["2","1","+","3","*"] Output: 9 — ((2 + 1) * 3) = 9

---

What Interviewers Are Actually Testing

Skill	What Interviewers Observe
Stack recognition	Do you immediately identify this as a stack problem?
Operand order	Do you pop operands in the correct order?
Integer division truncation	Do you truncate toward zero, not floor?
Clean code	Is the operator dispatch readable?

---

Step 1: The Key Insight

RPN is designed for stack-based evaluation. Push integers onto the stack. When you encounter an operator, pop two operands, apply the operator, and push the result. After processing all tokens, one number remains — that’s the answer.

---

Step 2: Operand Order

When popping for - and /, order matters:

• b = stack.pop() (right operand)
• a = stack.pop() (left operand)
• Result: a op b

---

Python Implementation

def evalRPN(tokens: list[str]) -> int:
    stack = []
    operators = {'+', '-', '*', '/'}

    for token in tokens:
        if token in operators:
            b = stack.pop()
            a = stack.pop()
            if token == '+':
                stack.append(a + b)
            elif token == '-':
                stack.append(a - b)
            elif token == '*':
                stack.append(a * b)
            elif token == '/':
                stack.append(int(a / b))  # truncate toward zero
        else:
            stack.append(int(token))

    return stack[0]

Division note: int(a / b) truncates toward zero. Python’s // floors toward negative infinity, which differs for negative results: int(7 / -2) = -3 (correct), but 7 // -2 = -4 (wrong).

---

Time & Space Complexity

Aspect	Complexity
Time	O(n) — single pass through tokens
Space	O(n) — stack holds at most n elements

---

Common Interview Mistakes

1. Wrong operand order. Pop b first (right), then a (left). a - b, not b - a.

2. Using // instead of int(a / b). Python’s // floors; the problem wants truncation toward zero.

3. Not converting tokens to integers. Tokens are strings — push int(token).

---

What a Strong Candidate Sounds Like

“This is a stack problem. I push numbers as I encounter them. When I see an operator, I pop two — the first pop is the right operand, the second is the left — apply the operator, and push the result. One subtlety: Python’s // floors toward negative infinity, but the problem wants truncation toward zero, so I use int(a / b) instead.”

---

Example Interview Dialogue

Interviewer: Why does division direction matter in Python?

Candidate: For positive numbers, // and truncation are identical. For negative results they differ: 7 // -2 = -4 (floor), but the problem expects -3 (truncate toward zero). int(7 / -2) = int(-3.5) = -3.

---

Related Problems to Practice

• Min Stack — Stack design with auxiliary state.
• Valid Parentheses — Classic stack matching.
• Basic Calculator — More complex expression evaluation with parentheses.

---

Frequently Asked Questions

What data structure is used to evaluate Reverse Polish Notation?

A Stack is universally the best data structure to evaluate postfix notation. You simply push incoming numbers onto the stack, and whenever an operator appears, you pop the top two numbers, evaluate them together, and push the newly calculated result back onto the stack.

What is a key pitfall when evaluating division in Reverse Polish Notation?

In languages like Python, floor division or standard division truncates towards negative infinity rather than towards zero. Candidates must specifically handle truncation toward zero to ensure division algorithms function correctly, especially with negative bounds.

Practice This in a Mock Interview

Evaluate RPN is fast if you recognize the stack pattern immediately. The main pitfall is division truncation in Python — know the int(a/b) vs. a//b distinction before your interview.

Start a mock interview for Evaluate Reverse Polish Notation on Intervu.

---

Further reading:

• How to Prepare for a Coding Interview in 2026, the complete roadmap
• Why LeetCode alone isn’t enough, and what to practice instead
• Practice any LeetCode problem as a live mock interview
• The Grind 75 Pathway, a structured study plan with AI practice links
• Browse all walkthroughs on GitHub, condensed solutions with code