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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.44.0" # 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/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/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/n_queens.json

@@ -0,0 +1,90 @@
+{
+    "problem_name": "n_queens",
+    "solution_class_name": "Solution",
+    "problem_number": "51",
+    "problem_title": "N-Queens",
+    "difficulty": "Hard",
+    "topics": "Array, Backtracking",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.\n\nGiven an integer `n`, return *all distinct solutions to the **n-queens puzzle***. You may return the answer in **any order**.\n\nEach solution contains a distinct board configuration of the n-queens' placement, where `'Q'` and `'.'` both indicate a queen and an empty space, respectively.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)\n\n```\nInput: n = 4\nOutput: [[\".Q..\",\"...Q\",\"Q...\",\"..Q.\"],[\"..Q.\",\"Q...\",\"...Q\",\".Q..\"]]\nExplanation: There exist two distinct solutions to the 4-queens puzzle as shown above\n```"
+            },
+            {
+                "content": "```\nInput: n = 1\nOutput: [[\"Q\"]]\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= n <= 9",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "def assert_solve_n_queens_solution_count(result: list[list[str]], expected: int) -> bool:\n    assert len(result) == expected\n    return True",
+    "helpers_run_name": "solve_n_queens",
+    "helpers_run_signature": "(solution_class: type, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.solve_n_queens(n)",
+    "helpers_assert_name": "solve_n_queens",
+    "helpers_assert_signature": "(result: list[list[str]], expected: list[list[str]]) -> bool",
+    "helpers_assert_body": "    # Sort both result and expected for order-independent comparison\n    result_sorted = sorted(result)\n    expected_sorted = sorted(expected)\n    assert result_sorted == 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_solve_n_queens, assert_solve_n_queens_solution_count, run_solve_n_queens\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "NQueens",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "solve_n_queens",
+                "signature": "(self, n: int) -> list[list[str]]",
+                "body": "        # TODO: Implement solve_n_queens\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_solve_n_queens",
+                "signature": "(self, n: int, expected: list[list[str]])",
+                "parametrize": "n, expected",
+                "test_cases": {
+                    "list": [
+                        "(1, [['Q']])",
+                        "(2, [])",
+                        "(3, [])",
+                        "(4, [['..Q.', 'Q...', '...Q', '.Q..'], ['.Q..', '...Q', 'Q...', '..Q.']])",
+                        "(5, [['....Q', '..Q..', 'Q....', '...Q.', '.Q...'], ['....Q', '.Q...', '...Q.', 'Q....', '..Q..'], ['...Q.', '.Q...', '....Q', '..Q..', 'Q....'], ['...Q.', 'Q....', '..Q..', '....Q', '.Q...'], ['..Q..', '....Q', '.Q...', '...Q.', 'Q....'], ['..Q..', 'Q....', '...Q.', '.Q...', '....Q'], ['.Q...', '....Q', '..Q..', 'Q....', '...Q.'], ['.Q...', '...Q.', 'Q....', '..Q..', '....Q'], ['Q....', '...Q.', '.Q...', '....Q', '..Q..'], ['Q....', '..Q..', '....Q', '.Q...', '...Q.']])",
+                        "(6, [['....Q.', '..Q...', 'Q.....', '.....Q', '...Q..', '.Q....'], ['...Q..', 'Q.....', '....Q.', '.Q....', '.....Q', '..Q...'], ['..Q...', '.....Q', '.Q....', '....Q.', 'Q.....', '...Q..'], ['.Q....', '...Q..', '.....Q', 'Q.....', '..Q...', '....Q.']])"
+                    ]
+                },
+                "body": "        result = run_solve_n_queens(Solution, n)\n        assert_solve_n_queens(result, expected)"
+            },
+            {
+                "name": "test_solve_n_queens_solution_count",
+                "signature": "(self, n: int, expected_count: int)",
+                "parametrize": "n, expected_count",
+                "test_cases": {
+                    "list": ["(4, 2)", "(5, 10)", "(6, 4)", "(7, 40)", "(8, 92)", "(9, 352)"]
+                },
+                "body": "        result = run_solve_n_queens(Solution, n)\n        assert_solve_n_queens_solution_count(result, expected_count)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_solve_n_queens, assert_solve_n_queens\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nn = 4\nexpected = [['..Q.', 'Q...', '...Q', '.Q..'], ['.Q..', '...Q', 'Q...', '..Q.']]",
+    "playground_run": "result = run_solve_n_queens(Solution, n)\nresult",
+    "playground_assert": "assert_solve_n_queens(result, expected)"
+}

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

@@ -0,0 +1,92 @@
+{
+    "problem_name": "plus_one",
+    "solution_class_name": "Solution",
+    "problem_number": "66",
+    "problem_title": "Plus One",
+    "difficulty": "Easy",
+    "topics": "Array, Math",
+    "_tags": {
+        "list": ["neetcode-150"]
+    },
+    "readme_description": "You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.\n\nIncrement the large integer by one and return *the resulting array of digits*.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: digits = [1,2,3]\nOutput: [1,2,4]\nExplanation: The array represents the integer 123.\nIncrementing by one gives 123 + 1 = 124.\nThus, the result should be [1,2,4].\n```"
+            },
+            {
+                "content": "```\nInput: digits = [4,3,2,1]\nOutput: [4,3,2,2]\nExplanation: The array represents the integer 4321.\nIncrementing by one gives 4321 + 1 = 4322.\nThus, the result should be [4,3,2,2].\n```"
+            },
+            {
+                "content": "```\nInput: digits = [9]\nOutput: [1,0]\nExplanation: The array represents the integer 9.\nIncrementing by one gives 9 + 1 = 10.\nThus, the result should be [1,0].\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= digits.length <= 100\n- 0 <= digits[i] <= 9\n- digits does not contain any leading 0's.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "plus_one",
+    "helpers_run_signature": "(solution_class: type, digits: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.plus_one(digits)",
+    "helpers_assert_name": "plus_one",
+    "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_plus_one, run_plus_one\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "PlusOne",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "plus_one",
+                "signature": "(self, digits: list[int]) -> list[int]",
+                "body": "        # TODO: Implement plus_one\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_plus_one",
+                "signature": "(self, digits: list[int], expected: list[int])",
+                "parametrize": "digits, expected",
+                "test_cases": {
+                    "list": [
+                        "([1, 2, 3], [1, 2, 4])",
+                        "([4, 3, 2, 1], [4, 3, 2, 2])",
+                        "([9], [1, 0])",
+                        "([0], [1])",
+                        "([1, 0, 0, 0], [1, 0, 0, 1])",
+                        "([9, 9], [1, 0, 0])",
+                        "([9, 9, 9], [1, 0, 0, 0])",
+                        "([8, 9, 9, 9], [9, 0, 0, 0])",
+                        "([2], [3])",
+                        "([1, 9], [2, 0])",
+                        "([7, 7, 7], [7, 7, 8])",
+                        "([5, 9, 9], [6, 0, 0])",
+                        "([1, 2, 9], [1, 3, 0])",
+                        "([6, 1, 4, 9], [6, 1, 5, 0])"
+                    ]
+                },
+                "body": "        result = run_plus_one(Solution, digits)\n        assert_plus_one(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_plus_one, assert_plus_one\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ndigits = [1, 2, 3]\nexpected = [1, 2, 4]",
+    "playground_run": "result = run_plus_one(Solution, digits)\nresult",
+    "playground_assert": "assert_plus_one(result, expected)"
+}