feat: add Merge Two Sorted Lists

Author: wislertt

.templates/leetcode/json/merge_two_sorted_lists.json

@@ -0,0 +1,46 @@
+{
+    "problem_name": "merge_two_sorted_lists",
+    "solution_class_name": "Solution",
+    "problem_number": "21",
+    "problem_title": "Merge Two Sorted Lists",
+    "difficulty": "Easy",
+    "topics": "Linked List, Recursion",
+    "tags": ["grind-75"],
+    "readme_description": "You are given the heads of two sorted linked lists `list1` and `list2`.\n\nMerge the two lists into one **sorted** list. The list should be made by splicing together the nodes of the first two lists.\n\nReturn *the head of the merged linked list*.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)\n\n```\nInput: list1 = [1,2,4], list2 = [1,3,4]\nOutput: [1,1,2,3,4,4]\n```"
+        },
+        { "content": "```\nInput: list1 = [], list2 = []\nOutput: []\n```" },
+        { "content": "```\nInput: list1 = [], list2 = [0]\nOutput: [0]\n```" }
+    ],
+    "readme_constraints": "- The number of nodes in both lists is in the range `[0, 50]`.\n- `-100 <= Node.val <= 100`\n- Both `list1` and `list2` are sorted in **non-decreasing** order.",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_methods": [
+        {
+            "name": "merge_two_lists",
+            "parameters": "list1: ListNode | None, list2: 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": "MergeTwoSortedLists",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_merge_two_lists",
+            "parametrize": "list1_vals, list2_vals, expected_vals",
+            "parametrize_typed": "list1_vals: list[int], list2_vals: list[int], expected_vals: list[int]",
+            "test_cases": "[([1, 2, 4], [1, 3, 4], [1, 1, 2, 3, 4, 4]), ([], [], []), ([], [0], [0]), ([1], [2], [1, 2]), ([2], [1], [1, 2])]",
+            "body": "list1 = ListNode.from_list(list1_vals)\nlist2 = ListNode.from_list(list2_vals)\nexpected = ListNode.from_list(expected_vals)\nresult = self.solution.merge_two_lists(list1, list2)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution\nfrom leetcode_py import ListNode",
+    "playground_test_case": "# Example test case\nlist1_vals = [1, 2, 4]\nlist2_vals = [1, 3, 4]\nexpected_vals = [1, 1, 2, 3, 4, 4]",
+    "playground_execution": "list1 = ListNode.from_list(list1_vals)\nlist2 = ListNode.from_list(list2_vals)\nresult = Solution().merge_two_lists(list1, list2)\nresult",
+    "playground_assertion": "expected = ListNode.from_list(expected_vals)\nassert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= balanced_binary_tree
+PROBLEM ?= merge_two_sorted_lists
 FORCE ?= 0
 COMMA := ,
 

leetcode/merge_two_sorted_lists/README.md

@@ -0,0 +1,46 @@
+# Merge Two Sorted Lists
+
+**Difficulty:** Easy
+**Topics:** Linked List, Recursion
+**Tags:** grind-75
+
+**LeetCode:** [Problem 21](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+
+## Problem Description
+
+You are given the heads of two sorted linked lists `list1` and `list2`.
+
+Merge the two lists into one **sorted** list. The list should be made by splicing together the nodes of the first two lists.
+
+Return _the head of the merged linked list_.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)
+
+```
+Input: list1 = [1,2,4], list2 = [1,3,4]
+Output: [1,1,2,3,4,4]
+```
+
+### Example 2:
+
+```
+Input: list1 = [], list2 = []
+Output: []
+```
+
+### Example 3:
+
+```
+Input: list1 = [], list2 = [0]
+Output: [0]
+```
+
+## Constraints
+
+- The number of nodes in both lists is in the range `[0, 50]`.
+- `-100 <= Node.val <= 100`
+- Both `list1` and `list2` are sorted in **non-decreasing** order.

leetcode/merge_two_sorted_lists/__init__.py

@@ -0,0 +1,74 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution\n",
+    "\n",
+    "from leetcode_py import ListNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "list1_vals = [1, 2, 4]\n",
+    "list2_vals = [1, 3, 4]\n",
+    "expected_vals = [1, 1, 2, 3, 4, 4]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = ListNode.from_list(list1_vals)\n",
+    "list2 = ListNode.from_list(list2_vals)\n",
+    "result = Solution().merge_two_lists(list1, list2)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "expected = ListNode.from_list(expected_vals)\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_two_sorted_lists/playground.ipynb

@@ -0,0 +1,22 @@
+from leetcode_py import ListNode
+
+
+class Solution:
+    # Time: O(m + n)
+    # Space: O(1)
+    def merge_two_lists(self, list1: ListNode | None, list2: ListNode | None) -> ListNode | None:
+
+        dummy = ListNode(0)
+        current = dummy
+
+        while list1 and list2:
+            if list1.val <= list2.val:
+                current.next = list1
+                list1 = list1.next
+            else:
+                current.next = list2
+                list2 = list2.next
+            current = current.next
+
+        current.next = list1 or list2
+        return dummy.next

leetcode/merge_two_sorted_lists/solution.py

@@ -0,0 +1,37 @@
+import pytest
+
+from leetcode_py import ListNode
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestMergeTwoSortedLists:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "list1_vals, list2_vals, expected_vals",
+        [
+            ([1, 2, 4], [1, 3, 4], [1, 1, 2, 3, 4, 4]),
+            ([], [], []),
+            ([], [0], [0]),
+            ([0], [], [0]),
+            ([1], [2], [1, 2]),
+            ([2], [1], [1, 2]),
+            ([1, 1, 1], [2, 2, 2], [1, 1, 1, 2, 2, 2]),
+            ([1, 3, 5], [2, 4, 6], [1, 2, 3, 4, 5, 6]),
+            ([-10, -5, 0], [-8, -3, 1], [-10, -8, -5, -3, 0, 1]),
+            ([5], [1, 2, 3, 4], [1, 2, 3, 4, 5]),
+            ([1, 2, 3, 4], [5], [1, 2, 3, 4, 5]),
+        ],
+    )
+    @logged_test
+    def test_merge_two_lists(
+        self, list1_vals: list[int], list2_vals: list[int], expected_vals: list[int]
+    ):
+        list1 = ListNode.from_list(list1_vals)
+        list2 = ListNode.from_list(list2_vals)
+        expected = ListNode.from_list(expected_vals)
+        result = self.solution.merge_two_lists(list1, list2)
+        assert result == expected