feat: add more question

Author: wislertt

.templates/leetcode/json/binary_tree_right_side_view.json

@@ -0,0 +1,49 @@
+{
+    "problem_name": "binary_tree_right_side_view",
+    "solution_class_name": "Solution",
+    "problem_number": "199",
+    "problem_title": "Binary Tree Right Side View",
+    "difficulty": "Medium",
+    "topics": "Tree, Depth-First Search, Breadth-First Search, Binary Tree",
+    "tags": ["grind-75"],
+    "readme_description": "Given the `root` of a binary tree, imagine yourself standing on the **right side** of it, return *the values of the nodes you can see ordered from top to bottom*.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2024/11/24/tmpd5jn43fs-1.png)\n\n```\nInput: root = [1,2,3,null,5,null,4]\nOutput: [1,3,4]\n```"
+        },
+        {
+            "content": "![Example 2](https://assets.leetcode.com/uploads/2024/11/24/tmpkpe40xeh-1.png)\n\n```\nInput: root = [1,2,3,4,null,null,null,5]\nOutput: [1,3,4,5]\n```"
+        },
+        { "content": "```\nInput: root = [1,null,3]\nOutput: [1,3]\n```" },
+        { "content": "```\nInput: root = []\nOutput: []\n```" }
+    ],
+    "readme_constraints": "- The number of nodes in the tree is in the range `[0, 100]`.\n- `-100 <= Node.val <= 100`",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_methods": [
+        {
+            "name": "right_side_view",
+            "parameters": "root: TreeNode[int] | None",
+            "return_type": "list[int]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom leetcode_py import TreeNode\nfrom .solution import Solution",
+    "test_class_name": "BinaryTreeRightSideView",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_right_side_view",
+            "parametrize": "root_list, expected",
+            "parametrize_typed": "root_list: list[int | None], expected: list[int]",
+            "test_cases": "[([1, 2, 3, None, 5, None, 4], [1, 3, 4]), ([1, 2, 3, 4, None, None, None, 5], [1, 3, 4, 5]), ([1, None, 3], [1, 3]), ([], [])]",
+            "body": "root = TreeNode.from_list(root_list)\nresult = self.solution.right_side_view(root)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_test_case": "# Example test case\nroot_list: list[int | None] = [1, 2, 3, None, 5, None, 4]\nexpected = [1, 3, 4]",
+    "playground_execution": "root = TreeNode.from_list(root_list)\nresult = Solution().right_side_view(root)\nresult",
+    "playground_assertion": "assert result == expected"
+}

.templates/leetcode/json/minimum_height_trees.json

@@ -5,7 +5,7 @@
     "problem_title": "Minimum Height Trees",
     "difficulty": "Medium",
     "topics": "Depth-First Search, Breadth-First Search, Graph, Topological Sort",
