leetcode-py-sdk 0.44.0__tar.gz → 0.46.0__tar.gz

{leetcode_py_sdk-0.44.0 → leetcode_py_sdk-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: leetcode-py-sdk
-Version: 0.44.0
+Version: 0.46.0
 Summary: Modern Python LeetCode practice environment with automated problem generation, beautiful data structure visualizations, and comprehensive testing
 Keywords: algorithms,coding-practice,data-structures,interview-prep,leetcode
 Author: Wisaroot Lertthaweedech
@@ -79,7 +79,7 @@ A Python package to generate professional LeetCode practice environments. Featur
 - **grind-75** - Essential coding interview questions from [Grind 75](https://www.techinterviewhandbook.org/grind75/) ✅ Complete
 - **grind** - Extended Grind collection including all Grind 75 plus additional problems 🚧 Partial
 - **blind-75** - Original [Blind 75](https://leetcode.com/problem-list/xi4ci4ig/) curated list ✅ Complete
-- **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set 🚧 Partial
+- **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set ✅ Complete
 - **algo-master-75** - Curated algorithmic mastery problems ✅ Complete
 
 **Coverage**: 130+ unique problems across all major coding interview topics and difficulty levels.

{leetcode_py_sdk-0.44.0 → leetcode_py_sdk-0.46.0}/README.md

@@ -43,7 +43,7 @@ A Python package to generate professional LeetCode practice environments. Featur
 - **grind-75** - Essential coding interview questions from [Grind 75](https://www.techinterviewhandbook.org/grind75/) ✅ Complete
 - **grind** - Extended Grind collection including all Grind 75 plus additional problems 🚧 Partial
 - **blind-75** - Original [Blind 75](https://leetcode.com/problem-list/xi4ci4ig/) curated list ✅ Complete
-- **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set 🚧 Partial
+- **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set ✅ Complete
 - **algo-master-75** - Curated algorithmic mastery problems ✅ Complete
 
 **Coverage**: 130+ unique problems across all major coding interview topics and difficulty levels.

{leetcode_py_sdk-0.44.0 → leetcode_py_sdk-0.46.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.44.0" # use git tag instead
+version = "0.46.0" # use git tag instead
 description = "Modern Python LeetCode practice environment with automated problem generation, beautiful data structure visualizations, and comprehensive testing"
 authors = [
   {name = "Wisaroot Lertthaweedech", email = "l.wisaroot@gmail.com"}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/best_time_to_buy_and_sell_stock_with_cooldown.json

@@ -0,0 +1,89 @@
+{
+    "problem_name": "best_time_to_buy_and_sell_stock_with_cooldown",
+    "solution_class_name": "Solution",
+    "problem_number": "309",
+    "problem_title": "Best Time to Buy and Sell Stock with Cooldown",
+    "difficulty": "Medium",
+    "topics": "Array, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.\n\nFind the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:\n\n- After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).\n\n**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: prices = [1,2,3,0,2]\nOutput: 3\n```\n**Explanation:** transactions = [buy, sell, cooldown, buy, sell]"
+            },
+            {
+                "content": "```\nInput: prices = [1]\nOutput: 0\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= prices.length <= 5000\n- 0 <= prices[i] <= 1000",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "max_profit",
+    "helpers_run_signature": "(solution_class: type, prices: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.max_profit(prices)",
+    "helpers_assert_name": "max_profit",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_max_profit, run_max_profit\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BestTimeToBuyAndSellStockWithCooldown",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "max_profit",
+                "signature": "(self, prices: list[int]) -> int",
+                "body": "        # TODO: Implement max_profit\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_max_profit",
+                "signature": "(self, prices: list[int], expected: int)",
+                "parametrize": "prices, expected",
+                "test_cases": {
+                    "list": [
+                        "([1, 2, 3, 0, 2], 3)",
+                        "([1], 0)",
+                        "([1, 2], 1)",
+                        "([3, 2, 1], 0)",
+                        "([1, 2, 3], 2)",
+                        "([1, 2, 4], 3)",
+                        "([2, 4, 1], 2)",
+                        "([1, 4, 2], 3)",
+                        "([1, 2, 3, 0, 2, 5], 6)",
+                        "([6, 1, 6, 4, 2, 0, 1], 6)",
+                        "([5], 0)",
+                        "([1, 2, 3, 4, 5], 4)",
+                        "([1, 3, 1, 4], 3)",
+                        "([2, 1], 0)"
+                    ]
+                },
+                "body": "        result = run_max_profit(Solution, prices)\n        assert_max_profit(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_max_profit, assert_max_profit\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nprices = [1, 2, 3, 0, 2]\nexpected = 3",
+    "playground_run": "result = run_max_profit(Solution, prices)\nresult",
+    "playground_assert": "assert_max_profit(result, expected)"
+}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/burst_balloons.json

@@ -0,0 +1,89 @@
+{
+    "problem_name": "burst_balloons",
+    "solution_class_name": "Solution",
+    "problem_number": "312",
+    "problem_title": "Burst Balloons",
+    "difficulty": "Hard",
+    "topics": "Array, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "You are given `n` balloons, indexed from `0` to `n - 1`. Each balloon is painted with a number on it represented by an array `nums`. You are asked to burst all the balloons.\n\nIf you burst the `ith` balloon, you will get `nums[i - 1] * nums[i] * nums[i + 1]` coins. If `i - 1` or `i + 1` goes out of bounds of the array, then treat it as if there is a balloon with a `1` painted on it.\n\nReturn *the maximum coins you can collect by bursting the balloons wisely*.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: nums = [3,1,5,8]\nOutput: 167\n```\n**Explanation:**\nnums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []\ncoins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167"
+            },
+            {
+                "content": "```\nInput: nums = [1,5]\nOutput: 10\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- n == nums.length\n- 1 <= n <= 300\n- 0 <= nums[i] <= 100",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "max_coins",
+    "helpers_run_signature": "(solution_class: type, nums: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.max_coins(nums)",
+    "helpers_assert_name": "max_coins",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_max_coins, run_max_coins\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BurstBalloons",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "max_coins",
+                "signature": "(self, nums: list[int]) -> int",
+                "body": "        # TODO: Implement max_coins\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_max_coins",
+                "signature": "(self, nums: list[int], expected: int)",
+                "parametrize": "nums, expected",
+                "test_cases": {
+                    "list": [
+                        "([3, 1, 5, 8], 167)",
+                        "([1, 5], 10)",
+                        "([5], 5)",
+                        "([1], 1)",
+                        "([0], 0)",
+                        "([100], 100)",
+                        "([0, 0, 0], 0)",
+                        "([2], 2)",
+                        "([1, 2], 4)",
+                        "([2, 2], 6)",
+                        "([1, 2, 3], 12)",
+                        "([3, 2, 1], 12)",
+                        "([3, 1, 5], 35)",
+                        "([4, 6, 7, 9], 639)"
+                    ]
+                },
+                "body": "        result = run_max_coins(Solution, nums)\n        assert_max_coins(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_max_coins, assert_max_coins\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [3, 1, 5, 8]\nexpected = 167",
+    "playground_run": "result = run_max_coins(Solution, nums)\nresult",
+    "playground_assert": "assert_max_coins(result, expected)"
+}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/car_fleet.json

@@ -0,0 +1,91 @@
+{
+    "problem_name": "car_fleet",
+    "solution_class_name": "Solution",
+    "problem_number": "853",
+    "problem_title": "Car Fleet",
+    "difficulty": "Medium",
+    "topics": "Array, Stack, Sorting, Monotonic Stack",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "There are `n` cars at given miles away from the starting mile 0, traveling to reach the mile `target`.\n\nYou are given two integer arrays `position` and `speed`, both of length `n`, where `position[i]` is the starting mile of the `i<sup>th</sup>` car and `speed[i]` is the speed of the `i<sup>th</sup>` car in miles per hour.\n\nA car cannot pass another car, but it can catch up and then travel next to it at the speed of the slower car.\n\nA **car fleet** is a single car or a group of cars driving next to each other. The speed of the car fleet is the **minimum** speed of any car in the fleet.\n\nIf a car catches up to a car fleet at the mile `target`, it will still be considered as part of the car fleet.\n\nReturn the number of car fleets that will arrive at the destination.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]\nOutput: 3\nExplanation:\n- The cars starting at 10 (speed 2) and 8 (speed 4) become a fleet, meeting each other at 12. The fleet forms at target.\n- The car starting at 0 (speed 1) does not catch up to any other car, so it is a fleet by itself.\n- The cars starting at 5 (speed 1) and 3 (speed 3) become a fleet, meeting each other at 6. The fleet moves at speed 1 until it reaches target.\n```"
+            },
+            {
+                "content": "```\nInput: target = 10, position = [3], speed = [3]\nOutput: 1\nExplanation: There is only one car, hence there is only one fleet.\n```"
+            },
+            {
+                "content": "```\nInput: target = 100, position = [0,2,4], speed = [4,2,1]\nOutput: 1\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- n == position.length == speed.length\n- 1 <= n <= 10<sup>5</sup>\n- 0 < target <= 10<sup>6</sup>\n- 0 <= position[i] < target\n- All the values of position are **unique**.\n- 0 < speed[i] <= 10<sup>6</sup>",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "car_fleet",
+    "helpers_run_signature": "(solution_class: type, target: int, position: list[int], speed: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.car_fleet(target, position, speed)",
+    "helpers_assert_name": "car_fleet",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_car_fleet, run_car_fleet\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "CarFleet",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "car_fleet",
+                "signature": "(self, target: int, position: list[int], speed: list[int]) -> int",
+                "body": "        # TODO: Implement car_fleet\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_car_fleet",
+                "signature": "(self, target: int, position: list[int], speed: list[int], expected: int)",
+                "parametrize": "target, position, speed, expected",
+                "test_cases": {
+                    "list": [
+                        "(12, [10, 8, 0, 5, 3], [2, 4, 1, 1, 3], 3)",
+                        "(10, [3], [3], 1)",
+                        "(100, [0, 2, 4], [4, 2, 1], 1)",
+                        "(10, [0], [1], 1)",
+                        "(20, [10, 15], [5, 1], 1)",
+                        "(100, [0, 1, 2], [1, 1, 1], 3)",
+                        "(10, [0, 2, 4, 6, 8], [1, 1, 1, 1, 1], 5)",
+                        "(10, [8, 6, 4, 2, 0], [2, 4, 6, 8, 10], 1)",
+                        "(15, [1, 5, 10], [4, 2, 1], 1)",
+                        "(20, [6, 10, 15], [2, 3, 1], 2)",
+                        "(5, [1, 3], [1, 2], 2)",
+                        "(20, [5, 10], [5, 5], 2)",
+                        "(50, [10, 20, 30, 40], [1, 1, 1, 1], 4)"
+                    ]
+                },
+                "body": "        result = run_car_fleet(Solution, target, position, speed)\n        assert_car_fleet(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_car_fleet, assert_car_fleet\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ntarget = 12\nposition = [10, 8, 0, 5, 3]\nspeed = [2, 4, 1, 1, 3]\nexpected = 3",
+    "playground_run": "result = run_car_fleet(Solution, target, position, speed)\nresult",
+    "playground_assert": "assert_car_fleet(result, expected)"
+}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/coin_change_ii.json

@@ -0,0 +1,92 @@
+{
+    "problem_name": "coin_change_ii",
+    "solution_class_name": "Solution",
+    "problem_number": "518",
+    "problem_title": "Coin Change II",
+    "difficulty": "Medium",
+    "topics": "Array, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.\n\nReturn *the number of combinations that make up that amount*. If that amount of money cannot be made up by any combination of the coins, return `0`.\n\nYou may assume that you have an infinite number of each kind of coin.\n\nThe final answer is **guaranteed** to fit into a signed 32-bit integer.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: amount = 5, coins = [1,2,5]\nOutput: 4\n```\n**Explanation:** there are four ways to make up the amount:\n5=5\n5=2+2+1\n5=2+1+1+1\n5=1+1+1+1+1"
+            },
+            {
+                "content": "```\nInput: amount = 3, coins = [2]\nOutput: 0\n```\n**Explanation:** the amount of 3 cannot be made up just with coins of 2."
+            },
+            {
+                "content": "```\nInput: amount = 10, coins = [10]\nOutput: 1\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= coins.length <= 300\n- 1 <= coins[i] <= 5000\n- All the values of `coins` are **unique**.\n- 0 <= amount <= 5000",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "change",
+    "helpers_run_signature": "(solution_class: type, amount: int, coins: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.change(amount, coins)",
+    "helpers_assert_name": "change",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_change, run_change\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "CoinChangeII",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "change",
+                "signature": "(self, amount: int, coins: list[int]) -> int",
+                "body": "        # TODO: Implement change\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_change",
+                "signature": "(self, amount: int, coins: list[int], expected: int)",
+                "parametrize": "amount, coins, expected",
+                "test_cases": {
+                    "list": [
+                        "(5, [1, 2, 5], 4)",
+                        "(3, [2], 0)",
+                        "(10, [10], 1)",
+                        "(0, [1, 2, 5], 1)",
+                        "(4, [1, 2], 3)",
+                        "(5, [2], 0)",
+                        "(1, [2], 0)",
+                        "(3, [1, 2], 2)",
+                        "(6, [1, 2, 3], 7)",
+                        "(2, [1], 1)",
+                        "(100, [1, 2, 5], 541)",
+                        "(7, [2, 3, 6], 1)",
+                        "(8, [2, 3, 5], 3)",
+                        "(500, [3, 5, 7], 1227)"
+                    ]
+                },
+                "body": "        result = run_change(Solution, amount, coins)\n        assert_change(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_change, assert_change\nfrom solution import Solution",
+    "playground_setup": "# Example test case\namount = 5\ncoins = [1, 2, 5]\nexpected = 4",
+    "playground_run": "result = run_change(Solution, amount, coins)\nresult",
+    "playground_assert": "assert_change(result, expected)"
+}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/copy_list_with_random_pointer.json

@@ -0,0 +1,91 @@
+{
+    "problem_name": "copy_list_with_random_pointer",
+    "solution_class_name": "Solution",
+    "problem_number": "138",
+    "problem_title": "Copy List with Random Pointer",
+    "difficulty": "Medium",
+    "topics": "Hash Table, Linked List",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "A linked list of length `n` is given such that each node contains an additional **random pointer**, which could point to any node in the list, or `null`.\n\nConstruct a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) of the list. The deep copy should consist of exactly `n` **brand new** nodes, where each new node has its value set to the value of its corresponding original node. Both the `next` and `random` pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. **None of the pointers in the new list should point to nodes in the original list**.\n\nReturn *the head of the copied linked list*.\n\nThe linked list is represented in the input/output as a list of `n` nodes. Each node is represented as a pair of `[val, random_index]` where:\n\n- `val`: an integer representing `Node.val`\n- `random_index`: the index of the node (range from `0` to `n-1`) that the `random` pointer points to, or `null` if it does not point to any node.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2019/12/18/e1.png)\n\n```\nInput: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]\nOutput: [[7,null],[13,0],[11,4],[10,2],[1,0]]\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2019/12/18/e2.png)\n\n```\nInput: head = [[1,1],[2,1]]\nOutput: [[1,1],[2,1]]\n```"
+            },
+            {
+                "content": "![Example 3](https://assets.leetcode.com/uploads/2019/12/18/e3.png)\n\n```\nInput: head = [[3,null],[3,0],[3,null]]\nOutput: [[3,null],[3,0],[3,null]]\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 0 <= n <= 1000\n- -10^4 <= Node.val <= 10^4\n- Node.random is null or points to some node in the linked list.",
+    "readme_additional": "",
+    "helpers_imports": "from .solution import Node",
+    "helpers_content": "def _build_random_list(nodes: list[list[int | None]]) -> Node | None:\n    if not nodes:\n        return None\n    created: list[Node] = []\n    for node_spec in nodes:\n        val = node_spec[0]\n        assert isinstance(val, int)\n        created.append(Node(val))\n    for i, node_spec in enumerate(nodes):\n        if i + 1 < len(created):\n            created[i].next = created[i + 1]\n        rand_idx = node_spec[1]\n        if rand_idx is not None:\n            created[i].random = created[rand_idx]\n    return created[0]\n\n\ndef _serialize_random_list(head: Node | None) -> list[list[int | None]]:\n    index_by_id: dict[int, int] = {}\n    cur: Node | None = head\n    i = 0\n    while cur is not None:\n        index_by_id[id(cur)] = i\n        i += 1\n        cur = cur.next\n    result: list[list[int | None]] = []\n    cur = head\n    while cur is not None:\n        rand_idx = index_by_id[id(cur.random)] if cur.random is not None else None\n        result.append([cur.val, rand_idx])\n        cur = cur.next\n    return result",
+    "helpers_run_name": "copy_random_list",
+    "helpers_run_signature": "(solution_class: type, nodes: list[list[int | None]])",
+    "helpers_run_body": "    implementation = solution_class()\n    head = _build_random_list(nodes)\n    copied = implementation.copy_random_list(head)\n    return _serialize_random_list(copied)",
+    "helpers_assert_name": "copy_random_list",
+    "helpers_assert_signature": "(result: list[list[int | None]], expected: list[list[int | None]]) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "from __future__ import annotations",
+    "solution_contents": "class Node:\n    def __init__(self, x: int, next: Node | None = None, random: Node | None = None):\n        self.val = int(x)\n        self.next = next\n        self.random = random\n\n\n",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_copy_random_list, run_copy_random_list\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "CopyListWithRandomPointer",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "copy_random_list",
+                "signature": "(self, head: Node | None) -> Node | None",
+                "body": "        # TODO: Implement copy_random_list\n        return None"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_copy_random_list",
+                "signature": "(self, nodes: list[list[int | None]], expected: list[list[int | None]])",
+                "parametrize": "nodes, expected",
+                "test_cases": {
+                    "list": [
+                        "([[7, None], [13, 0], [11, 4], [10, 2], [1, 0]], [[7, None], [13, 0], [11, 4], [10, 2], [1, 0]])",
+                        "([[1, 1], [2, 1]], [[1, 1], [2, 1]])",
+                        "([[3, None], [3, 0], [3, None]], [[3, None], [3, 0], [3, None]])",
+                        "([], [])",
+                        "([[1, None]], [[1, None]])",
+                        "([[1, 0]], [[1, 0]])",
+                        "([[1, None], [2, None]], [[1, None], [2, None]])",
+                        "([[5, 1], [6, None], [7, 0]], [[5, 1], [6, None], [7, 0]])",
+                        "([[0, None], [1, 0], [2, 1], [3, 2]], [[0, None], [1, 0], [2, 1], [3, 2]])",
+                        "([[1, None], [2, 2], [3, 2]], [[1, None], [2, 2], [3, 2]])",
+                        "([[42, None]], [[42, None]])",
+                        "([[1, 2], [2, None], [3, 0]], [[1, 2], [2, None], [3, 0]])",
+                        "([[1, None], [2, 0], [3, 1], [4, 2]], [[1, None], [2, 0], [3, 1], [4, 2]])"
+                    ]
+                },
+                "body": "        result = run_copy_random_list(Solution, nodes)\n        assert_copy_random_list(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_copy_random_list, assert_copy_random_list\nfrom solution import Node, Solution",
+    "playground_setup": "# Example test case (each node is [val, random_index])\nnodes = [[7, None], [13, 0], [11, 4], [10, 2], [1, 0]]\nexpected = [[7, None], [13, 0], [11, 4], [10, 2], [1, 0]]",
+    "playground_run": "result = run_copy_random_list(Solution, nodes)\nresult",
+    "playground_assert": "assert_copy_random_list(result, expected)"
+}

leetcode_py_sdk-0.46.0/src/leetcode_py/cli/resources/leetcode/json/problems/count_good_nodes_in_binary_tree.json

@@ -0,0 +1,95 @@
+{
+    "problem_name": "count_good_nodes_in_binary_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "1448",
+    "problem_title": "Count Good Nodes in Binary Tree",
+    "difficulty": "Medium",
+    "topics": "Tree, Depth-First Search, Breadth-First Search, Binary Tree",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_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.\n\nReturn the number of **good** nodes in the binary tree.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2020/04/02/test_sample_1.png)\n\n```\nInput: root = [3,1,4,3,null,1,5]\nOutput: 4\nExplanation: Nodes in blue are good.\nRoot Node (3) is always a good node.\nNode 4 -> (3,4) is the maximum value in the path starting from the root.\nNode 5 -> (3,4,5) is the maximum value in the path.\nNode 3 -> (3,1,3) is the maximum value in the path.\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2020/04/02/test_sample_2.png)\n\n```\nInput: root = [3,3,null,4,2]\nOutput: 3\nExplanation: Node 2 -> (3,3,2) is not good, because \"3\" is higher than it.\n```"
+            },
+            {
+                "content": "```\nInput: root = [1]\nOutput: 1\nExplanation: Root is considered as good.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in the binary tree is in the range `[1, 10^5]`.\n- Each node's value is between `[-10^4, 10^4]`.",
+    "readme_additional": "",
+    "helpers_imports": "from leetcode_py import TreeNode",
+    "helpers_content": "",
+    "helpers_run_name": "good_nodes",
+    "helpers_run_signature": "(solution_class: type, root_list: list[int | None])",
+    "helpers_run_body": "    implementation = solution_class()\n    root = TreeNode.from_list(root_list) if root_list else None\n    return implementation.good_nodes(root)",
+    "helpers_assert_name": "good_nodes",
+    "helpers_assert_signature": "(result: int, expected: int) -> 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_good_nodes, run_good_nodes\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "CountGoodNodesInBinaryTree",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "good_nodes",
+                "signature": "(self, root: TreeNode[int] | None) -> int",
+                "body": "        # TODO: Implement good_nodes\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_good_nodes",
+                "signature": "(self, root_list: list[int | None], expected: int)",
+                "parametrize": "root_list, expected",
+                "test_cases": {
+                    "list": [
+                        "([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)"
+                    ]
+                },
+                "body": "        result = run_good_nodes(Solution, root_list)\n        assert_good_nodes(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_good_nodes, assert_good_nodes\nfrom solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_setup": "# Example test case\nroot_list: list[int | None] = [3, 1, 4, 3, None, 1, 5]\nexpected = 4",
+    "playground_run": "result = run_good_nodes(Solution, root_list)\nresult",
+    "playground_assert": "assert_good_nodes(result, expected)"
+}