Evaluate Reverse Polish Notation

Evaluate Reverse Polish Notation - Problem

You are given an array of strings tokens that represents an arithmetic expression in Reverse Polish Notation.

Evaluate the expression and return an integer that represents the value of the expression.

Note that:

The valid operators are '+', '-', '*', and '/'
Each operand may be an integer or another expression
The division between two integers always truncates toward zero
There will not be any division by zero
The input represents a valid arithmetic expression in reverse polish notation
The answer and all intermediate calculations can be represented in a 32-bit integer

Input & Output

Example 1 — Basic RPN Expression

$ Input: tokens = ["2","1","+","3","*"]

› Output: 9

💡 Note: Step by step: Push 2, push 1, encounter '+' so pop 1 and 2, compute 2+1=3, push 3. Push 3, encounter '*' so pop 3 and 3, compute 3*3=9, push 9. Result is 9.

Example 2 — Division with Truncation

$ Input: tokens = ["4","13","5","/","+"]

› Output: 6

💡 Note: Push 4, push 13, push 5, encounter '/' so pop 5 and 13, compute 13/5=2 (truncated), push 2. Encounter '+' so pop 2 and 4, compute 4+2=6.

Example 3 — Negative Result

$ Input: tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]

› Output: 22

💡 Note: Complex expression that evaluates through multiple stack operations, handling negative numbers and multiple operators.

Constraints

1 ≤ tokens.length ≤ 10⁴
tokens[i] is either an operator: "+", "-", "*", or "/", or an integer in the range [-200, 200]

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18 G Google 15 f Facebook 12

The key insight is that Reverse Polish Notation naturally maps to stack operations - operands are pushed onto a stack, and when an operator is encountered, the required number of operands are popped, the operation is performed, and the result is pushed back. Best approach is the stack-based solution with Time: O(n), Space: O(n).

Common Approaches

✓ Heap

⏱️ Time: N/A Space: N/A

Recursive Parsing

⏱️ Time: O(n) Space: O(n)

Build an expression tree by parsing tokens recursively, then evaluate the tree. This approach treats each operator as a node with two operand children.

Stack-Based Evaluation

⏱️ Time: O(n) Space: O(n)

Iterate through tokens linearly. Push numbers onto stack, and when encountering an operator, pop two operands, compute result, and push back onto stack.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int stack[1000];
static int stackSize = 0;

void push(int val) {
    stack[stackSize++] = val;
}

int pop() {
    return stack[--stackSize];
}

int isOperator(const char* token) {
    return (strlen(token) == 1 && (token[0] == '+' || token[0] == '-' || token[0] == '*' || token[0] == '/'));
}

int evalRPN(char tokens[][100], int tokensSize) {
    stackSize = 0;
    
    for (int i = 0; i < tokensSize; i++) {
        if (isOperator(tokens[i])) {
            int b = pop();
            int a = pop();
            int result;
            
            switch (tokens[i][0]) {
                case '+':
                    result = a + b;
                    break;
                case '-':
                    result = a - b;
                    break;
                case '*':
                    result = a * b;
                    break;
                case '/':
                    // Division truncates toward zero
                    result = a / b;
                    break;
            }
            push(result);
        } else {
            // It's a number
            int num = atoi(tokens[i]);
            push(num);
        }
    }
    
    return pop();
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = '\0';
    
    // Parse tokens from format ["2","1","+","3","*"]
    static char tokens[100][100];
    int tokensSize = 0;
    
    // Find the opening bracket
    char* start = strchr(line, '[');
    if (start) {
        start++; // Skip '['
        
        char* current = start;
        while (*current && *current != ']') {
            // Skip whitespace and commas
            while (*current == ' ' || *current == ',') current++;
            
            if (*current == '"') {
                current++; // Skip opening quote
                char* tokenStart = current;
                
                // Find closing quote
                while (*current && *current != '"') current++;
                
                if (*current == '"') {
                    // Copy token
                    int len = current - tokenStart;
                    strncpy(tokens[tokensSize], tokenStart, len);
                    tokens[tokensSize][len] = '\0';
                    tokensSize++;
                    current++; // Skip closing quote
                }
            } else if (*current == ']') {
                break;
            } else {
                current++;
            }
        }
    }
    
    int result = evalRPN(tokens, tokensSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

185.0K Views

Medium Frequency

~15 min Avg. Time

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