150. Evaluate RPN

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

int evalRPN(char **tokens, int tokensSize) {
    int *st = malloc(tokensSize * sizeof(int));
    int top = 0;

    for (int i = 0; i < tokensSize; i++) {
        char *s = tokens[i];
        // a lone operator char; "-11" is a number, so check the length too
        if (strlen(s) == 1 && strchr("+-*/", s[0])) {
            int b = st[--top];
            int a = st[--top];

            if (s[0] == '+')
                st[top++] = a + b;
            else if (s[0] == '-')
                st[top++] = a - b;
            else if (s[0] == '*')
                st[top++] = a * b;
            else
                st[top++] = a / b;
        } else {
            st[top++] = atoi(s);
        }
    }

    int result = st[top - 1];
    free(st);
    return result;
}

#include <stack>
#include <string>
#include <vector>
using namespace std;

class Solution {
public:
  int evalRPN(vector<string> &tokens) {
    stack<int> st;

    for (string s : tokens) {
      if (s == "+" || s == "-" || s == "*" || s == "/") {
        int b = st.top();
        st.pop();
        int a = st.top();
        st.pop();

        if (s == "+")
          st.push(a + b);
        else if (s == "-")
          st.push(a - b);
        else if (s == "*")
          st.push(a * b);
        else
          st.push(a / b);
      } else {
        st.push(stoi(s));
      }
    }

    return st.top();
  }
};

package main

import "strconv"

func evalRPN(tokens []string) int {
    st := []int{}

    for _, s := range tokens {
        if s == "+" || s == "-" || s == "*" || s == "/" {
            n := len(st)
            a, b := st[n-2], st[n-1]
            st = st[:n-2]

            switch s {
            case "+":
                st = append(st, a+b)
            case "-":
                st = append(st, a-b)
            case "*":
                st = append(st, a*b)
            default:
                st = append(st, a/b)
            }
        } else {
            v, _ := strconv.Atoi(s)
            st = append(st, v)
        }
    }

    return st[len(st)-1]
}

import java.util.ArrayDeque;
import java.util.Deque;

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> st = new ArrayDeque<>();

        for (String s : tokens) {
            if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {
                int b = st.pop();
                int a = st.pop();

                if (s.equals("+"))
                    st.push(a + b);
                else if (s.equals("-"))
                    st.push(a - b);
                else if (s.equals("*"))
                    st.push(a * b);
                else
                    st.push(a / b);
            } else {
                st.push(Integer.parseInt(s));
            }
        }

        return st.peek();
    }
}

class Solution {
  evalRPN(tokens) {
    const st = [];

    for (const s of tokens) {
      if (s === "+" || s === "-" || s === "*" || s === "/") {
        const b = st.pop();
        const a = st.pop();

        if (s === "+") st.push(a + b);
        else if (s === "-") st.push(a - b);
        else if (s === "*") st.push(a * b);
        else st.push(Math.trunc(a / b));
      } else {
        st.push(parseInt(s, 10));
      }
    }

    return st.at(-1);
  }
}

from typing import List


class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        st = []

        for s in tokens:
            if s in ("+", "-", "*", "/"):
                b = st.pop()
                a = st.pop()

                if s == "+":
                    st.append(a + b)
                elif s == "-":
                    st.append(a - b)
                elif s == "*":
                    st.append(a * b)
                else:
                    st.append(int(a / b))  # truncate toward zero, not floor
            else:
                st.append(int(s))

        return st[-1]

struct Solution;

impl Solution {
    fn eval_rpn(tokens: Vec<String>) -> i32 {
        let mut st: Vec<i32> = Vec::new();

        for s in &tokens {
            if matches!(s.as_str(), "+" | "-" | "*" | "/") {
                let b = st.pop().unwrap();
                let a = st.pop().unwrap();

                st.push(match s.as_str() {
                    "+" => a + b,
                    "-" => a - b,
                    "*" => a * b,
                    _ => a / b,
                });
            } else {
                st.push(s.parse().unwrap());
            }
        }

        *st.last().unwrap()
    }
}