feat: add Merge k Sorted Lists

Author: wislertt

.templates/leetcode/json/merge_k_sorted_lists.json

@@ -0,0 +1,46 @@
+{
+    "problem_name": "merge_k_sorted_lists",
+    "solution_class_name": "Solution",
+    "problem_number": "23",
+    "problem_title": "Merge k Sorted Lists",
+    "difficulty": "Hard",
+    "topics": "Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort",
+    "tags": ["grind-75"],
+    "readme_description": "You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.\n\n*Merge all the linked-lists into one sorted linked-list and return it.*",
+    "readme_examples": [
+        {
+            "content": "```\nInput: lists = [[1,4,5],[1,3,4],[2,6]]\nOutput: [1,1,2,3,4,4,5,6]\n```\n**Explanation:** The linked-lists are:\n```\n[\n  1->4->5,\n  1->3->4,\n  2->6\n]\n```\nmerging them into one sorted linked list:\n```\n1->1->2->3->4->4->5->6\n```"
+        },
+        { "content": "```\nInput: lists = []\nOutput: []\n```" },
+        { "content": "```\nInput: lists = [[]]\nOutput: []\n```" }
+    ],
+    "readme_constraints": "- `k == lists.length`\n- `0 <= k <= 10^4`\n- `0 <= lists[i].length <= 500`\n- `-10^4 <= lists[i][j] <= 10^4`\n- `lists[i]` is sorted in ascending order.\n- The sum of `lists[i].length` will not exceed `10^4`.",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_methods": [
+        {
+            "name": "merge_k_lists",
+            "parameters": "lists: list[ListNode | None]",
+            "return_type": "ListNode | None",
+            "dummy_return": "None"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom leetcode_py import ListNode\nfrom .solution import Solution",
+    "test_class_name": "MergeKSortedLists",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_merge_k_lists",
+            "parametrize": "lists_data, expected_data",
+            "parametrize_typed": "lists_data: list[list[int]], expected_data: list[int]",
+            "test_cases": "[([[1, 4, 5], [1, 3, 4], [2, 6]], [1, 1, 2, 3, 4, 4, 5, 6]), ([], []), ([[]], []), ([[1]], [1]), ([[1, 2], [3, 4]], [1, 2, 3, 4]), ([[5], [1, 3], [2, 4, 6]], [1, 2, 3, 4, 5, 6]), ([[-1, 0, 1], [-2, 2]], [-2, -1, 0, 1, 2]), ([[1, 1, 1], [2, 2, 2]], [1, 1, 1, 2, 2, 2]), ([[]], []), ([[], [1], []], [1])]",
+            "body": "lists = [ListNode.from_list(lst) for lst in lists_data]\nresult = self.solution.merge_k_lists(lists)\nexpected = ListNode.from_list(expected_data)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution\nfrom leetcode_py import ListNode",
+    "playground_test_case": "# Example test case\nlists_data = [[1, 4, 5], [1, 3, 4], [2, 6]]\nlists = [ListNode.from_list(lst) for lst in lists_data]\nexpected_data = [1, 1, 2, 3, 4, 4, 5, 6]",
+    "playground_execution": "result = Solution().merge_k_lists(lists)\nListNode.to_list(result) if result else []",
+    "playground_assertion": "expected = ListNode.from_list(expected_data)\nassert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= basic_calculator
+PROBLEM ?= merge_k_sorted_lists
 FORCE ?= 0
 COMMA := ,
 

leetcode/basic_calculator/playground.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "imports",
    "metadata": {},
    "outputs": [],
@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "setup",
    "metadata": {},
    "outputs": [],
@@ -24,17 +24,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "execute",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "23"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "result = Solution().calculate(s)\nresult"
+    "result = Solution().calculate(s)\n",
+    "result"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "test",
    "metadata": {},
    "outputs": [],
@@ -57,7 +69,7 @@
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
-   "nbconvert_exporter": "python3",
+   "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.13.7"
   }

leetcode/merge_k_sorted_lists/README.md

@@ -0,0 +1,61 @@
+# Merge k Sorted Lists
+
+**Difficulty:** Hard
+**Topics:** Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort
+**Tags:** grind-75
+
+**LeetCode:** [Problem 23](https://leetcode.com/problems/merge-k-sorted-lists/description/)
+
+## Problem Description
+
+You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.
+
+_Merge all the linked-lists into one sorted linked-list and return it._
+
+## Examples
+
+### Example 1:
+
+```
+Input: lists = [[1,4,5],[1,3,4],[2,6]]
+Output: [1,1,2,3,4,4,5,6]
+```
+
+**Explanation:** The linked-lists are:
+
+```
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+```
+
+merging them into one sorted linked list:
+
+```
+1->1->2->3->4->4->5->6
+```
+
+### Example 2:
+
+```
+Input: lists = []
+Output: []
+```
+
+### Example 3:
+
+```
+Input: lists = [[]]
+Output: []
+```
+
+## Constraints
+
+- `k == lists.length`
+- `0 <= k <= 10^4`
+- `0 <= lists[i].length <= 500`
+- `-10^4 <= lists[i][j] <= 10^4`
+- `lists[i]` is sorted in ascending order.
+- The sum of `lists[i].length` will not exceed `10^4`.

leetcode/merge_k_sorted_lists/__init__.py

@@ -0,0 +1,83 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution\n",
+    "\n",
+    "from leetcode_py import ListNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "lists_data = [[1, 4, 5], [1, 3, 4], [2, 6]]\n",
+    "lists = [ListNode.from_list(lst) for lst in lists_data]\n",
+    "expected_data = [1, 1, 2, 3, 4, 4, 5, 6]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1, 1, 2, 3, 4, 4, 5, 6]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().merge_k_lists(lists)\n",
+    "ListNode.to_list(result) if result else []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "expected = ListNode.from_list(expected_data)\n",
+    "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": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/merge_k_sorted_lists/playground.ipynb

@@ -0,0 +1,35 @@
+from leetcode_py import ListNode
+
+
+class Solution:
+    # Time: O(n log k) where n is total nodes, k is number of lists
+    # Space: O(log k) for recursion stack
+    def merge_k_lists(self, lists: list[ListNode | None]) -> ListNode | None:
+        if not lists:
+            return None
+        return self._divide_conquer(lists, 0, len(lists) - 1)
+
+    def _divide_conquer(self, lists: list[ListNode | None], left: int, right: int) -> ListNode | None:
+        if left == right:
+            return lists[left]
+
+        mid = (left + right) // 2
+        l1 = self._divide_conquer(lists, left, mid)
+        l2 = self._divide_conquer(lists, mid + 1, right)
+        return self._merge_two(l1, l2)
+
+    def _merge_two(self, l1: ListNode | None, l2: ListNode | None) -> ListNode | None:
+        dummy = ListNode(0)
+        curr = dummy
+
+        while l1 and l2:
+            if l1.val <= l2.val:
+                curr.next = l1
+                l1 = l1.next
+            else:
+                curr.next = l2
+                l2 = l2.next
+            curr = curr.next
+
+        curr.next = l1 or l2
+        return dummy.next

leetcode/merge_k_sorted_lists/solution.py

@@ -0,0 +1,45 @@
+import pytest
+
+from leetcode_py import ListNode
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestMergeKSortedLists:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "lists_data, expected_data",
+        [
+            ([[1, 4, 5], [1, 3, 4], [2, 6]], [1, 1, 2, 3, 4, 4, 5, 6]),
+            ([], []),
+            ([[]], []),
+            ([[1]], [1]),
+            ([[1, 2], [3, 4]], [1, 2, 3, 4]),
+            ([[5], [1, 3], [2, 4, 6]], [1, 2, 3, 4, 5, 6]),
+            ([[-1, 0, 1], [-2, 2]], [-2, -1, 0, 1, 2]),
+            ([[1, 1, 1], [2, 2, 2]], [1, 1, 1, 2, 2, 2]),
+            ([[]], []),
+            ([[], [1], []], [1]),
+            ([[0]], [0]),
+            ([[-10, -5, -1], [-8, -3], [-7, -2, 0]], [-10, -8, -7, -5, -3, -2, -1, 0]),
+            ([[1, 2, 3, 4, 5]], [1, 2, 3, 4, 5]),
+            ([[10], [9], [8], [7]], [7, 8, 9, 10]),
+            ([[1, 100], [2, 99], [3, 98]], [1, 2, 3, 98, 99, 100]),
+            ([[], [], []], []),
+            ([[0, 0, 0], [0, 0]], [0, 0, 0, 0, 0]),
+            ([[1, 3, 5, 7], [2, 4, 6, 8]], [1, 2, 3, 4, 5, 6, 7, 8]),
+            (
+                [[100, 200, 300], [50, 150, 250], [75, 125, 175]],
+                [50, 75, 100, 125, 150, 175, 200, 250, 300],
+            ),
+        ],
+    )
+    @logged_test
+    def test_merge_k_lists(self, lists_data: list[list[int]], expected_data: list[int]):
+        lists = [ListNode.from_list(lst) for lst in lists_data]
+        result = self.solution.merge_k_lists(lists)
+        expected = ListNode.from_list(expected_data)
+        assert result == expected