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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.43.7" # use git tag instead
+version = "0.44.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.44.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.44.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.44.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)"
+}

leetcode_py_sdk-0.44.0/src/leetcode_py/cli/resources/leetcode/json/problems/powx_n.json

@@ -0,0 +1,82 @@
+{
+    "problem_name": "powx_n",
+    "solution_class_name": "Solution",
+    "problem_number": "50",
+    "problem_title": "Pow(x, n)",
+    "difficulty": "Medium",
+    "topics": "Math, Recursion",
+    "_tags": { "list": ["neetcode-150"] },
+    "readme_description": "Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., x<sup>n</sup>).",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: x = 2.00000, n = 10\nOutput: 1024.00000\n```" },
+            { "content": "```\nInput: x = 2.10000, n = 3\nOutput: 9.26100\n```" },
+            {
+                "content": "```\nInput: x = 2.00000, n = -2\nOutput: 0.25000\nExplanation: 2^-2 = 1/2^2 = 1/4 = 0.25\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- -100.0 < x < 100.0\n- -2^31 <= n <= 2^31 - 1\n- `n` is an integer.\n- Either `x` is not zero or `n > 0`.\n- -10^4 <= x^n <= 10^4",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "my_pow",
+    "helpers_run_signature": "(solution_class: type, x: float, n: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.my_pow(x, n)",
+    "helpers_assert_name": "my_pow",
+    "helpers_assert_signature": "(result: float, expected: float) -> bool",
+    "helpers_assert_body": "    assert abs(result - expected) < 1e-5, f'Expected {expected}, got {result}'\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_my_pow, run_my_pow\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "PowXN",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "my_pow",
+                "signature": "(self, x: float, n: int) -> float",
+                "body": "        # TODO: Implement my_pow\n        return 0.0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_my_pow",
+                "signature": "(self, x: float, n: int, expected: float)",
+                "parametrize": "x, n, expected",
+                "test_cases": {
+                    "list": [
+                        "(2.0, 10, 1024.0)",
+                        "(2.1, 3, 9.261)",
+                        "(2.0, -2, 0.25)",
+                        "(1.0, 0, 1.0)",
+                        "(0.5, 2, 0.25)",
+                        "(2.0, 1, 2.0)",
+                        "(3.0, 3, 27.0)",
+                        "(1.0, 100, 1.0)",
+                        "(0.0, 1, 0.0)",
+                        "(2.0, -1, 0.5)",
+                        "(10.0, 0, 1.0)",
+                        "(1.5, 2, 2.25)",
+                        "(0.5, -2, 4.0)",
+                        "(2.0, -3, 0.125)",
+                        "(1.0, -1, 1.0)",
+                        "(0.1, 3, 0.001)"
+                    ]
+                },
+                "body": "        result = run_my_pow(Solution, x, n)\n        assert_my_pow(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_my_pow, assert_my_pow\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nx = 2.0\nn = 10\nexpected = 1024.0",
+    "playground_run": "result = run_my_pow(Solution, x, n)\nresult",
+    "playground_assert": "assert_my_pow(result, expected)"
+}

leetcode_py_sdk-0.44.0/src/leetcode_py/cli/resources/leetcode/json/problems/regular_expression_matching.json

