feat: add zero_one_matrix

Author: wislertt

.templates/leetcode/json/permutations.json

@@ -0,0 +1,63 @@
+{
+    "problem_name": "permutations",
+    "solution_class_name": "Solution",
+    "problem_number": "46",
+    "problem_title": "Permutations",
+    "difficulty": "Medium",
+    "topics": "Array, Backtracking",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in any order.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: nums = [1,2,3]\nOutput: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]\n```"
+            },
+            { "content": "```\nInput: nums = [0,1]\nOutput: [[0,1],[1,0]]\n```" },
+            { "content": "```\nInput: nums = [1]\nOutput: [[1]]\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= nums.length <= 6\n- -10 <= nums[i] <= 10\n- All the integers of nums are unique.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "permute",
+    "helpers_run_signature": "(solution_class: type, nums: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.permute(nums)",
+    "helpers_assert_name": "permute",
+    "helpers_assert_signature": "(result: list[list[int]], expected: list[list[int]]) -> bool",
+    "helpers_assert_body": "    # Sort both result and expected for comparison since order doesn't matter\n    result_sorted = [sorted(perm) for perm in result]\n    expected_sorted = [sorted(perm) for perm in expected]\n    result_sorted.sort()\n    expected_sorted.sort()\n    assert len(result) == len(expected)\n    assert result_sorted == expected_sorted\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_permute, run_permute\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "Permutations",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "permute",
+                "signature": "(self, nums: list[int]) -> list[list[int]]",
+                "body": "        # TODO: Implement permute\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_permute",
+                "signature": "(self, nums: list[int], expected: list[list[int]])",
+                "parametrize": "nums, expected",
+                "test_cases": "[([1, 2, 3], [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]), ([0, 1], [[0, 1], [1, 0]]), ([1], [[1]]), ([2, 1], [[2, 1], [1, 2]])]",
+                "body": "        result = run_permute(Solution, nums)\n        assert_permute(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_permute, assert_permute\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [1, 2, 3]\nexpected = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]",
+    "playground_run": "result = run_permute(Solution, nums)\nresult",
+    "playground_assert": "assert_permute(result, expected)"
+}

.templates/leetcode/json/product_of_array_except_self.json

@@ -0,0 +1,60 @@
+{
+    "problem_name": "product_of_array_except_self",
+    "solution_class_name": "Solution",
+    "problem_number": "238",
+    "problem_title": "Product of Array Except Self",
+    "difficulty": "Medium",
+    "topics": "Array, Prefix Sum",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`.\n\nThe product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.\n\nYou must write an algorithm that runs in O(n) time and without using the division operation.",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: nums = [1,2,3,4]\nOutput: [24,12,8,6]\n```" },
+            { "content": "```\nInput: nums = [-1,1,0,-3,3]\nOutput: [0,0,9,0,0]\n```" }
+        ]
+    },
+    "readme_constraints": "- 2 <= nums.length <= 10^5\n- -30 <= nums[i] <= 30\n- The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.",
+    "readme_additional": "**Follow up:** Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "product_except_self",
+    "helpers_run_signature": "(solution_class: type, nums: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.product_except_self(nums)",
+    "helpers_assert_name": "product_except_self",
+    "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.test_utils import logged_test\nfrom .helpers import assert_product_except_self, run_product_except_self\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ProductOfArrayExceptSelf",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "product_except_self",
+                "signature": "(self, nums: list[int]) -> list[int]",
+                "body": "        # TODO: Implement product_except_self\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_product_except_self",
+                "signature": "(self, nums: list[int], expected: list[int])",
+                "parametrize": "nums, expected",
+                "test_cases": "[([1, 2, 3, 4], [24, 12, 8, 6]), ([-1, 1, 0, -3, 3], [0, 0, 9, 0, 0]), ([2, 3, 4, 5], [60, 40, 30, 24]), ([1, 1], [1, 1]), ([5, 2], [2, 5]), ([0, 1, 2, 3], [6, 0, 0, 0]), ([1, 0, 3, 4], [0, 12, 0, 0])]",
+                "body": "        result = run_product_except_self(Solution, nums)\n        assert_product_except_self(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_product_except_self, assert_product_except_self\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [1, 2, 3, 4]\nexpected = [24, 12, 8, 6]",
+    "playground_run": "result = run_product_except_self(Solution, nums)\nresult",
+    "playground_assert": "assert_product_except_self(result, expected)"
+}

