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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.46.0" # use git tag instead
+version = "0.47.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"}
@@ -46,7 +46,7 @@ Repository = "https://github.com/wislertt/leetcode-py"
 
 [dependency-groups]
 dev = [
-  "bakefile[lib]>=0.0.8",
+  "bakefile[lib]>=0.0.57a0",
   "deptry>=0.24.0",
   "ipykernel>=7.0.0",
   "jupytext>=1.16.6",

leetcode_py_sdk-0.47.0/src/leetcode_py/cli/resources/leetcode/json/problems/longest_common_prefix.json

@@ -0,0 +1,91 @@
+{
+    "problem_name": "longest_common_prefix",
+    "solution_class_name": "Solution",
+    "problem_number": "14",
+    "problem_title": "Longest Common Prefix",
+    "difficulty": "Easy",
+    "topics": "Array, String, Trie",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Write a function to find the longest common prefix string amongst an array of strings.\n\nIf there is no common prefix, return an empty string `\"\"`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: strs = [\"flower\",\"flow\",\"flight\"]\nOutput: \"fl\"\n```"
+            },
+            {
+                "content": "```\nInput: strs = [\"dog\",\"racecar\",\"car\"]\nOutput: \"\"\nExplanation: There is no common prefix among the input strings.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= strs.length <= 200\n- 0 <= strs[i].length <= 200\n- `strs[i]` consists of only lowercase English letters if it is non-empty.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "longest_common_prefix",
+    "helpers_run_signature": "(solution_class: type, strs: list[str])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.longest_common_prefix(strs)",
+    "helpers_assert_name": "longest_common_prefix",
+    "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_longest_common_prefix, run_longest_common_prefix\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "LongestCommonPrefix",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "longest_common_prefix",
+                "signature": "(self, strs: list[str]) -> str",
+                "body": "        # TODO: Implement longest_common_prefix\n        return ''"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_longest_common_prefix",
+                "signature": "(self, strs: list[str], expected: str)",
+                "parametrize": "strs, expected",
+                "test_cases": {
+                    "list": [
+                        "(['flower', 'flow', 'flight'], 'fl')",
+                        "(['dog', 'racecar', 'car'], '')",
+                        "([''], '')",
+                        "(['a'], 'a')",
+                        "(['ab', 'a'], 'a')",
+                        "(['aaa', 'aa', 'aaa'], 'aa')",
+                        "(['abc', 'abc', 'abc'], 'abc')",
+                        "(['abc', 'def', 'ghi'], '')",
+                        "(['interspecies', 'interstellar', 'interstate'], 'inters')",
+                        "(['', ''], '')",
+                        "(['ab', 'ab', 'ab'], 'ab')",
+                        "(['a', 'a', 'a'], 'a')",
+                        "(['prefix', 'pre', 'pref'], 'pre')",
+                        "(['xyz', 'xyz', 'x'], 'x')",
+                        "(['abca', 'abcab', 'abcabc'], 'abca')",
+                        "(['cir', 'car'], 'c')"
+                    ]
+                },
+                "body": "        result = run_longest_common_prefix(Solution, strs)\n        assert_longest_common_prefix(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_longest_common_prefix, assert_longest_common_prefix\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nstrs = ['flower', 'flow', 'flight']\nexpected = 'fl'",
+    "playground_run": "result = run_longest_common_prefix(Solution, strs)\nresult",
+    "playground_assert": "assert_longest_common_prefix(result, expected)"
+}

leetcode_py_sdk-0.47.0/src/leetcode_py/cli/resources/leetcode/json/problems/longest_valid_parentheses.json

@@ -0,0 +1,94 @@
+{
+    "problem_name": "longest_valid_parentheses",
+    "solution_class_name": "Solution",
+    "problem_number": "32",
+    "problem_title": "Longest Valid Parentheses",
+    "difficulty": "Hard",
+    "topics": "String, Dynamic Programming, Stack",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Given a string containing just the characters `'('` and `')'`, return the length of the longest valid (well-formed) parentheses *substring*.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"(()\"\nOutput: 2\nExplanation: The longest valid parentheses substring is \"()\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \")()())\"\nOutput: 4\nExplanation: The longest valid parentheses substring is \"()()\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \"\"\nOutput: 0\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 0 <= s.length <= 3 * 10^4\n- `s[i]` is `'('`, or `')'`.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "longest_valid_parentheses",
+    "helpers_run_signature": "(solution_class: type, s: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.longest_valid_parentheses(s)",
+    "helpers_assert_name": "longest_valid_parentheses",
+    "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_longest_valid_parentheses, run_longest_valid_parentheses\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "LongestValidParentheses",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "longest_valid_parentheses",
+                "signature": "(self, s: str) -> int",
+                "body": "        # TODO: Implement longest_valid_parentheses\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_longest_valid_parentheses",
+                "signature": "(self, s: str, expected: int)",
+                "parametrize": "s, expected",
+                "test_cases": {
+                    "list": [
+                        "('(()', 2)",
+                        "(')()())', 4)",
+                        "('', 0)",
+                        "('(', 0)",
+                        "(')', 0)",
+                        "('()', 2)",
+                        "('()()', 4)",
+                        "('(())', 4)",
+                        "('(()())', 6)",
+                        "('(()()', 4)",
+                        "(')(())', 4)",
+                        "('()(()', 2)",
+                        "('(((((', 0)",
+                        "(')))))', 0)",
+                        "('((()))', 6)",
+                        "('(())(())', 8)"
+                    ]
+                },
+                "body": "        result = run_longest_valid_parentheses(Solution, s)\n        assert_longest_valid_parentheses(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_longest_valid_parentheses, assert_longest_valid_parentheses\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = ')()())'\nexpected = 4",
+    "playground_run": "result = run_longest_valid_parentheses(Solution, s)\nresult",
+    "playground_assert": "assert_longest_valid_parentheses(result, expected)"
+}

leetcode_py_sdk-0.47.0/src/leetcode_py/cli/resources/leetcode/json/problems/palindrome_number.json

@@ -0,0 +1,94 @@
+{
+    "problem_name": "palindrome_number",
+    "solution_class_name": "Solution",
+    "problem_number": "9",
+    "problem_title": "Palindrome Number",
+    "difficulty": "Easy",
+    "topics": "Math",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Given an integer `x`, return `true` if `x` is a **palindrome**, and `false` otherwise.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: x = 121\nOutput: true\nExplanation: 121 reads as 121 from left to right and from right to left.\n```"
+            },
+            {
+                "content": "```\nInput: x = -121\nOutput: false\nExplanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.\n```"
+            },
+            {
+                "content": "```\nInput: x = 10\nOutput: false\nExplanation: Reads 01 from right to left. Therefore it is not a palindrome.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- -2^31 <= x <= 2^31 - 1",
+    "readme_additional": "**Follow up:** Could you solve it without converting the integer to a string?",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "is_palindrome",
+    "helpers_run_signature": "(solution_class: type, x: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.is_palindrome(x)",
+    "helpers_assert_name": "is_palindrome",
+    "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_palindrome, run_is_palindrome\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "PalindromeNumber",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "is_palindrome",
+                "signature": "(self, x: int) -> bool",
+                "body": "        # TODO: Implement is_palindrome\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_is_palindrome",
+                "signature": "(self, x: int, expected: bool)",
+                "parametrize": "x, expected",
+                "test_cases": {
+                    "list": [
+                        "(121, True)",
+                        "(-121, False)",
+                        "(10, False)",
+                        "(0, True)",
+                        "(1, True)",
+                        "(11, True)",
+                        "(12, False)",
+                        "(1001, True)",
+                        "(12321, True)",
+                        "(12345, False)",
+                        "(-1, False)",
+                        "(1000021, False)",
+                        "(1234321, True)",
+                        "(2147447412, True)",
+                        "(2147483647, False)",
+                        "(100, False)"
+                    ]
+                },
+                "body": "        result = run_is_palindrome(Solution, x)\n        assert_is_palindrome(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_is_palindrome, assert_is_palindrome\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nx = 121\nexpected = True",
+    "playground_run": "result = run_is_palindrome(Solution, x)\nresult",
+    "playground_assert": "assert_is_palindrome(result, expected)"
+}

leetcode_py_sdk-0.47.0/src/leetcode_py/cli/resources/leetcode/json/problems/roman_to_integer.json

@@ -0,0 +1,94 @@
+{
+    "problem_name": "roman_to_integer",
+    "solution_class_name": "Solution",
+    "problem_number": "13",
+    "problem_title": "Roman to Integer",
+    "difficulty": "Easy",
+    "topics": "Hash Table, Math, String",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.\n\n**Symbol**       **Value**\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000\n\nFor example, `2` is written as `II` in Roman numeral, just two ones added together. `12` is written as `XII`, which is simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.\n\nRoman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:\n\n- `I` can be placed before `V` (5) and `X` (10) to make 4 and 9.\n- `X` can be placed before `L` (50) and `C` (100) to make 40 and 90.\n- `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.\n\nGiven a roman numeral, convert it to an integer.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"III\"\nOutput: 3\nExplanation: III = 3.\n```"
+            },
+            {
+                "content": "```\nInput: s = \"LVIII\"\nOutput: 58\nExplanation: L = 50, V= 5, III = 3.\n```"
+            },
+            {
+                "content": "```\nInput: s = \"MCMXCIV\"\nOutput: 1994\nExplanation: M = 1000, CM = 900, XC = 90 and IV = 4.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= s.length <= 15\n- `s` contains only the characters (`'I'`, `'V'`, `'X'`, `'L'`, `'C'`, `'D'`, `'M'`).\n- It is guaranteed that `s` is a valid roman numeral in the range `[1, 3999]`.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "roman_to_int",
+    "helpers_run_signature": "(solution_class: type, s: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.roman_to_int(s)",
+    "helpers_assert_name": "roman_to_int",
+    "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_roman_to_int, run_roman_to_int\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "RomanToInteger",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "roman_to_int",
+                "signature": "(self, s: str) -> int",
+                "body": "        # TODO: Implement roman_to_int\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_roman_to_int",
+                "signature": "(self, s: str, expected: int)",
+                "parametrize": "s, expected",
+                "test_cases": {
+                    "list": [
+                        "('III', 3)",
+                        "('LVIII', 58)",
+                        "('MCMXCIV', 1994)",
+                        "('I', 1)",
+                        "('V', 5)",
+                        "('X', 10)",
+                        "('IV', 4)",
+                        "('IX', 9)",
+                        "('XL', 40)",
+                        "('XC', 90)",
+                        "('CD', 400)",
+                        "('CM', 900)",
+                        "('MMMCMXCIX', 3999)",
+                        "('MMMDCCCLXXXVIII', 3888)",
+                        "('DCXXI', 621)",
+                        "('MCMXC', 1990)"
+                    ]
+                },
+                "body": "        result = run_roman_to_int(Solution, s)\n        assert_roman_to_int(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_roman_to_int, assert_roman_to_int\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = 'MCMXCIV'\nexpected = 1994",
+    "playground_run": "result = run_roman_to_int(Solution, s)\nresult",
+    "playground_assert": "assert_roman_to_int(result, expected)"
+}

leetcode_py_sdk-0.47.0/src/leetcode_py/cli/resources/leetcode/json/problems/three_sum_closest.json

@@ -0,0 +1,91 @@
+{
+    "problem_name": "three_sum_closest",
+    "solution_class_name": "Solution",
+    "problem_number": "16",
+    "problem_title": "3Sum Closest",
+    "difficulty": "Medium",
+    "topics": "Array, Two Pointers, Sorting",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Given an integer array `nums` of length `n` and an integer `target`, find three integers at **distinct indices** in `nums` such that the sum is closest to `target`.\n\nReturn *the sum of the three integers*.\n\nYou may assume that each input would have exactly one solution.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: nums = [-1,2,1,-4], target = 1\nOutput: 2\nExplanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).\n```"
+            },
+            {
+                "content": "```\nInput: nums = [0,0,0], target = 1\nOutput: 0\nExplanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 3 <= nums.length <= 500\n- -1000 <= nums[i] <= 1000\n- -10^4 <= target <= 10^4",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "three_sum_closest",
+    "helpers_run_signature": "(solution_class: type, nums: list[int], target: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.three_sum_closest(nums, target)",
+    "helpers_assert_name": "three_sum_closest",
+    "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_three_sum_closest, run_three_sum_closest\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ThreeSumClosest",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "three_sum_closest",
+                "signature": "(self, nums: list[int], target: int) -> int",
+                "body": "        # TODO: Implement three_sum_closest\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_three_sum_closest",
+                "signature": "(self, nums: list[int], target: int, expected: int)",
+                "parametrize": "nums, target, expected",
+                "test_cases": {
+                    "list": [
+                        "([-1, 2, 1, -4], 1, 2)",
+                        "([0, 0, 0], 1, 0)",
+                        "([1, 1, -1, -1, 3], -1, -1)",
+                        "([1, 2, 3, 4, 5], 9, 9)",
+                        "([0, 1, 2], 0, 3)",
+                        "([0, 1, 2], 3, 3)",
+                        "([-4, -2, -1, 0, 3, 5], 1, 1)",
+                        "([1, 2, 5, 10, 11], 12, 13)",
+                        "([2, 3, 4, 5], 50, 12)",
+                        "([1, 1, 1], 3, 3)",
+                        "([100, 200, 300, 400], 200, 600)",
+                        "([-5, -4, -3, -2, -1], -12, -12)",
+                        "([5, 5, 5, 5], 10, 15)",
+                        "([1, 2, 4, 8, 16], 10, 11)",
+                        "([1, 2, 3], 1, 6)",
+                        "([-1, 0, 1, 2, -1, -4], 0, 0)"
+                    ]
+                },
+                "body": "        result = run_three_sum_closest(Solution, nums, target)\n        assert_three_sum_closest(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_three_sum_closest, assert_three_sum_closest\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [-1, 2, 1, -4]\ntarget = 1\nexpected = 2",
+    "playground_run": "result = run_three_sum_closest(Solution, nums, target)\nresult",
+    "playground_assert": "assert_three_sum_closest(result, expected)"
+}

{leetcode_py_sdk-0.46.0 → leetcode_py_sdk-0.47.0}/src/leetcode_py/cli/resources/leetcode/json/tags.json5

@@ -95,17 +95,22 @@
         "gas_station",
         "group_anagrams",
         "house_robber",
+        "longest_common_prefix",
         "longest_consecutive_sequence",
         "longest_increasing_subsequence",
+        "longest_valid_parentheses",
         "maximum_product_subarray",
         "maximum_width_of_binary_tree",
         "next_permutation",
         "odd_even_linked_list",
         "pacific_atlantic_water_flow",
+        "palindrome_number",
         "path_sum_ii",
         "remove_nth_node_from_end_of_list",
+        "roman_to_integer",
         "rotate_array",
         "swap_nodes_in_pairs",
+        "three_sum_closest",
         "top_k_frequent_words",
         "valid_sudoku",
     ],