@@ -0,0 +1,87 @@
+{
+    "problem_name": "regular_expression_matching",
+    "solution_class_name": "Solution",
+    "problem_number": "10",
+    "problem_title": "Regular Expression Matching",
+    "difficulty": "Hard",
+    "topics": "String, Dynamic Programming, Recursion",
+    "_tags": { "list": ["neetcode-150"] },
+    "readme_description": "Given an input string `s` and a pattern `p`, implement regular expression matching with support for `'.'` and `'*'` where:\n\n- `'.'` Matches any single character.\n- `'*'` Matches zero or more of the preceding element.\n\nReturn a boolean indicating whether the matching covers the entire input string (not partial).",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"aa\", p = \"a\"\nOutput: false\nExplanation: \"a\" does not match the entire string \"aa\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \"aa\", p = \"a*\"\nOutput: true\nExplanation: '*' means zero or more of the preceding element, 'a'. Therefore, by repeating 'a' once, it becomes \"aa\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \"ab\", p = \".*\"\nOutput: true\nExplanation: \".*\" means \"zero or more (*) of any character (.)\".\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= s.length <= 20\n- 1 <= p.length <= 20\n- `s` contains only lowercase English letters.\n- `p` contains only lowercase English letters, `'.'`, and `'*'`.\n- It is guaranteed for each appearance of the character `'*'`, there will be a previous valid character to match.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "is_match",
+    "helpers_run_signature": "(solution_class: type, s: str, p: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.is_match(s, p)",
+    "helpers_assert_name": "is_match",
+    "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_match, run_is_match\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "RegularExpressionMatching",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "is_match",
+                "signature": "(self, s: str, p: str) -> bool",
+                "body": "        # TODO: Implement is_match\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_is_match",
+                "signature": "(self, s: str, p: str, expected: bool)",
+                "parametrize": "s, p, expected",
+                "test_cases": {
+                    "list": [
+                        "('aa', 'a', False)",
+                        "('aa', 'a*', True)",
+                        "('ab', '.*', True)",
+                        "('aab', 'c*a*b', True)",
+                        "('mississippi', 'mis*is*p*.', False)",
+                        "('a', 'ab*', True)",
+                        "('', 'a*', True)",
+                        "('', '.*', True)",
+                        "('ab', '.*c', False)",
+                        "('aaa', 'a*a', True)",
+                        "('aaa', 'aaaa', False)",
+                        "('abc', 'a.c', True)",
+                        "('abc', 'a.*c', True)",
+                        "('a', '.', True)",
+                        "('abcdef', '.*', True)",
+                        "('abbbbc', 'ab*c', True)",
+                        "('abbbbc', 'ab*bc', True)"
+                    ]
+                },
+                "body": "        result = run_is_match(Solution, s, p)\n        assert_is_match(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_is_match, assert_is_match\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = 'aa'\np = 'a*'\nexpected = True",
+    "playground_run": "result = run_is_match(Solution, s, p)\nresult",
+    "playground_assert": "assert_is_match(result, expected)"
+}

{leetcode_py_sdk-0.43.7 → leetcode_py_sdk-0.44.0}/src/leetcode_py/cli/resources/leetcode/json/problems/two_sum.json

@@ -31,7 +31,7 @@
     "helpers_run_body": "    implementation = solution_class()\n    return implementation.two_sum(nums, target)",
     "helpers_assert_name": "two_sum",
     "helpers_assert_signature": "(result: list[int], expected: list[int]) -> bool",
-    "helpers_assert_body": "    assert result == expected\n    return True",
+    "helpers_assert_body": "    assert sorted(result) == sorted(expected)\n    return True",
     "solution_imports": "",
     "solution_contents": "",
     "solution_class_content": "",

{leetcode_py_sdk-0.43.7 → leetcode_py_sdk-0.44.0}/src/leetcode_py/cli/resources/leetcode/json/tags.json5

@@ -204,6 +204,7 @@
         "clone_graph",
         "coin_change",
         "combination_sum",
+        "combination_sum_ii",
         "construct_binary_tree_from_preorder_and_inorder_traversal",
         "container_with_most_water",
         "contains_duplicate",
@@ -220,6 +221,7 @@
         "find_minimum_in_rotated_sorted_array",
         "find_the_duplicate_number",
         "gas_station",
+        "generate_parentheses",
         "graph_valid_tree",
         "group_anagrams",
         "house_robber",
@@ -256,6 +258,7 @@
         "min_stack",
         "minimum_window_substring",
         "missing_number",
+        "multiply_strings",
         "non_overlapping_intervals",
         "number_of_1_bits",
         "number_of_connected_components_in_an_undirected_graph",
@@ -266,7 +269,9 @@
         "partition_equal_subset_sum",
         "permutation_in_string",
         "permutations",
+        "powx_n",
         "product_of_array_except_self",
+        "regular_expression_matching",
         "remove_nth_node_from_end_of_list",
         "reorder_list",
         "reverse_bits",

{leetcode_py_sdk-0.43.7 → leetcode_py_sdk-0.44.0}/src/leetcode_py/tools/generator.py

@@ -72,6 +72,8 @@ def batch_format_and_check(directories: list[Path]) -> None:
                 "**/solution.py:ARG002",
                 "--per-file-ignores",
                 "**/playground.ipynb:B018",
+                "--per-file-ignores",
+                "**/playground.py:B018",
                 "--fix",
                 "--exit-non-zero-on-fix",
                 "--line-length",
@@ -117,7 +119,7 @@ def merge_tags(data: dict) -> dict:
     existing_tags = data.get("_tags", {}).get("list", [])
 
     # Merge and deduplicate tags
-    all_tags = list(set(system_tags + existing_tags))
+    all_tags = sorted(set(system_tags + existing_tags))
 
     # Update data with merged tags
     if all_tags: