leetcode-py-sdk 1.0.4__tar.gz → 1.0.6__tar.gz

{leetcode_py_sdk-1.0.4 → leetcode_py_sdk-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: leetcode-py-sdk
-Version: 1.0.4
+Version: 1.0.6
 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
@@ -28,7 +28,7 @@ Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=14.1.0
 Requires-Dist: ruff>=0.14.0
 Requires-Dist: ty>=0.0.13
-Requires-Dist: typer>=0.21.0
+Requires-Dist: typer>=0.21.0,<0.27.2
 Requires-Python: >=3.10
 Project-URL: Changelog, https://github.com/wislertt/leetcode-py/releases
 Project-URL: Documentation, https://leetcode-py.wisl.dev
@@ -92,7 +92,7 @@ See the [Quickstart](https://leetcode-py.wisl.dev/getting-started/quickstart) fo
 
 ## 🗂️ Collections
 
-307 problems, ready to generate, across six complete collections. Browse them all in the [catalog](https://leetcode-py.wisl.dev/catalog):
+<!-- problem-count:start -->531<!-- problem-count:end --> problems, ready to generate, across seven complete collections. Browse them all in the [catalog](https://leetcode-py.wisl.dev/catalog):
 
 | Collection                                                           | What it is                                                  |
 | -------------------------------------------------------------------- | ----------------------------------------------------------- |
@@ -101,6 +101,7 @@ See the [Quickstart](https://leetcode-py.wisl.dev/getting-started/quickstart) fo
 | [Blind 75](https://leetcode-py.wisl.dev/catalog/blind-75)            | The original curated list                                   |
 | [NeetCode 150](https://leetcode-py.wisl.dev/catalog/neetcode-150)    | Comprehensive coverage by topic                             |
 | [NeetCode 250](https://leetcode-py.wisl.dev/catalog/neetcode-250)    | NeetCode 150 plus 100 more                                  |
+| [NeetCode All](https://leetcode-py.wisl.dev/catalog/neetcode)        | The complete neetcode.io list; coverage still growing       |
 | [AlgoMaster 75](https://leetcode-py.wisl.dev/catalog/algo-master-75) | Curated algorithmic mastery problems                        |
 
 ## 🛠️ Development

{leetcode_py_sdk-1.0.4 → leetcode_py_sdk-1.0.6}/README.md

@@ -53,7 +53,7 @@ See the [Quickstart](https://leetcode-py.wisl.dev/getting-started/quickstart) fo
 
 ## 🗂️ Collections
 
-307 problems, ready to generate, across six complete collections. Browse them all in the [catalog](https://leetcode-py.wisl.dev/catalog):
+<!-- problem-count:start -->531<!-- problem-count:end --> problems, ready to generate, across seven complete collections. Browse them all in the [catalog](https://leetcode-py.wisl.dev/catalog):
 
 | Collection                                                           | What it is                                                  |
 | -------------------------------------------------------------------- | ----------------------------------------------------------- |
@@ -62,6 +62,7 @@ See the [Quickstart](https://leetcode-py.wisl.dev/getting-started/quickstart) fo
 | [Blind 75](https://leetcode-py.wisl.dev/catalog/blind-75)            | The original curated list                                   |
 | [NeetCode 150](https://leetcode-py.wisl.dev/catalog/neetcode-150)    | Comprehensive coverage by topic                             |
 | [NeetCode 250](https://leetcode-py.wisl.dev/catalog/neetcode-250)    | NeetCode 150 plus 100 more                                  |
+| [NeetCode All](https://leetcode-py.wisl.dev/catalog/neetcode)        | The complete neetcode.io list; coverage still growing       |
 | [AlgoMaster 75](https://leetcode-py.wisl.dev/catalog/algo-master-75) | Curated algorithmic mastery problems                        |
 
 ## 🛠️ Development

{leetcode_py_sdk-1.0.4 → leetcode_py_sdk-1.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "1.0.4"
+version = "1.0.6"
 description = "Modern Python LeetCode practice environment with automated problem generation, beautiful data structure visualizations, and comprehensive testing"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -36,7 +36,7 @@ dependencies = [
     "rich>=14.1.0",
     "ruff>=0.14.0",
     "ty>=0.0.13",
-    "typer>=0.21.0",
+    "typer>=0.21.0,<0.27.2",
 ]
 
 [[project.authors]]

{leetcode_py_sdk-1.0.4 → leetcode_py_sdk-1.0.6}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "1.0.4" # use git tag instead
+version = "1.0.6" # 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"}
@@ -34,7 +34,7 @@ dependencies = [
   "rich>=14.1.0",
   "ruff>=0.14.0",
   "ty>=0.0.13",
-  "typer>=0.21.0"
+  "typer>=0.21.0,<0.27.2"
 ]
 
 [project.scripts]

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/add_to_array_form_of_integer.json

@@ -0,0 +1,90 @@
+{
+    "problem_name": "add_to_array_form_of_integer",
+    "solution_class_name": "Solution",
+    "problem_number": "989",
+    "problem_title": "Add to Array-Form of Integer",
+    "difficulty": "Easy",
+    "topics": "Array, Math",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "The **array-form** of an integer `num` is an array representing its digits in left to right order.\n\n- For example, for `num = 1321`, the array form is `[1,3,2,1]`.\n\nGiven `num`, the **array-form** of an integer, and an integer `k`, return *the **array-form** of the integer* `num + k`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: num = [1,2,0,0], k = 34\nOutput: [1,2,3,4]\nExplanation: 1200 + 34 = 1234\n```"
+            },
+            {
+                "content": "```\nInput: num = [2,7,4], k = 181\nOutput: [4,5,5]\nExplanation: 274 + 181 = 455\n```"
+            },
+            {
+                "content": "```\nInput: num = [2,1,5], k = 806\nOutput: [1,0,2,1]\nExplanation: 215 + 806 = 1021\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- `1 <= num.length <= 10^4`\n- `0 <= num[i] <= 9`\n- `num` does not contain any leading zeros except for the zero itself.\n- `1 <= k <= 10^4`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "add_to_array_form",
+    "helpers_run_signature": "(solution_class: type, num: list[int], k: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.add_to_array_form(num, k)",
+    "helpers_assert_name": "add_to_array_form",
+    "helpers_assert_signature": "(result: list[int], expected: list[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_add_to_array_form, run_add_to_array_form\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AddToArrayFormOfInteger",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "add_to_array_form",
+                "signature": "(self, num: list[int], k: int) -> list[int]",
+                "body": "        # TODO: Implement add_to_array_form\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_add_to_array_form",
+                "signature": "(self, num: list[int], k: int, expected: list[int])",
+                "parametrize": "num, k, expected",
+                "test_cases": {
+                    "list": [
+                        "([1, 2, 0, 0], 34, [1, 2, 3, 4])",
+                        "([2, 7, 4], 181, [4, 5, 5])",
+                        "([2, 1, 5], 806, [1, 0, 2, 1])",
+                        "([0], 1, [1])",
+                        "([0], 1000, [1, 0, 0, 0])",
+                        "([9, 9, 9], 1, [1, 0, 0, 0])",
+                        "([1], 9999, [1, 0, 0, 0, 0])",
+                        "([5, 5, 5], 555, [1, 1, 1, 0])",
+                        "([9], 9, [1, 8])",
+                        "([1, 0, 0, 0, 0, 0, 0, 0], 1, [1, 0, 0, 0, 0, 0, 0, 1])",
+                        "([3, 8, 1], 619, [1, 0, 0, 0])",
+                        "([7], 993, [1, 0, 0, 0])"
+                    ]
+                },
+                "body": "        result = run_add_to_array_form(Solution, num, k)\n        assert_add_to_array_form(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_add_to_array_form, assert_add_to_array_form\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnum = [1, 2, 0, 0]\nk = 34\nexpected = [1, 2, 3, 4]",
+    "playground_run": "result = run_add_to_array_form(Solution, num, k)\nresult",
+    "playground_assert": "assert_add_to_array_form(result, expected)"
+}

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/add_two_numbers_ii.json

@@ -0,0 +1,91 @@
+{
+    "problem_name": "add_two_numbers_ii",
+    "solution_class_name": "Solution",
+    "problem_number": "445",
+    "problem_title": "Add Two Numbers II",
+    "difficulty": "Medium",
+    "topics": "Linked List, Math, Stack",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "You are given two **non-empty** linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.\n\nYou may assume the two numbers do not contain any leading zero, except the number `0` itself.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2021/04/09/sumii-linked-list.jpg)\n\n```\nInput: l1 = [7,2,4,3], l2 = [5,6,4]\nOutput: [7,8,0,7]\n```"
+            },
+            {
+                "content": "```\nInput: l1 = [2,4,3], l2 = [5,6,4]\nOutput: [8,0,7]\n```"
+            },
+            {
+                "content": "```\nInput: l1 = [0], l2 = [0]\nOutput: [0]\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in each linked list is in the range `[1, 100]`.\n- `0 <= Node.val <= 9`\n- It is guaranteed that the list represents a number that does not have leading zeros.",
+    "readme_additional": "**Follow up:** Could you solve it without reversing the input lists?",
+    "helpers_imports": "from leetcode_py import ListNode",
+    "helpers_content": "",
+    "helpers_run_name": "add_two_numbers",
+    "helpers_run_signature": "(solution_class: type, l1_vals: list[int], l2_vals: list[int])",
+    "helpers_run_body": "    l1 = ListNode[int].from_list(l1_vals)\n    l2 = ListNode[int].from_list(l2_vals)\n    implementation = solution_class()\n    return implementation.add_two_numbers(l1, l2)",
+    "helpers_assert_name": "add_two_numbers",
+    "helpers_assert_signature": "(result: ListNode[int] | None, expected_vals: list[int]) -> bool",
+    "helpers_assert_body": "    expected = ListNode[int].from_list(expected_vals)\n    assert result == expected\n    return True",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_add_two_numbers, run_add_two_numbers\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AddTwoNumbersII",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "add_two_numbers",
+                "signature": "(self, l1: ListNode[int] | None, l2: ListNode[int] | None) -> ListNode[int] | None",
+                "body": "        # TODO: Implement add_two_numbers\n        return None"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_add_two_numbers",
+                "signature": "(self, l1_vals: list[int], l2_vals: list[int], expected_vals: list[int])",
+                "parametrize": "l1_vals, l2_vals, expected_vals",
+                "test_cases": {
+                    "list": [
+                        "([7, 2, 4, 3], [5, 6, 4], [7, 8, 0, 7])",
+                        "([2, 4, 3], [5, 6, 4], [8, 0, 7])",
+                        "([0], [0], [0])",
+                        "([9, 9, 9, 9], [1], [1, 0, 0, 0, 0])",
+                        "([1], [9], [1, 0])",
+                        "([5], [5], [1, 0])",
+                        "([1, 0, 0], [9, 9], [1, 9, 9])",
+                        "([3, 7, 8], [5, 4, 3], [9, 2, 1])",
+                        "([9], [9, 9, 9], [1, 0, 0, 8])",
+                        "([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [6, 6, 6, 6, 6])",
+                        "([9, 9], [9, 9], [1, 9, 8])",
+                        "([1, 8, 9], [2, 1], [2, 1, 0])",
+                        "([0], [9, 9, 9], [9, 9, 9])"
+                    ]
+                },
+                "body": "        result = run_add_two_numbers(Solution, l1_vals, l2_vals)\n        assert_add_two_numbers(result, expected_vals)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_add_two_numbers, assert_add_two_numbers\nfrom solution import Solution\nfrom leetcode_py import ListNode",
+    "playground_setup": "# Example test case\nl1_vals = [7, 2, 4, 3]\nl2_vals = [5, 6, 4]\nexpected_vals = [7, 8, 0, 7]",
+    "playground_run": "result = run_add_two_numbers(Solution, l1_vals, l2_vals)\nListNode[int].to_list(result) if result else []",
+    "playground_assert": "assert_add_two_numbers(result, expected_vals)"
+}

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/all_possible_full_binary_trees.json

@@ -0,0 +1,97 @@
+{
+    "problem_name": "all_possible_full_binary_trees",
+    "solution_class_name": "Solution",
+    "problem_number": "894",
+    "problem_title": "All Possible Full Binary Trees",
+    "difficulty": "Medium",
+    "topics": "Dynamic Programming, Tree, Recursion, Memoization, Binary Tree",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "Given an integer <code>n</code>, return <em>a list of all possible <strong>full binary trees</strong> with</em> <code>n</code> <em>nodes</em>. Each node of each tree in the answer must have <code>Node.val == 0</code>.</p>\n\n<p>Each element of the answer is the root node of one possible tree. You may return the final list of trees in <strong>any order</strong>.</p>\n\n<p>A <strong>full binary tree</strong> is a binary tree where each node has exactly <code>0</code> or <code>2</code> children.</p>",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: n = 7\nOutput: [[0,0,0,None,None,0,0,None,None,0,0],[0,0,0,None,None,0,0,None,None,0,0],[0,0,0,0,0,None,None,0,0],[0,0,0,0,0,None,None,0,0],[0,0,0,0,0,0,0]]\n```"
+            },
+            {
+                "content": "```\nInput: n = 3\nOutput: [[0,0,0]]\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= n <= 20",
+    "readme_additional": "",
+    "helpers_imports": "from leetcode_py import TreeNode",
+    "helpers_content": "def assert_all_possible_fbt_solution_count(result: list[TreeNode[int] | None], expected: int) -> bool:\n    assert len(result) == expected\n    return True",
+    "helpers_run_name": "all_possible_fbt",
+    "helpers_run_signature": "(solution_class: type, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.all_possible_fbt(n)",
+    "helpers_assert_name": "all_possible_fbt",
+    "helpers_assert_signature": "(result: list[TreeNode[int] | None], expected: list[list[int | None]]) -> bool",
+    "helpers_assert_body": "    # Trees serialize to lists; compare as multisets since order doesn't matter\n    roots = [tree for tree in result if tree is not None]\n    assert len(roots) == len(result)\n\n    def key(tree: list[int | None]) -> tuple[int, str]:\n        return (len(tree), str(tree))\n\n    result_lists = [tree.to_list() for tree in roots]\n    assert sorted(result_lists, key=key) == sorted(expected, key=key)\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 (\n    assert_all_possible_fbt,\n    assert_all_possible_fbt_solution_count,\n    run_all_possible_fbt,\n)\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AllPossibleFullBinaryTrees",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "all_possible_fbt",
+                "signature": "(self, n: int) -> list[TreeNode[int] | None]",
+                "body": "        # TODO: Implement all_possible_fbt\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_all_possible_fbt",
+                "signature": "(self, n: int, expected: list[list[int | None]])",
+                "parametrize": "n, expected",
+                "test_cases": {
+                    "list": [
+                        "(1, [[0]])",
+                        "(3, [[0, 0, 0]])",
+                        "(5, [[0, 0, 0, None, None, 0, 0], [0, 0, 0, 0, 0]])",
+                        "(7,[[0,0,0,0,0,0,0],[0,0,0,0,0,None,None,0,0],[0,0,0,None,None,0,0,0,0],[0,0,0,0,0,None,None,None,None,0,0],[0,0,0,None,None,0,0,None,None,0,0]])"
+                    ]
+                },
+                "body": "        result = run_all_possible_fbt(Solution, n)\n        assert_all_possible_fbt(result, expected)"
+            },
+            {
+                "name": "test_all_possible_fbt_solution_count",
+                "signature": "(self, n: int, expected_count: int)",
+                "parametrize": "n, expected_count",
+                "test_cases": {
+                    "list": [
+                        "(9, 14)",
+                        "(11, 42)",
+                        "(13, 132)",
+                        "(15, 429)",
+                        "(17, 1430)",
+                        "(19, 4862)",
+                        "(21, 16796)",
+                        "(23, 58786)"
+                    ]
+                },
+                "body": "        result = run_all_possible_fbt(Solution, n)\n        assert_all_possible_fbt_solution_count(result, expected_count)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_all_possible_fbt, assert_all_possible_fbt\nfrom solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_setup": "# Example test case\nn = 5\nexpected = [[0, 0, 0, None, None, 0, 0], [0, 0, 0, 0, 0]]",
+    "playground_run": "result = run_all_possible_fbt(Solution, n)\nresult",
+    "playground_assert": "assert_all_possible_fbt(result, expected)"
+}

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/android_unlock_patterns.json

@@ -0,0 +1,90 @@
+{
+    "problem_name": "android_unlock_patterns",
+    "solution_class_name": "Solution",
+    "problem_number": "351",
+    "problem_title": "Android Unlock Patterns",
+    "difficulty": "Medium",
+    "topics": "Bit Manipulation, Dynamic Programming, Backtracking, Bitmask",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "Android devices have a special lock screen with a `3 x 3` grid of dots. Users can set an \"unlock pattern\" by connecting the dots in a specific sequence, forming a series of joined line segments where each segment's endpoints are two consecutive dots in the sequence. A sequence of `k` dots is a **valid** unlock pattern if both of the following are true:\n\n- All the dots in the sequence are **distinct**.\n- If the line segment connecting two consecutive dots in the sequence passes through the **center** of any other dot, the other dot **must have previously appeared** in the sequence. No jumps through the center non-selected dots are allowed.\n    - For example, connecting dots `2` and `9` without dots `5` or `6` appearing beforehand is valid because the line from dot `2` to dot `9` does not pass through the center of either dot `5` or `6`.\n    - However, connecting dots `1` and `3` without dot `2` appearing beforehand is invalid because the line from dot `1` to dot `3` passes through the center of dot `2`.\n\nGiven two integers `m` and `n`, return *the **number of unique and valid unlock patterns** of the Android grid lock screen that consist of **at least*** `m` *keys and **at most*** `n` *keys*.\n\nTwo unlock patterns are considered **unique** if there is a dot in one sequence that is not in the other, or the order of the dots is different.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Unlock patterns](https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0300-0399/0351.Android%20Unlock%20Patterns/images/android-unlock.png)\n\n```\nInput: m = 1, n = 1\nOutput: 9\n```"
+            },
+            {
+                "content": "```\nInput: m = 1, n = 2\nOutput: 65\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- `1 <= m, n <= 9`\n- `m <= n`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "number_of_patterns",
+    "helpers_run_signature": "(solution_class: type, m: int, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.number_of_patterns(m, n)",
+    "helpers_assert_name": "number_of_patterns",
+    "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_number_of_patterns, run_number_of_patterns\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AndroidUnlockPatterns",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "number_of_patterns",
+                "signature": "(self, m: int, n: int) -> int",
+                "body": "        # TODO: Implement number_of_patterns\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_number_of_patterns",
+                "signature": "(self, m: int, n: int, expected: int)",
+                "parametrize": "m, n, expected",
+                "test_cases": {
+                    "list": [
+                        "(1,1,9)",
+                        "(1,2,65)",
+                        "(2,2,56)",
+                        "(1,3,385)",
+                        "(3,3,320)",
+                        "(1,9,389497)",
+                        "(9,9,140704)",
+                        "(2,3,376)",
+                        "(4,4,1624)",
+                        "(8,9,281408)",
+                        "(5,5,7152)",
+                        "(6,6,26016)",
+                        "(7,7,72912)",
+                        "(1,4,2009)",
+                        "(2,9,389488)"
+                    ]
+                },
+                "body": "        result = run_number_of_patterns(Solution, m, n)\n        assert_number_of_patterns(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_number_of_patterns, assert_number_of_patterns\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nm = 1\nn = 2\nexpected = 65",
+    "playground_run": "result = run_number_of_patterns(Solution, m, n)\nresult",
+    "playground_assert": "assert_number_of_patterns(result, expected)"
+}

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/arithmetic_slices_ii_subsequence.json

@@ -0,0 +1,92 @@
+{
+    "problem_name": "arithmetic_slices_ii_subsequence",
+    "solution_class_name": "Solution",
+    "problem_number": "446",
+    "problem_title": "Arithmetic Slices II - Subsequence",
+    "difficulty": "Hard",
+    "topics": "Array, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "Given an integer array `nums`, return *the number of all the **arithmetic subsequences** of* `nums`.\n\nA sequence of numbers is called arithmetic if it consists of **at least three elements** and if the difference between any two consecutive elements is the same.\n\n- For example, `[1, 3, 5, 7, 9]`, `[7, 7, 7, 7]`, and `[3, -1, -5, -9]` are arithmetic sequences.\n- For example, `[1, 1, 2, 5, 7]` is not an arithmetic sequence.\n\nA **subsequence** of an array is a sequence that can be formed by removing some elements (possibly none) of the array.\n\n- For example, `[2,5,10]` is a subsequence of `[1,2,1,**2**,4,1,**5**,**10**]`.\n\nThe test cases are generated so that the answer fits in **32-bit** integer.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: nums = [2,4,6,8,10]\nOutput: 7\nExplanation: All arithmetic subsequence slices are:\n[2,4,6]\n[4,6,8]\n[6,8,10]\n[2,4,6,8]\n[4,6,8,10]\n[2,4,6,8,10]\n[2,6,10]\n```"
+            },
+            {
+                "content": "```\nInput: nums = [7,7,7,7,7]\nOutput: 16\nExplanation: Any subsequence of this array is arithmetic.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- `1 <= nums.length <= 1000`\n- `-2^31 <= nums[i] <= 2^31 - 1`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "number_of_arithmetic_slices",
+    "helpers_run_signature": "(solution_class: type, nums: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.number_of_arithmetic_slices(nums)",
+    "helpers_assert_name": "number_of_arithmetic_slices",
+    "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_number_of_arithmetic_slices, run_number_of_arithmetic_slices\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ArithmeticSlicesIISubsequence",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "number_of_arithmetic_slices",
+                "signature": "(self, nums: list[int]) -> int",
+                "body": "        # TODO: Implement number_of_arithmetic_slices\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_number_of_arithmetic_slices",
+                "signature": "(self, nums: list[int], expected: int)",
+                "parametrize": "nums, expected",
+                "test_cases": {
+                    "list": [
+                        "([2, 4, 6, 8, 10], 7)",
+                        "([7, 7, 7, 7, 7], 16)",
+                        "([1], 0)",
+                        "([1, 2], 0)",
+                        "([1, 2, 3], 1)",
+                        "([1, 2, 4], 0)",
+                        "([0, 0, 0], 1)",
+                        "([1, 1, 2, 3], 2)",
+                        "([1, 3, 5, 7], 3)",
+                        "([2, 2, 3, 4], 2)",
+                        "([1, 2, 1, 2, 4, 1, 5, 10], 1)",
+                        "([5, 4, 3, 2, 1], 7)",
+                        "([1, -1, 1, -1, 1], 1)",
+                        "([0, 2000000000, -294967296], 0)",
+                        "([1, 2, 3, 4, 5, 6, 7], 20)",
+                        "([7, 7, 7, 7], 5)",
+                        "([3, -1, -5, -9], 3)"
+                    ]
+                },
+                "body": "        result = run_number_of_arithmetic_slices(Solution, nums)\n        assert_number_of_arithmetic_slices(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_number_of_arithmetic_slices, assert_number_of_arithmetic_slices\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [2, 4, 6, 8, 10]\nexpected = 7",
+    "playground_run": "result = run_number_of_arithmetic_slices(Solution, nums)\nresult",
+    "playground_assert": "assert_number_of_arithmetic_slices(result, expected)"
+}

leetcode_py_sdk-1.0.6/src/leetcode_py/cli/resources/leetcode/json/problems/arranging_coins.json

@@ -0,0 +1,94 @@
+{
+    "problem_name": "arranging_coins",
+    "solution_class_name": "Solution",
+    "problem_number": "441",
+    "problem_title": "Arranging Coins",
+    "difficulty": "Easy",
+    "topics": "Math, Binary Search",
+    "_tags": {
+        "list": ["neetcode"]
+    },
+    "readme_description": "You have `n` coins and you want to build a staircase with these coins. The staircase consists of `k` rows where the `i^th` row has exactly `i` coins. The last row of the staircase **may be** incomplete.\n\nGiven the integer `n`, return *the number of **complete rows** of the staircase you will build*.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2021/04/09/arrangecoins1-grid.jpg)\n\n```\nInput: n = 5\nOutput: 2\nExplanation: Because the 3rd row is incomplete, we return 2.\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2021/04/09/arrangecoins2-grid.jpg)\n\n```\nInput: n = 8\nOutput: 3\nExplanation: Because the 4th row is incomplete, we return 3.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- `1 <= n <= 2^31 - 1`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "arrange_coins",
+    "helpers_run_signature": "(solution_class: type, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.arrange_coins(n)",
+    "helpers_assert_name": "arrange_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_arrange_coins, run_arrange_coins\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ArrangingCoins",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "arrange_coins",
+                "signature": "(self, n: int) -> int",
+                "body": "        # TODO: Implement arrange_coins\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_arrange_coins",
+                "signature": "(self, n: int, expected: int)",
+                "parametrize": "n, expected",
+                "test_cases": {
+                    "list": [
+                        "(5, 2)",
+                        "(8, 3)",
+                        "(1, 1)",
+                        "(2, 1)",
+                        "(3, 2)",
+                        "(4, 2)",
+                        "(6, 3)",
+                        "(7, 3)",
+                        "(9, 3)",
+                        "(10, 4)",
+                        "(15, 5)",
+                        "(20, 5)",
+                        "(21, 6)",
+                        "(22, 6)",
+                        "(54, 9)",
+                        "(55, 10)",
+                        "(100, 13)",
+                        "(1804289384, 60070)",
+                        "(2147483647, 65535)"
+                    ]
+                },
+                "body": "        result = run_arrange_coins(Solution, n)\n        assert_arrange_coins(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_arrange_coins, assert_arrange_coins\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nn = 5\nexpected = 2",
+    "playground_run": "result = run_arrange_coins(Solution, n)\nresult",
+    "playground_assert": "assert_arrange_coins(result, expected)"
+}