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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: leetcode-py-sdk
-Version: 0.43.7
+Version: 0.45.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

{leetcode_py_sdk-0.43.7 → leetcode_py_sdk-0.45.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.43.7" # use git tag instead
+version = "0.45.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.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/combination_sum_ii.json

@@ -0,0 +1,79 @@
+{
+    "problem_name": "combination_sum_ii",
+    "solution_class_name": "Solution",
+    "problem_number": "40",
+    "problem_title": "Combination Sum II",
+    "difficulty": "Medium",
+    "topics": "Array, Backtracking",
+    "_tags": { "list": ["neetcode-150"] },
+    "readme_description": "Given a collection of candidate numbers (`candidates`) and a target number (`target`), find all unique combinations in `candidates` where the candidate numbers sum to `target`.\n\nEach number in `candidates` may only be used **once** in the combination.\n\n**Note:** The solution set must not contain duplicate combinations.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: candidates = [10,1,2,7,6,1,5], target = 8\nOutput: [[1,1,6],[1,2,5],[1,7],[2,6]]\n```"
+            },
+            { "content": "```\nInput: candidates = [2,5,2,1,2], target = 5\nOutput: [[1,2,2],[5]]\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= candidates.length <= 100\n- 1 <= candidates[i] <= 50\n- 1 <= target <= 30",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "combination_sum2",
+    "helpers_run_signature": "(solution_class: type, candidates: list[int], target: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    result = implementation.combination_sum2(candidates, target)\n    return sorted([sorted(combo) for combo in result])",
+    "helpers_assert_name": "combination_sum2",
+    "helpers_assert_signature": "(result: list[list[int]], expected: list[list[int]]) -> bool",
+    "helpers_assert_body": "    expected_sorted = sorted([sorted(combo) for combo in expected])\n    assert result == expected_sorted\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_combination_sum2, run_combination_sum2\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "CombinationSumII",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "combination_sum2",
+                "signature": "(self, candidates: list[int], target: int) -> list[list[int]]",
+                "body": "        # TODO: Implement combination_sum2\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_combination_sum2",
+                "signature": "(self, candidates: list[int], target: int, expected: list[list[int]])",
+                "parametrize": "candidates, target, expected",
+                "test_cases": {
+                    "list": [
+                        "([10, 1, 2, 7, 6, 1, 5], 8, [[1, 1, 6], [1, 2, 5], [1, 7], [2, 6]])",
+                        "([2, 5, 2, 1, 2], 5, [[1, 2, 2], [5]])",
+                        "([1], 1, [[1]])",
+                        "([1], 2, [])",
+                        "([2], 1, [])",
+                        "([1, 1], 2, [[1, 1]])",
+                        "([1, 1, 1], 2, [[1, 1]])",
+                        "([1, 1, 1, 1, 1], 3, [[1, 1, 1]])",
+                        "([1, 2], 4, [])",
+                        "([1, 2, 3], 3, [[1, 2], [3]])",
+                        "([5, 3, 2, 1], 6, [[1, 2, 3], [1, 5]])",
+                        "([1, 2, 2, 2, 5], 5, [[1, 2, 2], [5]])",
+                        "([2, 2, 2], 4, [[2, 2]])",
+                        "([1, 1, 2, 2], 4, [[1, 1, 2], [2, 2]])"
+                    ]
+                },
+                "body": "        result = run_combination_sum2(Solution, candidates, target)\n        assert_combination_sum2(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_combination_sum2, assert_combination_sum2\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ncandidates = [10, 1, 2, 7, 6, 1, 5]\ntarget = 8\nexpected = [[1, 1, 6], [1, 2, 5], [1, 7], [2, 6]]",
+    "playground_run": "result = run_combination_sum2(Solution, candidates, target)\nresult",
+    "playground_assert": "assert_combination_sum2(result, expected)"
+}

leetcode_py_sdk-0.45.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.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/distinct_subsequences.json

@@ -0,0 +1,90 @@
+{
+    "problem_name": "distinct_subsequences",
+    "solution_class_name": "Solution",
+    "problem_number": "115",
+    "problem_title": "Distinct Subsequences",
+    "difficulty": "Hard",
+    "topics": "String, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "Given two strings `s` and `t`, return *the number of distinct subsequences of* `s` *which equals* `t`.\n\nThe test cases are generated so that the answer fits on a **32-bit** signed integer.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"rabbbit\", t = \"rabbit\"\nOutput: 3\nExplanation:\nAs shown below, there are 3 ways you can generate \"rabbit\" from s.\nrabbbit\nrabbbit\nrabbbit\n```"
+            },
+            {
+                "content": "```\nInput: s = \"babgbag\", t = \"bag\"\nOutput: 5\nExplanation:\nAs shown below, there are 5 ways you can generate \"bag\" from s.\nbabgbag\nbabgbag\nbabgbag\nbabgbag\nbabgbag\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= s.length, t.length <= 1000\n- s and t consist of English letters.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "num_distinct",
+    "helpers_run_signature": "(solution_class: type, s: str, t: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.num_distinct(s, t)",
+    "helpers_assert_name": "num_distinct",
+    "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_num_distinct, run_num_distinct\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "DistinctSubsequences",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "num_distinct",
+                "signature": "(self, s: str, t: str) -> int",
+                "body": "        # TODO: Implement num_distinct\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_num_distinct",
+                "signature": "(self, s: str, t: str, expected: int)",
+                "parametrize": "s, t, expected",
+                "test_cases": {
+                    "list": [
+                        "('rabbbit', 'rabbit', 3)",
+                        "('babgbag', 'bag', 5)",
+                        "('a', 'a', 1)",
+                        "('a', 'b', 0)",
+                        "('aaa', 'a', 3)",
+                        "('aaa', 'aa', 3)",
+                        "('aaaa', 'aa', 6)",
+                        "('abc', 'abc', 1)",
+                        "('abc', 'abcd', 0)",
+                        "('abab', 'ab', 3)",
+                        "('abab', 'bab', 1)",
+                        "('abcabc', 'abc', 4)",
+                        "('dddd', 'dd', 6)",
+                        "('aab', 'ab', 2)",
+                        "('bbb', 'bb', 3)"
+                    ]
+                },
+                "body": "        result = run_num_distinct(Solution, s, t)\n        assert_num_distinct(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_num_distinct, assert_num_distinct\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = 'rabbbit'\nt = 'rabbit'\nexpected = 3",
+    "playground_run": "result = run_num_distinct(Solution, s, t)\nresult",
+    "playground_assert": "assert_num_distinct(result, expected)"
+}

leetcode_py_sdk-0.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/edit_distance.json

@@ -0,0 +1,89 @@
+{
+    "problem_name": "edit_distance",
+    "solution_class_name": "Solution",
+    "problem_number": "72",
+    "problem_title": "Edit Distance",
+    "difficulty": "Hard",
+    "topics": "String, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "Given two strings `word1` and `word2`, return *the minimum number of operations required to convert* `word1` *to* `word2`.\n\nYou have the following three operations permitted on a word:\n\n- Insert a character\n- Delete a character\n- Replace a character",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: word1 = \"horse\", word2 = \"ros\"\nOutput: 3\nExplanation:\nhorse -> rorse (replace 'h' with 'r')\nrorse -> rose (remove 'r')\nrose -> ros (remove 'e')\n```"
+            },
+            {
+                "content": "```\nInput: word1 = \"intention\", word2 = \"execution\"\nOutput: 5\nExplanation:\nintention -> inention (remove 't')\ninention -> enention (replace 'i' with 'e')\nenention -> exention (replace 'n' with 'x')\nexention -> exection (replace 'n' with 'c')\nexection -> execution (insert 'u')\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 0 <= word1.length, word2.length <= 500\n- word1 and word2 consist of lowercase English letters.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "min_distance",
+    "helpers_run_signature": "(solution_class: type, word1: str, word2: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.min_distance(word1, word2)",
+    "helpers_assert_name": "min_distance",
+    "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_min_distance, run_min_distance\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "EditDistance",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "min_distance",
+                "signature": "(self, word1: str, word2: str) -> int",
+                "body": "        # TODO: Implement min_distance\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_min_distance",
+                "signature": "(self, word1: str, word2: str, expected: int)",
+                "parametrize": "word1, word2, expected",
+                "test_cases": {
+                    "list": [
+                        "('horse', 'ros', 3)",
+                        "('intention', 'execution', 5)",
+                        "('', '', 0)",
+                        "('', 'a', 1)",
+                        "('a', '', 1)",
+                        "('a', 'a', 0)",
+                        "('ab', 'a', 1)",
+                        "('a', 'ab', 1)",
+                        "('ab', 'ba', 2)",
+                        "('abc', 'abc', 0)",
+                        "('abc', 'abd', 1)",
+                        "('kitten', 'sitting', 3)",
+                        "('saturday', 'sunday', 3)",
+                        "('', 'abc', 3)"
+                    ]
+                },
+                "body": "        result = run_min_distance(Solution, word1, word2)\n        assert_min_distance(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_min_distance, assert_min_distance\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nword1 = 'horse'\nword2 = 'ros'\nexpected = 3",
+    "playground_run": "result = run_min_distance(Solution, word1, word2)\nresult",
+    "playground_assert": "assert_min_distance(result, expected)"
+}

leetcode_py_sdk-0.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/generate_parentheses.json

@@ -0,0 +1,76 @@
+{
+    "problem_name": "generate_parentheses",
+    "solution_class_name": "Solution",
+    "problem_number": "22",
+    "problem_title": "Generate Parentheses",
+    "difficulty": "Medium",
+    "topics": "String, Dynamic Programming, Backtracking",
+    "_tags": { "list": ["neetcode-150"] },
+    "readme_description": "Given `n` pairs of parentheses, write a function to generate all combinations of well-formed parentheses.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: n = 3\nOutput: [\"((()))\",\"(()())\",\"(())()\",\"()(())\",\"()()()\"]\n```"
+            },
+            { "content": "```\nInput: n = 1\nOutput: [\"()\"]\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= n <= 8",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "generate_parenthesis",
+    "helpers_run_signature": "(solution_class: type, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return sorted(implementation.generate_parenthesis(n))",
+    "helpers_assert_name": "generate_parenthesis",
+    "helpers_assert_signature": "(result: list[str], expected: list[str]) -> bool",
+    "helpers_assert_body": "    assert sorted(result) == sorted(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_generate_parenthesis, run_generate_parenthesis\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "GenerateParentheses",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "generate_parenthesis",
+                "signature": "(self, n: int) -> list[str]",
+                "body": "        # TODO: Implement generate_parenthesis\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_generate_parenthesis",
+                "signature": "(self, n: int, expected: list[str])",
+                "parametrize": "n, expected",
+                "test_cases": {
+                    "list": [
+                        "(1, ['()'])",
+                        "(2, ['(())', '()()'])",
+                        "(3, ['((()))', '(()())', '(())()', '()(())', '()()()'])",
+                        "(4, ['(((())))', '((()()))', '((())())', '((()))()', '(()(()))', '(()()())', '(()())()', '(())(())', '(())()()', '()((()))', '()(()())', '()(())()', '()()(())', '()()()()'])",
+                        "(0, [''])",
+                        "(5, ['((((()))))', '(((()())))', '(((())()))', '(((()))())', '(((())))()', '((()(())))', '((()()()))', '((()())())', '((()()))()', '((())(()))', '((())()())', '((())())()', '((()))(())', '((()))()()', '(()((())))', '(()(()()))', '(()(())())', '(()(()))()', '(()()(()))', '(()()()())', '(()()())()', '(()())(())', '(()())()()', '(())((()))', '(())(()())', '(())(())()', '(())()(())', '(())()()()', '()(((())))', '()((()()))', '()((())())', '()((()))()', '()(()(()))', '()(()()())', '()(()())()', '()(())(())', '()(())()()', '()()((()))', '()()(()())', '()()(())()', '()()()(())', '()()()()()'])",
+                        "pytest.param(1, ['()'], id='dup1')",
+                        "pytest.param(2, ['(())', '()()'], id='dup2')",
+                        "pytest.param(3, ['((()))', '(()())', '(())()', '()(())', '()()()'], id='dup3a')",
+                        "pytest.param(3, ['((()))', '(()())', '(())()', '()(())', '()()()'], id='dup3b')",
+                        "pytest.param(3, ['((()))', '(()())', '(())()', '()(())', '()()()'], id='dup3c')"
+                    ]
+                },
+                "body": "        result = run_generate_parenthesis(Solution, n)\n        assert_generate_parenthesis(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_generate_parenthesis, assert_generate_parenthesis\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nn = 3\nexpected = ['((()))', '(()())', '(())()', '()(())', '()()()']",
+    "playground_run": "result = run_generate_parenthesis(Solution, n)\nresult",
+    "playground_assert": "assert_generate_parenthesis(result, expected)"
+}

leetcode_py_sdk-0.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/interleaving_string.json

@@ -0,0 +1,96 @@
+{
+    "problem_name": "interleaving_string",
+    "solution_class_name": "Solution",
+    "problem_number": "97",
+    "problem_title": "Interleaving String",
+    "difficulty": "Medium",
+    "topics": "String, Dynamic Programming",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "Given strings `s1`, `s2`, and `s3`, find whether `s3` is formed by an **interleaving** of `s1` and `s2`.\n\nAn interleaving of two strings `s` and `t` is a configuration where `s` and `t` are divided into `n` and `m` substrings respectively, such that:\n\n- s = s1 + s2 + ... + sn\n- t = t1 + t2 + ... + tm\n- |n - m| <= 1\n- The interleaving is s1 + t1 + s2 + t2 + s3 + t3 + ... or t1 + s1 + t2 + s2 + t3 + s3 + ...\n\n**Note:** `a + b` is the concatenation of strings `a` and `b`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2020/09/02/interleave.jpg)\n\n```\nInput: s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbcbcac\"\nOutput: true\nExplanation: One way to obtain s3 is:\nSplit s1 into s1 = \"aa\" + \"bc\" + \"c\", and s2 into s2 = \"dbbc\" + \"a\".\nInterleaving the two splits, we get \"aadbbcbcac\".\n```"
+            },
+            {
+                "content": "```\nInput: s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbbaccc\"\nOutput: false\nExplanation: Notice how it is hard to find a viable interleaving because s3 must preserve the character order of s1 and s2.\n```"
+            },
+            {
+                "content": "```\nInput: s1 = \"\", s2 = \"\", s3 = \"\"\nOutput: true\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 0 <= s1.length, s2.length <= 100\n- 0 <= s3.length <= 200\n- s1, s2, and s3 consist of lowercase English letters.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "is_interleave",
+    "helpers_run_signature": "(solution_class: type, s1: str, s2: str, s3: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.is_interleave(s1, s2, s3)",
+    "helpers_assert_name": "is_interleave",
+    "helpers_assert_signature": "(result: bool, expected: bool) -> 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_is_interleave, run_is_interleave\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "InterleavingString",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "is_interleave",
+                "signature": "(self, s1: str, s2: str, s3: str) -> bool",
+                "body": "        # TODO: Implement is_interleave\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_is_interleave",
+                "signature": "(self, s1: str, s2: str, s3: str, expected: bool)",
+                "parametrize": "s1, s2, s3, expected",
+                "test_cases": {
+                    "list": [
+                        "('aabcc', 'dbbca', 'aadbbcbcac', True)",
+                        "('aabcc', 'dbbca', 'aadbbbaccc', False)",
+                        "('', '', '', True)",
+                        "('', '', 'a', False)",
+                        "('a', '', 'a', True)",
+                        "('', 'b', 'b', True)",
+                        "('a', 'b', 'ab', True)",
+                        "('a', 'b', 'ba', True)",
+                        "('a', 'b', 'a', False)",
+                        "('ab', 'cd', 'acbd', True)",
+                        "('ab', 'cd', 'abcd', True)",
+                        "('ab', 'cd', 'cdab', True)",
+                        "('ab', 'cd', 'acdb', True)",
+                        "('aa', 'ab', 'aaab', True)",
+                        "('aa', 'ab', 'aaba', True)",
+                        "('abc', 'def', 'abcdef', True)",
+                        "('abc', 'def', 'adbecf', True)",
+                        "('abc', 'def', 'defabc', True)"
+                    ]
+                },
+                "body": "        result = run_is_interleave(Solution, s1, s2, s3)\n        assert_is_interleave(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_is_interleave, assert_is_interleave\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns1 = 'aabcc'\ns2 = 'dbbca'\ns3 = 'aadbbcbcac'\nexpected = True",
+    "playground_run": "result = run_is_interleave(Solution, s1, s2, s3)\nresult",
+    "playground_assert": "assert_is_interleave(result, expected)"
+}

leetcode_py_sdk-0.45.0/src/leetcode_py/cli/resources/leetcode/json/problems/multiply_strings.json

@@ -0,0 +1,79 @@
+{
+    "problem_name": "multiply_strings",
+    "solution_class_name": "Solution",
+    "problem_number": "43",
+    "problem_title": "Multiply Strings",
+    "difficulty": "Medium",
+    "topics": "Math, String, Simulation",
+    "_tags": { "list": ["neetcode-150"] },
+    "readme_description": "Given two non-negative integers `num1` and `num2` represented as strings, return the product of `num1` and `num2`, also represented as a string.\n\n**Note:** You must not use any built-in BigInteger library or convert the inputs to integer directly.",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: num1 = \"2\", num2 = \"3\"\nOutput: \"6\"\n```" },
+            { "content": "```\nInput: num1 = \"123\", num2 = \"456\"\nOutput: \"56088\"\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= num1.length, num2.length <= 200\n- `num1` and `num2` consist of digits only.\n- Both `num1` and `num2` do not contain any leading zero, except the number `0` itself.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "multiply",
+    "helpers_run_signature": "(solution_class: type, num1: str, num2: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.multiply(num1, num2)",
+    "helpers_assert_name": "multiply",
+    "helpers_assert_signature": "(result: str, expected: str) -> 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_multiply, run_multiply\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "MultiplyStrings",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "multiply",
+                "signature": "(self, num1: str, num2: str) -> str",
+                "body": "        # TODO: Implement multiply\n        return ''"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_multiply",
+                "signature": "(self, num1: str, num2: str, expected: str)",
+                "parametrize": "num1, num2, expected",
+                "test_cases": {
+                    "list": [
+                        "('2', '3', '6')",
+                        "('123', '456', '56088')",
+                        "('0', '0', '0')",
+                        "('0', '123', '0')",
+                        "('123', '0', '0')",
+                        "('1', '1', '1')",
+                        "('9', '9', '81')",
+                        "('99', '99', '9801')",
+                        "('999', '999', '998001')",
+                        "('123456789', '987654321', '121932631112635269')",
+                        "('2', '50', '100')",
+                        "('10', '10', '100')",
+                        "('100', '100', '10000')",
+                        "('5', '5', '25')",
+                        "('123', '1', '123')",
+                        "('1', '999', '999')"
+                    ]
+                },
+                "body": "        result = run_multiply(Solution, num1, num2)\n        assert_multiply(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_multiply, assert_multiply\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnum1 = '123'\nnum2 = '456'\nexpected = '56088'",
+    "playground_run": "result = run_multiply(Solution, num1, num2)\nresult",
+    "playground_assert": "assert_multiply(result, expected)"
+}