feat: add more question

Author: wislertt

.templates/leetcode/json/task_scheduler.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "task_scheduler",
+    "solution_class_name": "Solution",
+    "problem_number": "621",
+    "problem_title": "Task Scheduler",
+    "difficulty": "Medium",
+    "topics": "Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting",
+    "tags": ["grind-75"],
+    "readme_description": "You are given an array of CPU `tasks`, each labeled with a letter from A to Z, and a number `n`. Each CPU interval can be idle or allow the completion of one task. Tasks can be completed in any order, but there's a constraint: there has to be a gap of **at least** `n` intervals between two tasks with the same label.\n\nReturn the **minimum** number of CPU intervals required to complete all tasks.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: tasks = [\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n = 2\nOutput: 8\n```\n**Explanation:** A possible sequence is: A -> B -> idle -> A -> B -> idle -> A -> B.\n\nAfter completing task A, you must wait two intervals before doing A again. The same applies to task B. In the 3rd interval, neither A nor B can be done, so you idle. By the 4th interval, you can do A again as 2 intervals have passed."
+        },
+        {
+            "content": "```\nInput: tasks = [\"A\",\"C\",\"A\",\"B\",\"D\",\"B\"], n = 1\nOutput: 6\n```\n**Explanation:** A possible sequence is: A -> B -> C -> D -> A -> B.\n\nWith a cooling interval of 1, you can repeat a task after just one other task."
+        },
+        {
+            "content": "```\nInput: tasks = [\"A\",\"A\",\"A\", \"B\",\"B\",\"B\"], n = 3\nOutput: 10\n```\n**Explanation:** A possible sequence is: A -> B -> idle -> idle -> A -> B -> idle -> idle -> A -> B.\n\nThere are only two types of tasks, A and B, which need to be separated by 3 intervals. This leads to idling twice between repetitions of these tasks."
+        }
+    ],
+    "readme_constraints": "- `1 <= tasks.length <= 10^4`\n- `tasks[i]` is an uppercase English letter.\n- `0 <= n <= 100`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "least_interval",
+            "parameters": "tasks: list[str], n: int",
+            "return_type": "int",
+            "dummy_return": "0"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "TaskScheduler",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_least_interval",
+            "parametrize": "tasks, n, expected",
+            "parametrize_typed": "tasks: list[str], n: int, expected: int",
+            "test_cases": "[([\"A\", \"A\", \"A\", \"B\", \"B\", \"B\"], 2, 8), ([\"A\", \"C\", \"A\", \"B\", \"D\", \"B\"], 1, 6), ([\"A\", \"A\", \"A\", \"B\", \"B\", \"B\"], 3, 10)]",
+            "body": "result = self.solution.least_interval(tasks, n)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ntasks = [\\\"A\\\", \\\"A\\\", \\\"A\\\", \\\"B\\\", \\\"B\\\", \\\"B\\\"]\nn = 2\nexpected = 8",
+    "playground_execution": "result = Solution().least_interval(tasks, n)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= evaluate_reverse_polish_notation
+PROBLEM ?= task_scheduler
 FORCE ?= 0
 
 sync_submodules:

leetcode/task_scheduler/README.md

