# Evaluate Reverse Polish Notation LeetCode Solution

Here, We see Evaluate Reverse Polish Notation LeetCode Solution. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

# List of all LeetCode Solution

## Problem Statement

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

Evaluate the expression. 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 a reverse polish notation.
• The answer and all the intermediate calculations can be represented in a 32-bit integer.

Example 1:
Input: tokens = [“2″,”1″,”+”,”3″,”*”]
Output: 9
Explanation: ((2 + 1) * 3) = 9

Example 2:
Input: tokens = [“4″,”13″,”5″,”/”,”+”]
Output: 6
Explanation: (4 + (13 / 5)) = 6

Example 3:
Input: tokens = [“10″,”6″,”9″,”3″,”+”,”-11″,”*”,”/”,”*”,”17″,”+”,”5″,”+”]
Output: 22
Explanation:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

## Evaluate Reverse Polish Notation LeetCode Solution C++

``````class Solution {
public:
int evalRPN(vector<string>& tokens) {
unordered_map<string, function<int (int, int) > > map = {
{ "+" , [] (int a, int b) { return a + b; } },
{ "-" , [] (int a, int b) { return a - b; } },
{ "*" , [] (int a, int b) { return a * b; } },
{ "/" , [] (int a, int b) { return a / b; } }
};
std::stack<int> stack;
for (string& s : tokens) {
if (!map.count(s)) {
stack.push(stoi(s));
} else {
int op1 = stack.top();
stack.pop();
int op2 = stack.top();
stack.pop();
stack.push(map[s](op2, op1));
}
}
return stack.top();
}
};```Code language: PHP (php)```

## Evaluate Reverse Polish Notation LeetCode Solution Java

``````class Solution {
public int evalRPN(String[] tokens) {
Stack<Long> stack = new Stack<>();
int n = tokens.length;
for (int i = 0; i < n; i++) {
if (tokens[i].length() == 1 && tokens[i].charAt(0) < 48) {
long integer2 = stack.pop();
long integer1 = stack.pop();
char operator = tokens[i].charAt(0);
long resolvedAns = resolves(integer1, integer2, operator);
stack.push(resolvedAns);
} else {
stack.push(Long.parseLong(tokens[i]));
}
}
return stack.pop().intValue();
}
long resolves(long a, long b, char Operator) {
if (Operator == '+') return a + b;
else if (Operator == '-') return a - b;
else if (Operator == '*') return a * b;
return a / b;
}
}```Code language: JavaScript (javascript)```

## Evaluate Reverse Polish Notation Solution JavaScript

``````var evalRPN = function(tokens) {
let stack = [];
let ops = {
'+': (a, b) => a + b,
'-': (a, b) => a - b,
'*': (a, b) => a * b,
'/': (a, b) => a / b >= 0 ? Math.floor(a / b) : Math.ceil(a / b),
};
for (let t of tokens) {
if (ops[t]) {
let top = stack.pop();
let second = stack.pop();
stack.push(ops[t](second, top));
} else {
stack.push(Number(t));
}
}
return stack.pop();
};```Code language: JavaScript (javascript)```

## Evaluate Reverse Polish Notation Solution Python

``````class Solution(object):
def evalRPN(self, tokens):
stack = []
for t in tokens:
if t not in "+-*/":
stack.append(int(t))
else:
r, l = stack.pop(), stack.pop()
if t == "+":
stack.append(l+r)
elif t == "-":
stack.append(l-r)
elif t == "*":
stack.append(l*r)
else:
stack.append(int(float(l)/r))
return stack.pop()``````
Scroll to Top