feat: add maximum_profit_in_job_scheduling

Author: wislertt

.templates/check_test_cases.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+import json
+from pathlib import Path
+
+def count_test_cases(json_data):
+    """Count total test cases across all test methods."""
+    total = 0
+
+    # Handle both direct test_methods and nested _test_methods.list
+    test_methods = json_data.get("test_methods", [])
+    if not test_methods and "_test_methods" in json_data:
+        test_methods = json_data["_test_methods"].get("list", [])
+
+    for method in test_methods:
+        test_cases = method.get("test_cases", "")
+        if test_cases.strip():
+            # Count tuples/lists in test_cases string
+            total += max(test_cases.count("("), test_cases.count("["))
+    return total
+
+def main():
+    json_dir = Path(".templates/leetcode/json")
+    files_with_few_tests = []
+
+    for json_file in json_dir.glob("*.json"):
+        try:
+            with open(json_file) as f:
+                data = json.load(f)
+
+            test_count = count_test_cases(data)
+            if test_count <= 10:
+                files_with_few_tests.append((json_file.name, test_count))
+        except Exception as e:
+            print(f"Error reading {json_file.name}: {e}")
+
+    # Sort by test count
+    files_with_few_tests.sort(key=lambda x: x[1])
+
+    print(f"Files with ≤10 test cases ({len(files_with_few_tests)} total):")
+    for filename, count in files_with_few_tests:
+        print(f"{filename}: {count} test cases")
+
+if __name__ == "__main__":
+    main()

.templates/leetcode/json/flood_fill.json

@@ -0,0 +1,64 @@
+{
+    "problem_name": "flood_fill",
+    "solution_class_name": "Solution",
+    "problem_number": "733",
+    "problem_title": "Flood Fill",
+    "difficulty": "Easy",
+    "topics": "Array, Depth-First Search, Breadth-First Search, Matrix",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "You are given an image represented by an `m x n` grid of integers `image`, where `image[i][j]` represents the pixel value of the image. You are also given three integers `sr`, `sc`, and `color`. Your task is to perform a **flood fill** on the image starting from the pixel `image[sr][sc]`.\n\nTo perform a **flood fill**:\n\n1. Begin with the starting pixel and change its color to `color`.\n2. Perform the same process for each pixel that is **directly adjacent** (pixels that share a side with the original pixel, either horizontally or vertically) and shares the **same color** as the starting pixel.\n3. Keep **repeating** this process by checking neighboring pixels of the *updated* pixels and modifying their color if it matches the original color of the starting pixel.\n4. The process **stops** when there are **no more** adjacent pixels of the original color to update.\n\nReturn the **modified** image after performing the flood fill.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2021/06/01/flood1-grid.jpg)\n\n```\nInput: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2\nOutput: [[2,2,2],[2,2,0],[2,0,1]]\n```\n**Explanation:** From the center of the image with position `(sr, sc) = (1, 1)` (i.e., the red pixel), all pixels connected by a path of the same color as the starting pixel (i.e., the blue pixels) are colored with the new color. Note the bottom corner is not colored 2, because it is not horizontally or vertically connected to the starting pixel."
+            },
+            {
+                "content": "```\nInput: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, color = 0\nOutput: [[0,0,0],[0,0,0]]\n```\n**Explanation:** The starting pixel is already colored with 0, which is the same as the target color. Therefore, no changes are made to the image."
+            }
+        ]
+    },
+    "readme_constraints": "- `m == image.length`\n- `n == image[i].length`\n- `1 <= m, n <= 50`\n- `0 <= image[i][j], color < 2^16`\n- `0 <= sr < m`\n- `0 <= sc < n`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "flood_fill",
+    "helpers_run_signature": "(solution_class: type, image: list[list[int]], sr: int, sc: int, color: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.flood_fill(image, sr, sc, color)",
+    "helpers_assert_name": "flood_fill",
+    "helpers_assert_signature": "(result: list[list[int]], expected: list[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_flood_fill, run_flood_fill\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "FloodFill",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "flood_fill",
+                "signature": "(self, image: list[list[int]], sr: int, sc: int, color: int) -> list[list[int]]",
+                "body": "        # TODO: Implement flood_fill\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_flood_fill",
+                "signature": "(self, image: list[list[int]], sr: int, sc: int, color: int, expected: list[list[int]])",
+                "parametrize": "image, sr, sc, color, expected",
+                "test_cases": "[([[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 2, [[2, 2, 2], [2, 2, 0], [2, 0, 1]]), ([[0, 0, 0], [0, 0, 0]], 0, 0, 0, [[0, 0, 0], [0, 0, 0]]), ([[0, 0, 0], [0, 1, 1]], 1, 1, 1, [[0, 0, 0], [0, 1, 1]]), ([[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 1, [[1, 1, 1], [1, 1, 0], [1, 0, 1]])]",
+                "body": "        result = run_flood_fill(Solution, image, sr, sc, color)\n        assert_flood_fill(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_flood_fill, assert_flood_fill\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nimage = [[1, 1, 1], [1, 1, 0], [1, 0, 1]]\nsr = 1\nsc = 1\ncolor = 2\nexpected = [[2, 2, 2], [2, 2, 0], [2, 0, 1]]",
+    "playground_run": "result = run_flood_fill(Solution, image, sr, sc, color)\nresult",
+    "playground_assert": "assert_flood_fill(result, expected)"
+}

