feat(work): add solutions for 150.evaluate-reverse-polish-notation and 155.min-stack, remove 42.trapping-rain-water

work/Hard/Array/42.trapping-rain-water.js

@@ -1,44 +0,0 @@
-/*
- * 42. Trapping Rain Water
- * Difficulty: Hard
- * https://leetcode.com/problems/trapping-rain-water/
- * 
- * ──────────────────────────────────────────────────
- * 
- * Given n non-negative integers representing an elevation map where the
- * width of each bar is 1, compute how much water it can trap after
- * raining.
- * 
- *  
- * 
- * Example 1:
- * 
- * Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
- * Output: 6
- * Explanation: The above elevation map (black section) is represented
- * by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain
- * water (blue section) are being trapped.
- * 
- * Example 2:
- * 
- * Input: height = [4,2,0,3,2,5]
- * Output: 9
- * 
- *  
- * 
- * Constraints:
- * 
- * 	• n == height.length
- * 
- * 	• 1 <= n <= 2 * 10^4
- * 
- * 	• 0 <= height[i] <= 10^5
-*/
-
-/**
- * @param {number[]} height
- * @return {number}
- */
-var trap = function(height) {
-    
-};

work/Medium/Array/150.evaluate-reverse-polish-notation.py

@@ -0,0 +1,88 @@
+"""
+150. Evaluate Reverse Polish Notation
+Difficulty: Medium
+https://leetcode.com/problems/evaluate-reverse-polish-notation/
+
+──────────────────────────────────────────────────
+
+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
+
+
+
+Constraints:
+
+        • 1 <= tokens.length <= 10^4
+
+• tokens[i] is either an operator: "+", "-", "*", or "/", or an
+integer in the range [-200, 200].
+"""
+
+
+class Solution:
+    def evalRPN(self, tokens: List[str]) -> int:
+        stack = []
+        operations = {
+            "+": lambda x, y: int(x + y),
+            "-": lambda x, y: int(x - y),
+            "*": lambda x, y: int(x * y),
+            "/": lambda x, y: int(x / y),
+        }
+
+        for c in tokens:
+            if c in operations:
+                y = stack.pop()
+                x = stack.pop()
+                calc_func = operations[c]
+                result = calc_func(x, y)
+                stack.append(result)
+            else:
+                stack.append(int(c))
+
+        return stack[0]

work/Medium/Stack/155.min-stack.py

@@ -0,0 +1,86 @@
+"""
+155. Min Stack
+Difficulty: Medium
+https://leetcode.com/problems/min-stack/
+
+──────────────────────────────────────────────────
+
+Design a stack that supports push, pop, top, and retrieving the
+minimum element in constant time.
+
+Implement the MinStack class:
+
+        • MinStack() initializes the stack object.
+
+        • void push(int value) pushes the element value onto the stack.
+
+        • void pop() removes the element on the top of the stack.
+
+        • int top() gets the top element of the stack.
+
+        • int getMin() retrieves the minimum element in the stack.
+
+You must implement a solution with O(1) time complexity for each
+function.
+
+
+
+Example 1:
+
+Input
+["MinStack","push","push","push","getMin","pop","top","getMin"]
+[[],[-2],[0],[-3],[],[],[],[]]
+
+Output
+[null,null,null,null,-3,null,0,-2]
+
+Explanation
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin(); // return -3
+minStack.pop();
+minStack.top();    // return 0
+minStack.getMin(); // return -2
+
+
+
+Constraints:
+
+        • -2^31 <= val <= 2^31 - 1
+
+• Methods pop, top and getMin operations will always be called on
+non-empty stacks.
+
+        • At most 3 * 10^4 calls will be made to push, pop, top, and getMin.
+"""
+
+
+class MinStack:
+    def __init__(self):
+        self.stack = []
+        self.minStack = []
+
+    def push(self, value: int) -> None:
+        self.stack.append(value)
+        value = min(value, self.minStack[-1] if self.minStack else value)
+        self.minStack.append(value)
+
+    def pop(self) -> None:
+        self.stack.pop()
+        self.minStack.pop()
+
+    def top(self) -> int:
+        return self.stack[-1]
+
+    def getMin(self) -> int:
+        return self.minStack[-1]
+
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(value)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.getMin()