@@ -0,0 +1,54 @@
+# Task Scheduler
+
+**Difficulty:** Medium
+**Topics:** Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting
+**Tags:** grind-75
+
+**LeetCode:** [Problem 621](https://leetcode.com/problems/task-scheduler/description/)
+
+## Problem Description
+
+You are given an array of CPU `tasks`, each labeled with a letter from A to Z, and a number `n`. Each CPU interval can be idle or allow the completion of one task. Tasks can be completed in any order, but there's a constraint: there has to be a gap of **at least** `n` intervals between two tasks with the same label.
+
+Return the **minimum** number of CPU intervals required to complete all tasks.
+
+## Examples
+
+### Example 1:
+
+```
+Input: tasks = ["A","A","A","B","B","B"], n = 2
+Output: 8
+```
+
+**Explanation:** A possible sequence is: A -> B -> idle -> A -> B -> idle -> A -> B.
+
+After completing task A, you must wait two intervals before doing A again. The same applies to task B. In the 3rd interval, neither A nor B can be done, so you idle. By the 4th interval, you can do A again as 2 intervals have passed.
+
+### Example 2:
+
+```
+Input: tasks = ["A","C","A","B","D","B"], n = 1
+Output: 6
+```
+
+**Explanation:** A possible sequence is: A -> B -> C -> D -> A -> B.
+
+With a cooling interval of 1, you can repeat a task after just one other task.
+
+### Example 3:
+
+```
+Input: tasks = ["A","A","A", "B","B","B"], n = 3
+Output: 10
+```
+
+**Explanation:** A possible sequence is: A -> B -> idle -> idle -> A -> B -> idle -> idle -> A -> B.
+
+There are only two types of tasks, A and B, which need to be separated by 3 intervals. This leads to idling twice between repetitions of these tasks.
+
+## Constraints
+
+- `1 <= tasks.length <= 10^4`
+- `tasks[i]` is an uppercase English letter.
+- `0 <= n <= 100`

leetcode/task_scheduler/__init__.py

@@ -0,0 +1,88 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "tasks = [\"A\", \"A\", \"A\", \"B\", \"B\", \"B\"]\n",
+    "n = 2\n",
+    "expected = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Counter({'A': 3, 'B': 3})\n",
+      "[-3, -3]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().least_interval(tasks, n)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/task_scheduler/playground.ipynb

@@ -0,0 +1,65 @@
+import heapq
+from collections import Counter, deque
+
+
+class Solution:
+    # Time: O(T * n + m log m) where T = len(tasks), worst case with many idle periods
+    # Space: O(m) where m ≤ 26, so O(1)
+    def least_interval(self, tasks: list[str], n: int) -> int:
+        counts = Counter(tasks)
+        max_heap = [-count for count in counts.values()]
+        heapq.heapify(max_heap)
+
+        step_num = 0
+        queue: deque[tuple[int, int]] = deque()  # (count, available_time)
+
+        while max_heap or queue:
+            step_num += 1
+
+            while queue and queue[0][1] <= step_num:
+                count, _ = queue.popleft()
+                heapq.heappush(max_heap, count)
+
+            if max_heap:
+                count = heapq.heappop(max_heap)
+                count += 1  # Decrease count (was negative)
+                if count < 0:  # Still has tasks left
+                    queue.append((count, step_num + n + 1))
+
+        return step_num
+
+
+class SolutionGreedy:
+    # Time: O(T + m) where T = len(tasks), m = unique tasks ≤ 26, so O(T)
+    # Space: O(m) where m ≤ 26, so O(1)
+    def least_interval(self, tasks: list[str], n: int) -> int:
+        """
+        Mathematical approach:
+
+        Key insight: The most frequent task determines the minimum time.
+
+        Example: tasks=["A","A","A","B","B","B"], n=2
+
+        1. Find max frequency: max_freq = 3 (A and B both appear 3 times)
+        2. Count tasks with max frequency: max_count = 2 (A and B)
+        3. Create frame structure:
+           Frame: A B _ | A B _ | A B
+           - (max_freq - 1) complete frames of size (n + 1)
+           - Last frame contains only max frequency tasks
+
+        4. Calculate minimum intervals:
+           - Frame intervals: (max_freq - 1) * (n + 1) = 2 * 3 = 6
+           - Plus max frequency tasks: 6 + 2 = 8
+
+        5. Return max(total_tasks, calculated_min) to handle cases where
+           we have enough variety to fill all gaps without idle time.
+        """
+        counts = Counter(tasks)
+        max_freq = max(counts.values())
+        max_count = sum(1 for freq in counts.values() if freq == max_freq)
+
+        # Minimum intervals needed based on most frequent tasks
+        min_intervals = (max_freq - 1) * (n + 1) + max_count
+
+        # Return max to handle cases with sufficient task variety
+        return max(len(tasks), min_intervals)

leetcode/task_scheduler/solution.py

@@ -0,0 +1,30 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution, SolutionGreedy
+
+
+class TestTaskScheduler:
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionGreedy])
+    @pytest.mark.parametrize(
+        "tasks, n, expected",
+        [
+            (["A", "A", "A", "B", "B", "B"], 2, 8),
+            (["A", "C", "A", "B", "D", "B"], 1, 6),
+            (["A", "A", "A", "B", "B", "B"], 3, 10),
+            (["A", "A", "A", "A", "A", "A", "B", "C", "D", "E", "F", "G"], 2, 16),
+            (["A"], 2, 1),
+        ],
+    )
+    @logged_test
+    def test_least_interval(
+        self,
+        tasks: list[str],
+        n: int,
+        expected: int,
+        solution_class: type[Solution | SolutionGreedy],
+    ):
+        solution = solution_class()
+        result = solution.least_interval(tasks, n)
+        assert result == expected