.templates/leetcode/json/ransom_note.json

@@ -0,0 +1,61 @@
+{
+    "problem_name": "ransom_note",
+    "solution_class_name": "Solution",
+    "problem_number": "383",
+    "problem_title": "Ransom Note",
+    "difficulty": "Easy",
+    "topics": "Hash Table, String, Counting",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given two strings `ransomNote` and `magazine`, return `true` if `ransomNote` can be constructed by using the letters from `magazine` and `false` otherwise.\n\nEach letter in `magazine` can only be used once in `ransomNote`.",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: ransomNote = \"a\", magazine = \"b\"\nOutput: false\n```" },
+            { "content": "```\nInput: ransomNote = \"aa\", magazine = \"ab\"\nOutput: false\n```" },
+            { "content": "```\nInput: ransomNote = \"aa\", magazine = \"aab\"\nOutput: true\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= ransomNote.length, magazine.length <= 10^5\n- ransomNote and magazine consist of lowercase English letters.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "can_construct",
+    "helpers_run_signature": "(solution_class: type, ransom_note: str, magazine: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.can_construct(ransom_note, magazine)",
+    "helpers_assert_name": "can_construct",
+    "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.test_utils import logged_test\nfrom .helpers import assert_can_construct, run_can_construct\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "RansomNote",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "can_construct",
+                "signature": "(self, ransom_note: str, magazine: str) -> bool",
+                "body": "        # TODO: Implement can_construct\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_can_construct",
+                "signature": "(self, ransom_note: str, magazine: str, expected: bool)",
+                "parametrize": "ransom_note, magazine, expected",
+                "test_cases": "[('a', 'b', False), ('aa', 'ab', False), ('aa', 'aab', True), ('aab', 'baa', True), ('', '', True), ('', 'abc', True), ('abc', '', False), ('abc', 'abc', True), ('abc', 'cba', True), ('aaa', 'aa', False), ('ab', 'ba', True)]",
+                "body": "        result = run_can_construct(Solution, ransom_note, magazine)\n        assert_can_construct(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_can_construct, assert_can_construct\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nransom_note = 'aa'\nmagazine = 'aab'\nexpected = True",
+    "playground_run": "result = run_can_construct(Solution, ransom_note, magazine)\nresult",
+    "playground_assert": "assert_can_construct(result, expected)"
+}

.templates/leetcode/json/reverse_linked_list.json

