feat: add 5 more leetcode problems

co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: wislertt

leetcode/count_good_nodes_in_binary_tree/README.md

@@ -0,0 +1,52 @@
+# Count Good Nodes in Binary Tree
+
+**Difficulty:** Medium
+**Topics:** Tree, Depth-First Search, Breadth-First Search, Binary Tree
+**Tags:** neetcode-150
+
+**LeetCode:** [Problem 1448](https://leetcode.com/problems/count-good-nodes-in-binary-tree/description/)
+
+## Problem Description
+
+Given a binary tree `root`, a node _X_ in the tree is named **good** if in the path from root to _X_ there are no nodes with a value _greater than_ X.
+
+Return the number of **good** nodes in the binary tree.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2020/04/02/test_sample_1.png)
+
+```
+Input: root = [3,1,4,3,null,1,5]
+Output: 4
+Explanation: Nodes in blue are good.
+Root Node (3) is always a good node.
+Node 4 -> (3,4) is the maximum value in the path starting from the root.
+Node 5 -> (3,4,5) is the maximum value in the path.
+Node 3 -> (3,1,3) is the maximum value in the path.
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2020/04/02/test_sample_2.png)
+
+```
+Input: root = [3,3,null,4,2]
+Output: 3
+Explanation: Node 2 -> (3,3,2) is not good, because "3" is higher than it.
+```
+
+### Example 3:
+
+```
+Input: root = [1]
+Output: 1
+Explanation: Root is considered as good.
+```
+
+## Constraints
+
+- The number of nodes in the binary tree is in the range `[1, 10^5]`.
+- Each node's value is between `[-10^4, 10^4]`.

leetcode/count_good_nodes_in_binary_tree/__init__.py

@@ -0,0 +1,12 @@
+from leetcode_py import TreeNode
+
+
+def run_good_nodes(solution_class: type, root_list: list[int | None]):
+    implementation = solution_class()
+    root = TreeNode.from_list(root_list) if root_list else None
+    return implementation.good_nodes(root)
+
+
+def assert_good_nodes(result: int, expected: int) -> bool:
+    assert result == expected
+    return True

leetcode/count_good_nodes_in_binary_tree/helpers.py

@@ -0,0 +1,29 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.4
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_good_nodes, run_good_nodes
+from solution import Solution
+
+# %%
+# Example test case
+root_list: list[int | None] = [3, 1, 4, 3, None, 1, 5]
+expected = 4
+
+# %%
+result = run_good_nodes(Solution, root_list)
+result
+
+# %%
+assert_good_nodes(result, expected)

leetcode/count_good_nodes_in_binary_tree/playground.py

@@ -0,0 +1,21 @@
+from leetcode_py import TreeNode
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(h) - recursion stack, h = tree height
+    def good_nodes(self, root: TreeNode[int] | None) -> int:
+        if root is None:
+            return 0
+
+        def dfs(node: TreeNode[int], max_so_far: int) -> int:
+            good = 1 if node.val >= max_so_far else 0
+            next_max = max(max_so_far, node.val)
+            total = good
+            if node.left is not None:
+                total += dfs(node.left, next_max)
+            if node.right is not None:
+                total += dfs(node.right, next_max)
+            return total
+
+        return dfs(root, root.val)

leetcode/count_good_nodes_in_binary_tree/solution.py

@@ -0,0 +1,38 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_good_nodes, run_good_nodes
+from .solution import Solution
+
+
+class TestCountGoodNodesInBinaryTree:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "root_list, expected",
+        [
+            ([3, 1, 4, 3, None, 1, 5], 4),
+            ([3, 3, None, 4, 2], 3),
+            ([1], 1),
+            ([], 0),
+            ([5], 1),
+            ([2, 1], 1),
+            ([2, 3], 2),
+            ([1, 2, 3], 3),
+            ([3, 2, 1], 1),
+            ([-1, -2, -3], 1),
+            ([-3, -1, -4], 2),
+            ([1, 2, 3, 4, 5, 6, 7], 7),
+            ([7, 6, 5, 4, 3, 2, 1], 1),
+            ([10, 5, 15], 2),
+            ([10, 10, 10], 3),
+            ([4, 2, 6, 1, 3, 5, 7], 3),
+            ([1, 1, 1, 1, None, 1, 1], 6),
+        ],
+    )
+    def test_good_nodes(self, root_list: list[int | None], expected: int):
+        result = run_good_nodes(Solution, root_list)
+        assert_good_nodes(result, expected)

leetcode/count_good_nodes_in_binary_tree/test_solution.py

@@ -0,0 +1,52 @@
+# Detect Squares
+
+**Difficulty:** Medium
+**Topics:** Array, Hash Table, Design, Counting, Data Stream
+**Tags:** neetcode-150
+
+**LeetCode:** [Problem 2013](https://leetcode.com/problems/detect-squares/description/)
+
+## Problem Description
+
+You are given a stream of points on the X-Y plane. Design an algorithm that:
+
+- **Adds** new points from the stream into a data structure. **Duplicate** points are allowed and should be treated as different points.
+- Given a query point, **counts** the number of ways to choose three points from the data structure such that the three points and the query point form an **axis-aligned square** with **positive area**.
+
+An **axis-aligned square** is a square whose edges are all the same length and are either parallel or perpendicular to the x-axis and y-axis.
+
+Implement the `DetectSquares` class:
+
+- `DetectSquares()` Initializes the object with an empty data structure.
+- `void add(int[] point)` Adds a new point `point = [x, y]` to the data structure.
+- `int count(int[] point)` Counts the number of ways to form **axis-aligned squares** with point `point = [x, y]` as described above.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/09/01/image.png)
+
+```
+Input
+["DetectSquares", "add", "add", "add", "count", "count", "add", "count"]
+[[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]
+Output
+[null, null, null, null, 1, 0, null, 2]
+
+Explanation
+DetectSquares detectSquares = new DetectSquares();
+detectSquares.add([3, 10]);
+detectSquares.add([11, 2]);
+detectSquares.add([3, 2]);
+detectSquares.count([11, 10]); // return 1.
+detectSquares.count([14, 8]);  // return 0.
+detectSquares.add([11, 2]);    // Adding duplicate points is allowed.
+detectSquares.count([11, 10]); // return 2.
+```
+
+## Constraints
+
+- `point.length == 2`
+- 0 <= x, y <= 1000
+- At most `3000` calls in total will be made to `add` and `count`.

leetcode/detect_squares/README.md

@@ -0,0 +1,25 @@
+from typing import Any
+
+
+def run_detect_squares(solution_class: type, operations: list[str], inputs: list[Any]):
+    squares: Any = None
+    results: list[Any] = []
+
+    for op, args in zip(operations, inputs, strict=False):
+        if op == "DetectSquares":
+            squares = solution_class()
+            results.append(None)
+        elif op == "add":
+            assert squares is not None
+            squares.add(args[0])
+            results.append(None)
+        elif op == "count":
+            assert squares is not None
+            results.append(squares.count(args[0]))
+
+    return results
+
+
+def assert_detect_squares(result: list[Any], expected: list[Any]) -> bool:
+    assert result == expected
+    return True

leetcode/detect_squares/__init__.py

@@ -0,0 +1,30 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.4
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_detect_squares, run_detect_squares
+from solution import DetectSquares
+
+# %%
+# Example test case
+operations = ["DetectSquares", "add", "add", "add", "count", "count", "add", "count"]
+inputs = [[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]
+expected = [None, None, None, None, 1, 0, None, 2]
+
+# %%
+result = run_detect_squares(DetectSquares, operations, inputs)
+result
+
+# %%
+assert_detect_squares(result, expected)