From 95f10980d46f998fbf579b9d5ecc546c2c59981d Mon Sep 17 00:00:00 2001
From: Prad Nukala <prad@sonr.io>
Date: Thu, 27 Aug 2026 15:19:48 -0400
Subject: [PATCH] docs(docs): add MDX documentation pages for problems 150
 (Evaluate Reverse Polish Notation) and 155 (Min Stack)

---
 .../150-evaluate-reverse-polish-notation.mdx  | 55 ++++++++++++++++++
 apps/docs/content/(stack)/155-min-stack.mdx   | 56 +++++++++++++++++++
 2 files changed, 111 insertions(+)
 create mode 100644 apps/docs/content/(array)/150-evaluate-reverse-polish-notation.mdx
 create mode 100644 apps/docs/content/(stack)/155-min-stack.mdx

diff --git a/apps/docs/content/(array)/150-evaluate-reverse-polish-notation.mdx b/apps/docs/content/(array)/150-evaluate-reverse-polish-notation.mdx
new file mode 100644
index 0000000..04a5134
--- /dev/null
+++ b/apps/docs/content/(array)/150-evaluate-reverse-polish-notation.mdx
@@ -0,0 +1,55 @@
+---
+title: '150. Evaluate Reverse Polish Notation'
+description: You are given an array of strings tokens that represents an arithmetic expression in a Reverse Polish Notation
+sidebar:
+  label: 'Evaluate Reverse Polish Notation'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Stack</Badge>
+
+### 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].
+
+## Solution
+
+```py
+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]
+```
diff --git a/apps/docs/content/(stack)/155-min-stack.mdx b/apps/docs/content/(stack)/155-min-stack.mdx
new file mode 100644
index 0000000..e284439
--- /dev/null
+++ b/apps/docs/content/(stack)/155-min-stack.mdx
@@ -0,0 +1,56 @@
+---
+title: '155. Min Stack'
+description: Design a stack that supports push, pop, top, and retrieving the minimum element in constant time
+sidebar:
+  label: 'Min Stack'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Stack</Badge>
+
+::::warning
+You must implement a solution with O(1) time complexity for each function.
+::::
+
+### Example 1:
+- Input: ``
+- Output: ``
+- Explanation: 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.
+
+## Solution
+
+```py
+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()
+```