Evaluate Reverse Polish Notation - Practice Coding Problems

Evaluate Reverse Polish Notation - Problem

Reverse Polish Notation (RPN) is a mathematical notation where operators come after their operands, eliminating the need for parentheses. For example, the infix expression 3 + 4 becomes 3 4 + in RPN.

You are given an array of strings tokens that represents an arithmetic expression in Reverse Polish Notation. Your task is to evaluate this expression and return the result as an integer.

Supported Operations:
• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/) - always truncates toward zero

Example: ["2", "1", "+", "3", "*"] evaluates to 9
Step by step: 2 1 + → 3, then 3 3 * → 9

Input & Output

example_1.py — Basic RPN Expression

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

› Output: 9

💡 Note: Step-by-step: Push 2, push 1, then '+' pops 1 and 2, computes 2+1=3, pushes 3. Push 3, then '*' pops 3 and 3, computes 3*3=9, pushes 9. Final result is 9.

example_2.py — Division with Truncation

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

› Output: 6

💡 Note: Step-by-step: Push 4, push 13, push 5. '/' pops 5 and 13, computes 13/5=2 (truncated), pushes 2. '+' pops 2 and 4, computes 4+2=6, pushes 6.

example_3.py — Complex Expression

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

› Output: 22

💡 Note: This complex expression evaluates through multiple stack operations: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 = 22

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty stack and first token

Process Numbers

Push numbers onto the stack as they appear

Process Operators

Pop two operands, calculate, push result

Continue

Repeat until all tokens are processed

Return Result

The final stack contains exactly one element - the answer

Key Takeaway

🎯 Key Insight: The stack's LIFO behavior perfectly matches RPN's evaluation order - most recent operands are used first!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each token is processed exactly once, each stack operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

Stack can grow up to the size of input in worst case (all numbers)

⚡ Linearithmic Space

Constraints

1 ≤ tokens.length ≤ 10⁴
tokens[i] is either an operator: "+", "-", "*", or "/", or an integer in the range [-200, 200]
Valid RPN expression - guaranteed to be well-formed
Division result will always be an integer (no remainder handling needed)
All intermediate and final results fit in a 32-bit signed integer

Asked in

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

The optimal solution uses a stack data structure to evaluate the RPN expression in O(n) time. For each token: if it's a number, push to stack; if it's an operator, pop two operands, compute, and push the result back. The stack's LIFO property naturally handles the order of operations in reverse Polish notation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Array Manipulation)	O(n²)	O(1)	Process tokens by repeatedly scanning and modifying the array in-place
Stack-Based Evaluation (Optimal)	O(n)	O(n)	Use a stack to efficiently process tokens in a single pass

Brute Force (Array Manipulation) — Algorithm Steps

Scan the array from left to right looking for an operator
When found, take the two preceding numbers as operands
Compute the result and replace all three elements with the result
Shift remaining elements to fill the gap
Repeat until only one element remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with tokens: ["2", "1", "+", "3", "*"]

Find First Operator

Scan and find "+" at index 2

Calculate 2 + 1

Replace ["2", "1", "+"] with ["3"]

Updated Array

Array becomes ["3", "3", "*"]

Final Calculation

Calculate 3 * 3 = 9

Code -

solution.c — C

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

int evalRPN(char** tokens, int tokensSize) {
    // Create working copy
    char** work = (char**)malloc(tokensSize * sizeof(char*));
    for (int i = 0; i < tokensSize; i++) {
        work[i] = (char*)malloc(20 * sizeof(char));
        strcpy(work[i], tokens[i]);
    }
    int size = tokensSize;
    
    while (size > 1) {
        // Find the first operator
        for (int i = 0; i < size; i++) {
            if (strcmp(work[i], "+") == 0 || strcmp(work[i], "-") == 0 ||
                strcmp(work[i], "*") == 0 || strcmp(work[i], "/") == 0) {
                
                // Get operands
                int b = atoi(work[i-1]);
                int a = atoi(work[i-2]);
                
                // Perform operation
                int result = 0;
                if (strcmp(work[i], "+") == 0) result = a + b;
                else if (strcmp(work[i], "-") == 0) result = a - b;
                else if (strcmp(work[i], "*") == 0) result = a * b;
                else result = a / b;
                
                // Replace with result
                sprintf(work[i-2], "%d", result);
                
                // Shift remaining elements
                for (int j = i-1; j < size-2; j++) {
                    strcpy(work[j], work[j+2]);
                }
                size -= 2;
                break;
            }
        }
    }
    
    int result = atoi(work[0]);
    
    // Free memory
    for (int i = 0; i < tokensSize; i++) {
        free(work[i]);
    }
    free(work);
    
    return result;
}

int main() {
    char* tokens[] = {"2", "1", "+", "3", "*"};
    printf("%d\n", evalRPN(tokens, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, each of the n tokens requires scanning the entire remaining array

⚠ Quadratic Growth

Space Complexity

O(1)

Only using the input array, no additional space needed

✓ Linear Space

Constraints

1 ≤ tokens.length ≤ 10⁴
tokens[i] is either an operator: "+", "-", "*", or "/", or an integer in the range [-200, 200]
Valid RPN expression - guaranteed to be well-formed
Division result will always be an integer (no remainder handling needed)
All intermediate and final results fit in a 32-bit signed integer

68.0K Views

High Frequency

~15 min Avg. Time

2.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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Array Manipulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler