Add stack-based algorithm implementations

Implement four stack-related algorithms: `is_valid` for validating parentheses, `MinStack` for tracking minimum stack values, `evaluate_reverse_polish_notation` for evaluating expressions in postfix notation, and `generate_parentheses` for generating valid parentheses combinations. Each implementation includes corresponding unit tests for validation.

Author: nicholasadamou

Stack/__init__.py

@@ -0,0 +1,35 @@
+# https://neetcode.io/problems/evaluate-reverse-polish-notation
+
+import unittest
+from typing import List
+
+def evaluate_reverse_polish_notation(tokens: List[str]) -> int:
+    stack = []
+
+    for token in tokens:
+        if token in '+-*/':
+            # The values are in reverse order, so 'b' is first then 'a' due
+            # to the order of stack operations
+            b = stack.pop()
+            a = stack.pop()
+
+            # Perform the computation and push result back onto the stack
+
+            if token == '+':
+                stack.append(a + b)
+            elif token == '-':
+                stack.append(a - b)
+            elif token == '*':
+                stack.append(a * b)
+            else:
+                stack.append(a // b)
+
+            continue
+
+        stack.append(int(token)) # Convert token to int and push into the stack
+
+    return stack.pop() # The final result will be the only element left on the stack
+
+class Test(unittest.TestCase):
+    def test_evaluate_reverse_polish_notation(self):
+        self.assertEqual(evaluate_reverse_polish_notation(["1", "2", "+", "3", "*", "4", "-"]), 5)

Stack/evaluate_reverse_polish_notation.py

@@ -0,0 +1,31 @@
+# https://neetcode.io/problems/generate-parentheses
+
+import unittest
+from typing import List
+
+def generate_parentheses(n: int) -> List[str]:
+    result = []
+    stack = []
+
+    def backtrack(open_count, close_count):
+        if open_count == close_count == n:
+            return result.append(''.join(stack))
+
+        if open_count < n:
+            stack.append('(')
+            backtrack(open_count + 1, close_count)
+            stack.pop()
+
+        if close_count < open_count:
+            stack.append(')')
+            backtrack(open_count, close_count + 1)
+            stack.pop()
+
+    backtrack(0, 0)
+
+    return result
+
+class Test(unittest.TestCase):
+    def test_generate_parentheses(self):
+        self.assertEqual(generate_parentheses(1), ["()"])
+        self.assertEqual(generate_parentheses(3), ["((()))", "(()())", "(())()", "()(())", "()()()"])

Stack/generate_parentheses.py

@@ -0,0 +1,96 @@
+# https://neetcode.io/problems/minimum-stack
+
+import unittest
+
+class MinStack:
+    def __init__(self):
+        self.stack = []
+        self.min_stack = []
+
+    def push(self, value: int) -> None:
+        self.stack.append(value)
+
+        value = min(value, self.min_stack[-1] if self.min_stack else value)
+        self.min_stack.append(value)
+
+    def pop(self) -> None:
+        if self.stack:
+            self.stack.pop()
+
+        if self.min_stack:
+            self.min_stack.pop()
+
+    def top(self) -> int:
+        return self.stack[-1] if self.stack else None
+
+    def get_min(self) -> int:
+        return self.min_stack[-1] if self.min_stack else None
+
+class TestMinStack(unittest.TestCase):
+    def setUp(self):
+        self.min_stack = MinStack()
+
+    def test_push(self):
+        self.min_stack.push(3)
+        self.assertEqual(self.min_stack.top(), 3)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+        self.min_stack.push(5)
+        self.assertEqual(self.min_stack.top(), 5)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+        self.min_stack.push(2)
+        self.assertEqual(self.min_stack.top(), 2)
+        self.assertEqual(self.min_stack.get_min(), 2)
+
+        self.min_stack.push(2)
+        self.assertEqual(self.min_stack.top(), 2)
+        self.assertEqual(self.min_stack.get_min(), 2)
+
+        self.min_stack.push(1)
+        self.assertEqual(self.min_stack.top(), 1)
+        self.assertEqual(self.min_stack.get_min(), 1)
+
+    def test_pop(self):
+        self.min_stack.push(3)
+        self.min_stack.push(5)
+        self.min_stack.push(2)
+        self.min_stack.push(2)
+        self.min_stack.push(1)
+
+        self.min_stack.pop()
+        self.assertEqual(self.min_stack.top(), 2)
+        self.assertEqual(self.min_stack.get_min(), 2)
+
+        self.min_stack.pop()
+        self.assertEqual(self.min_stack.top(), 2)
+        self.assertEqual(self.min_stack.get_min(), 2)
+
+        self.min_stack.pop()
+        self.assertEqual(self.min_stack.top(), 5)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+        self.min_stack.pop()
+        self.assertEqual(self.min_stack.top(), 3)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+    def test_top(self):
+        self.min_stack.push(3)
+        self.assertEqual(self.min_stack.top(), 3)
+
+        self.min_stack.push(5)
+        self.assertEqual(self.min_stack.top(), 5)
+
+    def test_get_min(self):
+        self.min_stack.push(3)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+        self.min_stack.push(5)
+        self.assertEqual(self.min_stack.get_min(), 3)
+
+        self.min_stack.push(2)
+        self.assertEqual(self.min_stack.get_min(), 2)
+
+        self.min_stack.push(1)
+        self.assertEqual(self.min_stack.get_min(), 1)
+

Stack/minimum_stack.py

@@ -0,0 +1,28 @@
+# https://neetcode.io/problems/validate-parentheses
+
+import unittest
+
+def is_valid(s: str) -> bool:
+    closing = {')': '(', ']': '[', '}': '{'}
+    stack = []
+
+    for char in s:
+        is_closing = char in closing
+
+        if is_closing and (stack and stack[-1] == closing[char]):
+            stack.pop()
+            continue
+
+        if is_closing and not stack:
+            return False
+
+        stack.append(char)
+
+    return len(stack) == 0
+
+class Test(unittest.TestCase):
+    def test_is_valid(self):
+        self.assertTrue(is_valid('[]'))
+        self.assertTrue(is_valid('([{}])'))
+        self.assertFalse(is_valid('[(])'))
+        self.assertFalse(is_valid(']'))