.templates/leetcode/json/implement_queue_using_stacks.json

@@ -0,0 +1,79 @@
+{
+    "problem_name": "implement_queue_using_stacks",
+    "solution_class_name": "MyQueue",
+    "problem_number": "232",
+    "problem_title": "Implement Queue using Stacks",
+    "difficulty": "Easy",
+    "topics": "Stack, Design, Queue",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (`push`, `peek`, `pop`, and `empty`).\n\nImplement the `MyQueue` class:\n\n- `void push(int x)` Pushes element x to the back of the queue.\n- `int pop()` Removes the element from the front of the queue and returns it.\n- `int peek()` Returns the element at the front of the queue.\n- `boolean empty()` Returns `true` if the queue is empty, `false` otherwise.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput\n[\"MyQueue\", \"push\", \"push\", \"peek\", \"pop\", \"empty\"]\n[[], [1], [2], [], [], []]\nOutput\n[null, null, null, 1, 1, false]\n```\n**Explanation:**\n```\nMyQueue myQueue = new MyQueue();\nmyQueue.push(1); // queue is: [1]\nmyQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)\nmyQueue.peek(); // return 1\nmyQueue.pop(); // return 1, queue is [2]\nmyQueue.empty(); // return false\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= x <= 9\n- At most 100 calls will be made to push, pop, peek, and empty.\n- All the calls to pop and peek are valid.",
+    "readme_additional": "**Notes:**\n- You must use **only** standard operations of a stack, which means only `push to top`, `peek/pop from top`, `size`, and `is empty` operations are valid.\n- Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.\n\n**Follow-up:** Can you implement the queue such that each operation is amortized `O(1)` time complexity? In other words, performing `n` operations will take overall `O(n)` time even if one of those operations may take longer.",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "my_queue",
+    "helpers_run_signature": "(solution_class: type, operations: list[str], inputs: list[list[int]])",
+    "helpers_run_body": "    queue = None\n    results: list[int | None | bool] = []\n    for i, op in enumerate(operations):\n        if op == 'MyQueue':\n            queue = solution_class()\n            results.append(None)\n        elif op == 'push' and queue is not None:\n            queue.push(inputs[i][0])\n            results.append(None)\n        elif op == 'pop' and queue is not None:\n            results.append(queue.pop())\n        elif op == 'peek' and queue is not None:\n            results.append(queue.peek())\n        elif op == 'empty' and queue is not None:\n            results.append(queue.empty())\n    return results, queue",
+    "helpers_assert_name": "my_queue",
+    "helpers_assert_signature": "(result: list[int | None | bool], expected: list[int | None | 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_my_queue, run_my_queue\nfrom .solution import MyQueue",
+    "test_content": "",
+    "test_class_name": "ImplementQueueUsingStacks",
+    "test_class_content": "",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "__init__",
+                "signature": "(self) -> None",
+                "body": "        # TODO: Initialize\n        pass"
+            },
+            {
+                "name": "push",
+                "signature": "(self, x: int) -> None",
+                "body": "        # TODO: Implement push\n        pass"
+            },
+            {
+                "name": "pop",
+                "signature": "(self) -> int",
+                "body": "        # TODO: Implement pop\n        return 0"
+            },
+            {
+                "name": "peek",
+                "signature": "(self) -> int",
+                "body": "        # TODO: Implement peek\n        return 0"
+            },
+            {
+                "name": "empty",
+                "signature": "(self) -> bool",
+                "body": "        # TODO: Implement empty\n        return True"
+            }
+        ]
+    },
+    "_test_helper_methods": { "list": [] },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_queue_operations",
+                "signature": "(self, operations: list[str], inputs: list[list[int]], expected: list[int | None | bool])",
+                "parametrize": "operations, inputs, expected",
+                "test_cases": "[(['MyQueue', 'push', 'push', 'peek', 'pop', 'empty'], [[], [1], [2], [], [], []], [None, None, None, 1, 1, False]), (['MyQueue', 'empty', 'push', 'peek', 'pop', 'empty'], [[], [], [1], [], [], []], [None, True, None, 1, 1, True]), (['MyQueue', 'push', 'push', 'push', 'pop', 'pop', 'peek', 'pop', 'empty'], [[], [1], [2], [3], [], [], [], [], []], [None, None, None, None, 1, 2, 3, 3, True])]",
+                "body": "        result, _ = run_my_queue(MyQueue, operations, inputs)\n        assert_my_queue(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_my_queue, assert_my_queue\nfrom solution import MyQueue",
+    "playground_setup": "# Example test case\noperations = ['MyQueue', 'push', 'push', 'peek', 'pop', 'empty']\ninputs = [[], [1], [2], [], [], []]\nexpected = [None, None, None, 1, 1, False]",
+    "playground_run": "result, queue = run_my_queue(MyQueue, operations, inputs)\nprint(result)\nqueue",
+    "playground_assert": "assert_my_queue(result, expected)"
+}

