feat: add problem same_tree

Author: wislertt

.cursor/.dev/update_tags.py

@@ -8,36 +8,7 @@
 sys.path.append(str(Path(__file__).parent.parent.parent))
 from problem_lists import available_lists
 
-# Import existing function to reuse the tag resolution logic
-try:
-    from leetcode_py.cli.utils.problem_finder import find_problems_by_tag
-except ImportError:
-    # Fallback if import fails
-    def find_problems_by_tag(tag: str) -> list[str]:
-        """Fallback function to find problems by tag."""
-        try:
-            import json5
-
-            tags_path = (
-                Path(__file__).parent.parent.parent
-                / "leetcode_py/cli/resources/leetcode/json/tags.json5"
-            )
-            with open(tags_path, "r") as f:
-                tags_data = json5.load(f)
-
-            problems = []
-            tag_items = tags_data.get(tag, [])
-
-            for item in tag_items:
-                if isinstance(item, dict) and "tag" in item:
-                    # Resolve tag reference recursively
-                    referenced_problems = find_problems_by_tag(item["tag"])
-                    problems.extend(referenced_problems)
-                elif isinstance(item, str):
-                    problems.append(item)
-            return problems
-        except Exception:
-            return []
+from leetcode_py.cli.utils.problem_finder import find_problems_by_tag
 
 
 def get_existing_problems():

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= jump_game
+PROBLEM ?= same_tree
 FORCE ?= 0
 COMMA := ,
 

leetcode/same_tree/README.md

@@ -0,0 +1,47 @@
+# Same Tree
+
+**Difficulty:** Easy
+**Topics:** Tree, Depth-First Search, Breadth-First Search, Binary Tree
+**Tags:** blind-75
+
+**LeetCode:** [Problem 100](https://leetcode.com/problems/same-tree/description/)
+
+## Problem Description
+
+Given the roots of two binary trees `p` and `q`, write a function to check if they are the same or not.
+
+Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)
+
+```
+Input: p = [1,2,3], q = [1,2,3]
+Output: true
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)
+
+```
+Input: p = [1,2], q = [1,null,2]
+Output: false
+```
+
+### Example 3:
+
+![Example 3](https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg)
+
+```
+Input: p = [1,2,1], q = [1,1,2]
+Output: false
+```
+
+## Constraints
+
+- The number of nodes in both trees is in the range [0, 100].
+- -10^4 <= Node.val <= 10^4

leetcode/same_tree/__init__.py

@@ -0,0 +1,13 @@
+from leetcode_py import TreeNode
+
+
+def run_is_same_tree(solution_class: type, p_list: list[int | None], q_list: list[int | None]):
+    p = TreeNode[int].from_list(p_list)
+    q = TreeNode[int].from_list(q_list)
+    implementation = solution_class()
+    return implementation.is_same_tree(p, q)
+
+
+def assert_is_same_tree(result: bool, expected: bool) -> bool:
+    assert result == expected
+    return True

leetcode/same_tree/helpers.py

@@ -0,0 +1,30 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_is_same_tree, run_is_same_tree
+from solution import Solution
+
+# %%
+# Example test case
+p_list: list[int | None] = [1, 2, 3]
+q_list: list[int | None] = [1, 2, 3]
+expected = True
+
+# %%
+result = run_is_same_tree(Solution, p_list, q_list)
+result
+
+# %%
+assert_is_same_tree(result, expected)

leetcode/same_tree/playground.py

@@ -0,0 +1,22 @@
+from leetcode_py import TreeNode
+
+
+class Solution:
+
+    # Time: O(min(m, n)) where m and n are the number of nodes in the two trees
+    # Space: O(min(m, n)) for the recursion stack
+    def is_same_tree(self, p: TreeNode[int] | None, q: TreeNode[int] | None) -> bool:
+        # Base case: both nodes are None
+        if p is None and q is None:
+            return True
+
+        # Base case: one node is None, the other is not
+        if p is None or q is None:
+            return False
+
+        # Check if current nodes have the same value
+        if p.val != q.val:
+            return False
+
+        # Recursively check left and right subtrees
+        return self.is_same_tree(p.left, q.left) and self.is_same_tree(p.right, q.right)

leetcode/same_tree/solution.py

@@ -0,0 +1,32 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_is_same_tree, run_is_same_tree
+from .solution import Solution
+
+
+class TestSameTree:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "p_list, q_list, expected",
+        [
+            ([1, 2, 3], [1, 2, 3], True),
+            ([1, 2], [1, None, 2], False),
+            ([1, 2, 1], [1, 1, 2], False),
+            ([], [], True),
+            ([1], [1], True),
+            ([1], [2], False),
+            ([1, None, 2], [1, 2], False),
+            ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], True),
+            ([1, 2, 3, 4, 5], [1, 2, 3, 4, 6], False),
+            ([1, 2, 3, None, 4], [1, 2, 3, None, 4], True),
+            ([1, 2, 3, None, 4], [1, 2, 3, 4, None], False),
+        ],
+    )
+    def test_is_same_tree(self, p_list: list[int | None], q_list: list[int | None], expected: bool):
+        result = run_is_same_tree(Solution, p_list, q_list)
+        assert_is_same_tree(result, expected)

leetcode/same_tree/test_solution.py

@@ -0,0 +1,67 @@
+{
+    "problem_name": "same_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "100",
+    "problem_title": "Same Tree",
+    "difficulty": "Easy",
+    "topics": "Tree, Depth-First Search, Breadth-First Search, Binary Tree",
+    "_tags": { "list": ["blind-75"] },
+    "readme_description": "Given the roots of two binary trees `p` and `q`, write a function to check if they are the same or not.\n\nTwo binary trees are considered the same if they are structurally identical, and the nodes have the same value.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)\n\n```\nInput: p = [1,2,3], q = [1,2,3]\nOutput: true\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)\n\n```\nInput: p = [1,2], q = [1,null,2]\nOutput: false\n```"
+            },
+            {
+                "content": "![Example 3](https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg)\n\n```\nInput: p = [1,2,1], q = [1,1,2]\nOutput: false\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in both trees is in the range [0, 100].\n- -10^4 <= Node.val <= 10^4",
+    "readme_additional": "",
+    "helpers_imports": "from leetcode_py import TreeNode",
+    "helpers_content": "",
+    "helpers_run_name": "is_same_tree",
+    "helpers_run_signature": "(solution_class: type, p_list: list[int | None], q_list: list[int | None])",
+    "helpers_run_body": "    p = TreeNode[int].from_list(p_list)\n    q = TreeNode[int].from_list(q_list)\n    implementation = solution_class()\n    return implementation.is_same_tree(p, q)",
+    "helpers_assert_name": "is_same_tree",
+    "helpers_assert_signature": "(result: bool, expected: bool) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_is_same_tree, run_is_same_tree\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "SameTree",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "is_same_tree",
+                "signature": "(self, p: TreeNode[int] | None, q: TreeNode[int] | None) -> bool",
+                "body": "        # TODO: Implement is_same_tree\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_is_same_tree",
+                "signature": "(self, p_list: list[int | None], q_list: list[int | None], expected: bool)",
+                "parametrize": "p_list, q_list, expected",
+                "test_cases": "[([1, 2, 3], [1, 2, 3], True), ([1, 2], [1, None, 2], False), ([1, 2, 1], [1, 1, 2], False), ([], [], True), ([1], [1], True), ([1], [2], False), ([1, None, 2], [1, 2], False), ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], True), ([1, 2, 3, 4, 5], [1, 2, 3, 4, 6], False), ([1, 2, 3, None, 4], [1, 2, 3, None, 4], True), ([1, 2, 3, None, 4], [1, 2, 3, 4, None], False)]",
+                "body": "        result = run_is_same_tree(Solution, p_list, q_list)\n        assert_is_same_tree(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_is_same_tree, assert_is_same_tree\nfrom solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_setup": "# Example test case\np_list: list[int | None] = [1, 2, 3]\nq_list: list[int | None] = [1, 2, 3]\nexpected = True",
+    "playground_run": "result = run_is_same_tree(Solution, p_list, q_list)\nresult",
+    "playground_assert": "assert_is_same_tree(result, expected)"
+}

