feat: update mismatch

Author: wislertt

leetcode/climbing_stairs/solution.py

@@ -2,10 +2,9 @@ class Solution:
 
     # Time: O(n)
     # Space: O(1)
+    # This follows Fibonacci pattern
+    # Standard Fib: F(0)=0, F(1)=1, F(2)=1, F(3)=2, F(4)=3, F(5)=5...
     def climb_stairs(self, n: int) -> int:
-
-        # This follows Fibonacci pattern
-        # Standard Fib: F(0)=0, F(1)=1, F(2)=1, F(3)=2, F(4)=3, F(5)=5...
         if n <= 2:
             return n
 

leetcode/first_bad_version/solution.py

@@ -1,7 +1,5 @@
 class Solution:
 
-    # Time: O(?)
-    # Space: O(?)
     def __init__(self, first_bad: int = 1) -> None:
         self.is_bad_version = lambda version: version >= first_bad
 

leetcode/min_stack/solution.py

@@ -28,3 +28,16 @@ def top(self) -> int:
     # Space: O(1)
     def get_min(self) -> int:
         return self.min_stack[-1]
+
+
+# Example walkthrough: push(-2), push(0), push(-3), getMin(), pop(), top(), getMin()
+#
+# Initial: stack=[], min_stack=[]
+#
+# push(-2): stack=[-2], min_stack=[-2]  (first element, add to both)
+# push(0):  stack=[-2,0], min_stack=[-2]  (0 > -2, don't add to min_stack)
+# push(-3): stack=[-2,0,-3], min_stack=[-2,-3]  (-3 <= -2, add to min_stack)
+# getMin(): return -3  (top of min_stack)
+# pop():    stack=[-2,0], min_stack=[-2]  (-3 was min, remove from both stacks)
+# top():    return 0  (top of main stack)
+# getMin(): return -2  (top of min_stack after pop)

leetcode/minimum_height_trees/solution.py

@@ -1,10 +1,11 @@
+from collections import defaultdict, deque
+
+
 class Solution:
 
     # Time: O(V)
     # Space: O(V)
     def find_min_height_trees(self, n: int, edges: list[list[int]]) -> list[int]:
-        from collections import defaultdict, deque
-
         if n == 1:
             return [0]
 

leetcode/rotting_oranges/solution.py

@@ -1,10 +1,11 @@
+from collections import deque
+
+
 class Solution:
 
     # Time: O(m*n)
     # Space: O(m*n)
     def oranges_rotting(self, grid: list[list[int]]) -> int:
-        from collections import deque
-
         EMPTY, FRESH, ROTTEN = 0, 1, 2
         _ = EMPTY
 

leetcode/serialize_and_deserialize_binary_tree/solution.py

@@ -39,3 +39,48 @@ def dfs():
             return node
 
         return dfs()
+
+
+# Binary Tree Serialization Techniques
+
+# Example Tree:
+#       1
+#      / \
+#     2   3
+#        / \
+#       4   5
+
+# 1. Preorder with Null Markers (This Implementation)
+# Visit: root → left → right, mark nulls with '#'
+# Result: "1,2,#,#,3,4,#,#,5,#,#"
+# Pros: Self-contained, unambiguous, O(n) reconstruction
+# Cons: Longer string due to null markers
+
+# 2. Level-order (BFS) with Null Markers
+# Visit level by level, mark nulls with '#'
+# Result: "1,2,3,#,#,4,5"
+# Pros: Simple format like preorder, level-by-level intuitive
+# Cons: Still requires queue processing
+
+# 3. Postorder with Null Markers
+# Visit: left → right → root
+# Result: "#,#,2,#,#,4,#,#,5,3,1"
+# Pros: Bottom-up reconstruction
+# Cons: Less intuitive than preorder
+
+# 4. Inorder + Preorder (Two Arrays)
+# Inorder: [2,1,4,3,5], Preorder: [1,2,3,4,5]
+# Pros: Works for any binary tree structure
+# Cons: Requires two arrays, only works with unique values
+
+# 5. Parenthetical Preorder
+# Same traversal as #1 but with parentheses format: value(left)(right)
+# Result: "1(2()())(3(4()())(5()()))"
+# Pros: Human readable structure, shows nesting clearly
+# Cons: Complex parsing, verbose
+
+# 6. Parenthetical Postorder
+# Same traversal as #3 but with parentheses format: (left)(right)value
+# Result: "(()()2)((()()4)(()()5)3)1"
+# Pros: Bottom-up readable structure
+# Cons: Even more complex parsing

leetcode/zero_one_matrix/solution.py

@@ -1,10 +1,11 @@
+from collections import deque
+
+
 class Solution:
 
     # Time: O(m * n)
     # Space: O(m * n)
     def update_matrix(self, mat: list[list[int]]) -> list[list[int]]:
-        from collections import deque
-
         UNSEEN = -1
         m, n = len(mat), len(mat[0])
         queue: deque[tuple[int, int]] = deque()