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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: leetcode-py-sdk
-Version: 0.45.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.45.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.45.0 → leetcode_py_sdk-0.46.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.45.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/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)"
+}

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

@@ -0,0 +1,99 @@
+{
+    "problem_name": "design_twitter",
+    "solution_class_name": "Twitter",
+    "problem_number": "355",
+    "problem_title": "Design Twitter",
+    "difficulty": "Medium",
+    "topics": "Hash Table, Linked List, Design, Heap (Priority Queue)",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "Design a simplified version of Twitter where users can post tweets, follow/unfollow another user, and is able to see the `10` most recent tweets in the user's news feed.\n\nImplement the `Twitter` class:\n\n- `Twitter()` Initializes your twitter object.\n- `void postTweet(int userId, int tweetId)` Composes a new tweet with ID `tweetId` by the user `userId`. Each call to this function will be made with a unique `tweetId`.\n- `List<Integer> getNewsFeed(int userId)` Retrieves the `10` most recent tweet IDs in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user themself. Tweets must be **ordered from most recent to least recent**.\n- `void follow(int followerId, int followeeId)` The user with ID `followerId` started following the user with ID `followeeId`.\n- `void unfollow(int followerId, int followeeId)` The user with ID `followerId` started unfollowing the user with ID `followeeId`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput\n[\"Twitter\", \"postTweet\", \"getNewsFeed\", \"follow\", \"postTweet\", \"getNewsFeed\", \"unfollow\", \"getNewsFeed\"]\n[[], [1, 5], [1], [1, 2], [2, 6], [1], [1, 2], [1]]\nOutput\n[null, null, [5], null, null, [6, 5], null, [5]]\n\nExplanation\nTwitter twitter = new Twitter();\ntwitter.postTweet(1, 5); // User 1 posts a new tweet (id = 5).\ntwitter.getNewsFeed(1);  // User 1's news feed should return a list with 1 tweet id -> [5]. return [5]\ntwitter.follow(1, 2);    // User 1 follows user 2.\ntwitter.postTweet(2, 6); // User 2 posts a new tweet (id = 6).\ntwitter.getNewsFeed(1);  // User 1's news feed should return a list with 2 tweet ids -> [6, 5]. Tweet id 6 should precede tweet id 5 because it is posted after tweet id 5.\ntwitter.unfollow(1, 2);  // User 1 unfollows user 2.\ntwitter.getNewsFeed(1);  // User 1's news feed should return a list with 1 tweet id -> [5], since user 1 is no longer following user 2.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= userId, followerId, followeeId <= 500\n- 0 <= tweetId <= 10^4\n- All the tweets have **unique** IDs.\n- At most `3 * 10^4` calls will be made to `postTweet`, `getNewsFeed`, `follow`, and `unfollow`.\n- A user cannot follow himself.",
+    "readme_additional": "",
+    "helpers_imports": "from typing import Any",
+    "helpers_content": "",
+    "helpers_run_name": "twitter",
+    "helpers_run_signature": "(solution_class: type, operations: list[str], inputs: list[list[int]])",
+    "helpers_run_body": "    twitter: Any = None\n    results: list[Any] = []\n\n    for op, args in zip(operations, inputs, strict=False):\n        if op == 'Twitter':\n            twitter = solution_class()\n            results.append(None)\n        elif op == 'postTweet':\n            assert twitter is not None\n            twitter.post_tweet(args[0], args[1])\n            results.append(None)\n        elif op == 'getNewsFeed':\n            assert twitter is not None\n            results.append(twitter.get_news_feed(args[0]))\n        elif op == 'follow':\n            assert twitter is not None\n            twitter.follow(args[0], args[1])\n            results.append(None)\n        elif op == 'unfollow':\n            assert twitter is not None\n            twitter.unfollow(args[0], args[1])\n            results.append(None)\n\n    return results",
+    "helpers_assert_name": "twitter",
+    "helpers_assert_signature": "(result: list[Any], expected: list[Any]) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "import heapq",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "from typing import Any\n\nimport pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_twitter, run_twitter\nfrom .solution import Twitter",
+    "test_content": "",
+    "test_class_name": "DesignTwitter",
+    "test_class_content": "",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "__init__",
+                "signature": "(self) -> None",
+                "body": "        # TODO: Initialize data structure\n        pass"
+            },
+            {
+                "name": "post_tweet",
+                "signature": "(self, user_id: int, tweet_id: int) -> None",
+                "body": "        # TODO: Implement post_tweet\n        pass"
+            },
+            {
+                "name": "get_news_feed",
+                "signature": "(self, user_id: int) -> list[int]",
+                "body": "        # TODO: Implement get_news_feed\n        return []"
+            },
+            {
+                "name": "follow",
+                "signature": "(self, follower_id: int, followee_id: int) -> None",
+                "body": "        # TODO: Implement follow\n        pass"
+            },
+            {
+                "name": "unfollow",
+                "signature": "(self, follower_id: int, followee_id: int) -> None",
+                "body": "        # TODO: Implement unfollow\n        pass"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": []
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_twitter",
+                "signature": "(self, operations: list[str], inputs: list[list[int]], expected: list[Any])",
+                "parametrize": "operations, inputs, expected",
+                "test_cases": {
+                    "list": [
+                        "(['Twitter', 'postTweet', 'getNewsFeed', 'follow', 'postTweet', 'getNewsFeed', 'unfollow', 'getNewsFeed'], [[], [1, 5], [1], [1, 2], [2, 6], [1], [1, 2], [1]], [None, None, [5], None, None, [6, 5], None, [5]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'postTweet', 'getNewsFeed'], [[], [1, 1], [1, 2], [1, 3], [1]], [None, None, None, None, [3, 2, 1]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'follow', 'getNewsFeed'], [[], [1, 10], [2, 20], [1, 2], [1]], [None, None, None, None, [20, 10]])",
+                        "(['Twitter', 'follow', 'follow', 'postTweet', 'postTweet', 'getNewsFeed'], [[], [1, 2], [1, 3], [2, 100], [3, 200], [1]], [None, None, None, None, None, [200, 100]])",
+                        "(['Twitter', 'postTweet', 'follow', 'getNewsFeed', 'unfollow', 'getNewsFeed'], [[], [2, 50], [1, 2], [1], [1, 2], [1]], [None, None, None, [50], None, []])",
+                        "(['Twitter', 'postTweet', 'getNewsFeed'], [[], [1, 5], [1]], [None, None, [5]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'getNewsFeed'], [[], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [1, 9], [1, 10], [1, 11], [1, 12], [1]], [None, None, None, None, None, None, None, None, None, None, None, None, None, [12, 11, 10, 9, 8, 7, 6, 5, 4, 3]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'unfollow', 'getNewsFeed'], [[], [1, 7], [1, 8], [1, 1], [1]], [None, None, None, None, [8, 7]])",
+                        "(['Twitter', 'follow', 'postTweet', 'postTweet', 'getNewsFeed', 'unfollow', 'getNewsFeed'], [[], [1, 2], [2, 30], [1, 40], [1], [1, 2], [1]], [None, None, None, None, [40, 30], None, [40]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'postTweet', 'getNewsFeed', 'getNewsFeed'], [[], [1, 11], [1, 22], [1, 33], [1, 44], [1, 55], [1], [1]], [None, None, None, None, None, None, [55, 44, 33, 22, 11], [55, 44, 33, 22, 11]])",
+                        "(['Twitter', 'follow', 'postTweet', 'getNewsFeed', 'getNewsFeed'], [[], [1, 2], [2, 99], [1], [2]], [None, None, None, [99], [99]])",
+                        "(['Twitter', 'postTweet', 'postTweet', 'follow', 'follow', 'getNewsFeed', 'unfollow', 'getNewsFeed'], [[], [1, 1], [2, 2], [1, 2], [1, 2], [1], [1, 2], [1]], [None, None, None, None, None, [2, 1], None, [1]])",
+                        "(['Twitter', 'follow', 'postTweet', 'postTweet', 'postTweet', 'getNewsFeed'], [[], [1, 2], [1, 1], [2, 2], [2, 3], [1]], [None, None, None, None, None, [3, 2, 1]])"
+                    ]
+                },
+                "body": "        result = run_twitter(Twitter, operations, inputs)\n        assert_twitter(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_twitter, assert_twitter\nfrom solution import Twitter",
+    "playground_setup": "# Example test case\noperations = ['Twitter', 'postTweet', 'getNewsFeed', 'follow', 'postTweet', 'getNewsFeed', 'unfollow', 'getNewsFeed']\ninputs = [[], [1, 5], [1], [1, 2], [2, 6], [1], [1, 2], [1]]\nexpected = [None, None, [5], None, None, [6, 5], None, [5]]",
+    "playground_run": "result = run_twitter(Twitter, operations, inputs)\nresult",
+    "playground_assert": "assert_twitter(result, expected)"
+}