leetcode_py/cli/resources/leetcode/json/problems/same_tree.json

@@ -110,6 +110,7 @@
 
     // Blind 75 - (on-going)
     "blind-75": [
+        "alien_dictionary",
         "best_time_to_buy_and_sell_stock",
         "binary_tree_level_order_traversal",
         "climbing_stairs",
@@ -149,6 +150,7 @@
         "remove_nth_node_from_end_of_list",
         "reverse_linked_list",
         "rotate_image",
+        "same_tree",
         "search_in_rotated_sorted_array",
         "serialize_and_deserialize_binary_tree",
         "set_matrix_zeroes",
@@ -166,6 +168,7 @@
 
     // NeetCode 150 - (on-going)
     "neetcode-150": [
+        "alien_dictionary",
         "balanced_binary_tree",
         "best_time_to_buy_and_sell_stock",
         "binary_search",
@@ -181,6 +184,7 @@
         "course_schedule",
         "course_schedule_ii",
         "daily_temperatures",
+        "decode_ways",
         "design_add_and_search_words_data_structure",
         "diameter_of_binary_tree",
         "evaluate_reverse_polish_notation",
@@ -192,6 +196,7 @@
         "implement_trie_prefix_tree",
         "insert_interval",
         "invert_binary_tree",
+        "jump_game",
         "k_closest_points_to_origin",
         "kth_smallest_element_in_a_bst",
         "largest_rectangle_in_histogram",
@@ -218,9 +223,12 @@
         "product_of_array_except_self",
         "remove_nth_node_from_end_of_list",
         "reverse_linked_list",
+        "rotate_image",
         "rotting_oranges",
+        "same_tree",
         "search_in_rotated_sorted_array",
         "serialize_and_deserialize_binary_tree",
+        "set_matrix_zeroes",
         "spiral_matrix",
         "subsets",
         "task_scheduler",
@@ -269,6 +277,7 @@
         "permutations",
         "product_of_array_except_self",
         "remove_nth_node_from_end_of_list",
+        "rotate_image",
         "rotting_oranges",
         "search_in_rotated_sorted_array",
         "serialize_and_deserialize_binary_tree",