-    "tags": [],
+    "tags": ["grind-75"],
     "readme_description": "A tree is an undirected graph in which any two vertices are connected by *exactly* one path. In other words, any connected graph without simple cycles is a tree.\n\nGiven a tree of `n` nodes labelled from `0` to `n - 1`, and an array of `n - 1` `edges` where `edges[i] = [ai, bi]` indicates that there is an undirected edge between the two nodes `ai` and `bi` in the tree, you can choose any node of the tree as the root. When you select a node `x` as the root, the result tree has height `h`. Among all possible rooted trees, those with minimum height (i.e. `min(h)`) are called **minimum height trees** (MHTs).\n\nReturn *a list of all **MHTs'** root labels*. You can return the answer in **any order**.\n\nThe **height** of a rooted tree is the number of edges on the longest downward path between the root and a leaf.",
     "readme_examples": [
         {

.templates/leetcode/json/validate_binary_search_tree.json

@@ -0,0 +1,47 @@
+{
+    "problem_name": "validate_binary_search_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "98",
+    "problem_title": "Validate Binary Search Tree",
+    "difficulty": "Medium",
+    "topics": "Tree, Depth-First Search, Binary Search Tree, Binary Tree",
+    "tags": ["grind-75"],
+    "readme_description": "Given the `root` of a binary tree, determine if it is a valid binary search tree (BST).\n\nA **valid BST** is defined as follows:\n\n- The left subtree of a node contains only nodes with keys **strictly less than** the node's key.\n- The right subtree of a node contains only nodes with keys **strictly greater than** the node's key.\n- Both the left and right subtrees must also be binary search trees.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg)\n\n```\nInput: root = [2,1,3]\nOutput: true\n```"
+        },
+        {
+            "content": "![Example 2](https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg)\n\n```\nInput: root = [5,1,4,null,null,3,6]\nOutput: false\n```\n**Explanation:** The root node's value is 5 but its right child's value is 4."
+        }
+    ],
+    "readme_constraints": "- The number of nodes in the tree is in the range `[1, 10^4]`.\n- `-2^31 <= Node.val <= 2^31 - 1`",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_methods": [
+        {
+            "name": "is_valid_bst",
+            "parameters": "root: TreeNode[int] | None",
+            "return_type": "bool",
+            "dummy_return": "False"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom leetcode_py import TreeNode\nfrom .solution import Solution",
+    "test_class_name": "ValidateBinarySearchTree",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_is_valid_bst",
+            "parametrize": "root_list, expected",
+            "parametrize_typed": "root_list: list[int | None], expected: bool",
+            "test_cases": "[([2, 1, 3], True), ([5, 1, 4, None, None, 3, 6], False), ([2, 1, 3], True), ([1], True), ([1, 1], False)]",
+            "body": "root = TreeNode.from_list(root_list)\nresult = self.solution.is_valid_bst(root)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_test_case": "# Example test case\nroot_list: list[int | None] = [2, 1, 3]\nexpected = True",
+    "playground_execution": "root = TreeNode.from_list(root_list)\nresult = Solution().is_valid_bst(root)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= minimum_height_trees
+PROBLEM ?= binary_tree_right_side_view
 FORCE ?= 0
 
 sync_submodules:

leetcode/binary_tree_right_side_view/README.md

@@ -0,0 +1,50 @@
+# Binary Tree Right Side View
+
+**Difficulty:** Medium
+**Topics:** Tree, Depth-First Search, Breadth-First Search, Binary Tree
+**Tags:** grind-75
+
+**LeetCode:** [Problem 199](https://leetcode.com/problems/binary-tree-right-side-view/description/)
+
+## Problem Description
+
+Given the `root` of a binary tree, imagine yourself standing on the **right side** of it, return _the values of the nodes you can see ordered from top to bottom_.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2024/11/24/tmpd5jn43fs-1.png)
+
+```
+Input: root = [1,2,3,null,5,null,4]
+Output: [1,3,4]
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2024/11/24/tmpkpe40xeh-1.png)
+
+```
+Input: root = [1,2,3,4,null,null,null,5]
+Output: [1,3,4,5]
+```
+
+### Example 3:
+
+```
+Input: root = [1,null,3]
+Output: [1,3]
+```
+
+### Example 4:
+
+```
+Input: root = []
+Output: []
+```
+
+## Constraints
+
+- The number of nodes in the tree is in the range `[0, 100]`.
+- `-100 <= Node.val <= 100`

leetcode/binary_tree_right_side_view/__init__.py

@@ -0,0 +1,71 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution\n",
+    "\n",
+    "from leetcode_py import TreeNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "root_list: list[int | None] = [1, 2, 3, None, 5, None, 4]\n",
+    "expected = [1, 3, 4]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "root = TreeNode.from_list(root_list)\n",
+    "result = Solution().right_side_view(root)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/binary_tree_right_side_view/playground.ipynb

@@ -0,0 +1,67 @@
+from collections import deque
+
+from leetcode_py import TreeNode
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(h)
+    def right_side_view(self, root: TreeNode[int] | None) -> list[int]:
+        result: list[int] = []
+
+        def dfs(node: TreeNode[int] | None, level: int) -> None:
+            if not node:
+                return
+            if level == len(result):
+                result.append(node.val)
+            dfs(node.right, level + 1)
+            dfs(node.left, level + 1)
+
+        dfs(root, 0)
+        return result
+
+
+class SolutionDFS:
+    # Time: O(n)
+    # Space: O(h)
+    def right_side_view(self, root: TreeNode[int] | None) -> list[int]:
+        if not root:
+            return []
+
+        result: list[int] = []
+        stack = [(root, 0)]
+
+        while stack:
+            node, level = stack.pop()
+            if level == len(result):
+                result.append(node.val)
+            if node.left:
+                stack.append((node.left, level + 1))
+            if node.right:
+                stack.append((node.right, level + 1))
+
+        return result
+
+
+class SolutionBFS:
+    # Time: O(n)
+    # Space: O(w)
+    def right_side_view(self, root: TreeNode[int] | None) -> list[int]:
+        if not root:
+            return []
+
+        result: list[int] = []
+        queue = deque([root])
+
+        while queue:
+            level_size = len(queue)
+            for i in range(level_size):
+                node = queue.popleft()
+                if i == level_size - 1:  # rightmost node
+                    result.append(node.val)
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+
+        return result

leetcode/binary_tree_right_side_view/solution.py

@@ -0,0 +1,30 @@
+import pytest
+
+from leetcode_py import TreeNode
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution, SolutionBFS, SolutionDFS
+
+
+class TestBinaryTreeRightSideView:
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionDFS, SolutionBFS])
+    @pytest.mark.parametrize(
+        "root_list, expected",
+        [
+            ([1, 2, 3, None, 5, None, 4], [1, 3, 4]),
+            ([1, 2, 3, 4, None, None, None, 5], [1, 3, 4, 5]),
+            ([1, None, 3], [1, 3]),
+            ([], []),
+        ],
+    )
+    @logged_test
+    def test_right_side_view(
+        self,
+        root_list: list[int | None],
+        expected: list[int],
+        solution_class: type[Solution | SolutionDFS | SolutionBFS],
+    ):
+        solution = solution_class()
+        root = TreeNode.from_list(root_list)
+        result = solution.right_side_view(root)
+        assert result == expected

leetcode/binary_tree_right_side_view/tests.py

@@ -29,7 +29,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = Solution().max_area(height)\nresult"
+    "result = Solution().max_area(height)\n",
+    "result"
    ]
   },
   {