@@ -0,0 +1,65 @@
+{
+    "problem_name": "reverse_linked_list",
+    "solution_class_name": "Solution",
+    "problem_number": "206",
+    "problem_title": "Reverse Linked List",
+    "difficulty": "Easy",
+    "topics": "Linked List, Recursion",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given the `head` of a singly linked list, reverse the list, and return the reversed list.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)\n\n```\nInput: head = [1,2,3,4,5]\nOutput: [5,4,3,2,1]\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg)\n\n```\nInput: head = [1,2]\nOutput: [2,1]\n```"
+            },
+            { "content": "```\nInput: head = []\nOutput: []\n```" }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in the list is the range `[0, 5000]`.\n- `-5000 <= Node.val <= 5000`",
+    "readme_additional": "**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?",
+    "helpers_imports": "from leetcode_py import ListNode",
+    "helpers_content": "",
+    "helpers_run_name": "reverse_list",
+    "helpers_run_signature": "(solution_class: type, head_list: list[int])",
+    "helpers_run_body": "    head = ListNode[int].from_list(head_list)\n    implementation = solution_class()\n    return implementation.reverse_list(head)",
+    "helpers_assert_name": "reverse_list",
+    "helpers_assert_signature": "(result: ListNode[int] | None, expected_list: list[int]) -> bool",
+    "helpers_assert_body": "    expected = ListNode[int].from_list(expected_list)\n    assert result == expected\n    return True",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_reverse_list, run_reverse_list\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ReverseLinkedList",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "reverse_list",
+                "signature": "(self, head: ListNode[int] | None) -> ListNode[int] | None",
+                "body": "        # TODO: Implement reverse_list\n        return None"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_reverse_list",
+                "signature": "(self, head_list: list[int], expected_list: list[int])",
+                "parametrize": "head_list, expected_list",
+                "test_cases": "[([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]), ([1, 2], [2, 1]), ([1], [1]), ([], []), ([1, 2, 3], [3, 2, 1]), ([1, 2, 3, 4], [4, 3, 2, 1]), ([-1, -2, -3], [-3, -2, -1]), ([0], [0]), ([5000, -5000], [-5000, 5000]), ([1, 1, 1], [1, 1, 1])]",
+                "body": "        result = run_reverse_list(Solution, head_list)\n        assert_reverse_list(result, expected_list)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_reverse_list, assert_reverse_list\nfrom solution import Solution\nfrom leetcode_py import ListNode",
+    "playground_setup": "# Example test case\nhead_list = [1, 2, 3, 4, 5]\nexpected_list = [5, 4, 3, 2, 1]",
+    "playground_run": "result = run_reverse_list(Solution, head_list)\nresult",
+    "playground_assert": "assert_reverse_list(result, expected_list)"
+}

.templates/leetcode/json/reverse_linked_list_ii.json

@@ -0,0 +1,62 @@
+{
+    "problem_name": "reverse_linked_list_ii",
+    "solution_class_name": "Solution",
+    "problem_number": "92",
+    "problem_title": "Reverse Linked List II",
+    "difficulty": "Medium",
+    "topics": "Linked List",
+    "_tags": { "list": [] },
+    "readme_description": "Given the `head` of a singly linked list and two integers `left` and `right` where `left <= right`, reverse the nodes of the list from position `left` to position `right`, and return the reversed list.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: head = [1,2,3,4,5], left = 2, right = 4\nOutput: [1,4,3,2,5]\n```"
+            },
+            { "content": "```\nInput: head = [5], left = 1, right = 1\nOutput: [5]\n```" }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in the list is n\n- 1 <= n <= 500\n- -500 <= Node.val <= 500\n- 1 <= left <= right <= n",
+    "readme_additional": "**Follow up:** Could you do it in one pass?",
+    "helpers_imports": "from leetcode_py import ListNode",
+    "helpers_content": "",
+    "helpers_run_name": "reverse_between",
+    "helpers_run_signature": "(solution_class: type, head_list: list[int], left: int, right: int)",
+    "helpers_run_body": "    head = ListNode[int].from_list(head_list)\n    implementation = solution_class()\n    return implementation.reverse_between(head, left, right)",
+    "helpers_assert_name": "reverse_between",
+    "helpers_assert_signature": "(result: ListNode[int] | None, expected_list: list[int]) -> bool",
+    "helpers_assert_body": "    expected = ListNode[int].from_list(expected_list)\n    assert result == expected\n    return True",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_reverse_between, run_reverse_between\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "ReverseLinkedListII",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "reverse_between",
+                "signature": "(self, head: ListNode[int] | None, left: int, right: int) -> ListNode[int] | None",
+                "body": "        # TODO: Implement reverse_between\n        return None"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_reverse_between",
+                "signature": "(self, head_list: list[int], left: int, right: int, expected_list: list[int])",
+                "parametrize": "head_list, left, right, expected_list",
+                "test_cases": "[([1, 2, 3, 4, 5], 2, 4, [1, 4, 3, 2, 5]), ([5], 1, 1, [5]), ([1, 2], 1, 2, [2, 1]), ([1, 2, 3], 1, 3, [3, 2, 1]), ([1, 2, 3, 4, 5], 1, 5, [5, 4, 3, 2, 1]), ([1, 2, 3, 4, 5], 3, 3, [1, 2, 3, 4, 5])]",
+                "body": "        result = run_reverse_between(Solution, head_list, left, right)\n        assert_reverse_between(result, expected_list)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_reverse_between, assert_reverse_between\nfrom solution import Solution\nfrom leetcode_py import ListNode",
+    "playground_setup": "# Example test case\nhead_list = [1, 2, 3, 4, 5]\nleft, right = 2, 4\nexpected_list = [1, 4, 3, 2, 5]",
+    "playground_run": "result = run_reverse_between(Solution, head_list, left, right)\nresult",
+    "playground_assert": "assert_reverse_between(result, expected_list)"
+}