.templates/leetcode/json/insert_interval.json

@@ -0,0 +1,64 @@
+{
+    "problem_name": "insert_interval",
+    "solution_class_name": "Solution",
+    "problem_number": "57",
+    "problem_title": "Insert Interval",
+    "difficulty": "Medium",
+    "topics": "Array",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "You are given an array of non-overlapping intervals `intervals` where `intervals[i] = [starti, endi]` represent the start and the end of the ith interval and `intervals` is sorted in ascending order by `starti`. You are also given an interval `newInterval = [start, end]` that represents the start and end of another interval.\n\nInsert `newInterval` into `intervals` such that `intervals` is still sorted in ascending order by `starti` and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).\n\nReturn `intervals` after the insertion.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: intervals = [[1,3],[6,9]], newInterval = [2,5]\nOutput: [[1,5],[6,9]]\n```"
+            },
+            {
+                "content": "```\nInput: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]\nOutput: [[1,2],[3,10],[12,16]]\nExplanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 0 <= intervals.length <= 10^4\n- intervals[i].length == 2\n- 0 <= starti <= endi <= 10^5\n- intervals is sorted by starti in ascending order\n- newInterval.length == 2\n- 0 <= start <= end <= 10^5",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "insert",
+    "helpers_run_signature": "(solution_class: type, intervals: list[list[int]], new_interval: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.insert(intervals, new_interval)",
+    "helpers_assert_name": "insert",
+    "helpers_assert_signature": "(result: list[list[int]], expected: list[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_insert, run_insert\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "InsertInterval",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "insert",
+                "signature": "(self, intervals: list[list[int]], new_interval: list[int]) -> list[list[int]]",
+                "body": "        # TODO: Implement insert\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_insert",
+                "signature": "(self, intervals: list[list[int]], new_interval: list[int], expected: list[list[int]])",
+                "parametrize": "intervals, new_interval, expected",
+                "test_cases": "[([[1,3],[6,9]], [2,5], [[1,5],[6,9]]), ([[1,2],[3,5],[6,7],[8,10],[12,16]], [4,8], [[1,2],[3,10],[12,16]]), ([], [5,7], [[5,7]]), ([[1,5]], [2,3], [[1,5]]), ([[1,5]], [6,8], [[1,5],[6,8]]), ([[1,5]], [0,0], [[0,0],[1,5]]), ([[3,5],[12,15]], [6,6], [[3,5],[6,6],[12,15]])]",
+                "body": "        result = run_insert(Solution, intervals, new_interval)\n        assert_insert(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_insert, assert_insert\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nintervals = [[1,3],[6,9]]\nnew_interval = [2,5]\nexpected = [[1,5],[6,9]]",
+    "playground_run": "result = run_insert(Solution, intervals, new_interval)\nresult",
+    "playground_assert": "assert_insert(result, expected)"
+}