feat: add Reverse Linked List

Author: wislertt

.templates/leetcode/json/reverse_linked_list.json

@@ -0,0 +1,48 @@
+{
+    "problem_name": "reverse_linked_list",
+    "solution_class_name": "Solution",
+    "problem_number": "206",
+    "problem_title": "Reverse Linked List",
+    "difficulty": "Easy",
+    "topics": "Linked List, Recursion",
+    "tags": ["grind-75"],
+    "readme_description": "Given the `head` of a singly linked list, reverse the list, and return the reversed list.",
+    "readme_examples": [
+        {
+            "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?",
+    "solution_imports": "from leetcode_py import ListNode",
+    "solution_methods": [
+        {
+            "name": "reverse_list",
+            "parameters": "head: ListNode[int] | None",
+            "return_type": "ListNode[int] | 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": "ReverseLinkedList",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_reverse_list",
+            "parametrize": "head_list, expected_list",
+            "parametrize_typed": "head_list: list[int], expected_list: list[int]",
+            "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": "head = ListNode.from_list(head_list)\nexpected = ListNode.from_list(expected_list)\nresult = self.solution.reverse_list(head)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from leetcode_py import ListNode\nfrom solution import Solution",
+    "playground_test_case": "# Example test case\nhead_list = [1, 2, 3, 4, 5]\nexpected_list = [5, 4, 3, 2, 1]\nhead = ListNode.from_list(head_list)\nexpected = ListNode.from_list(expected_list)",
+    "playground_execution": "result = Solution().reverse_list(head)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= merge_intervals
+PROBLEM ?= reverse_linked_list
 FORCE ?= 0
 COMMA := ,
 

leetcode/reverse_linked_list/README.md

@@ -0,0 +1,45 @@
+# Reverse Linked List
+
+**Difficulty:** Easy
+**Topics:** Linked List, Recursion
+**Tags:** grind-75
+
+**LeetCode:** [Problem 206](https://leetcode.com/problems/reverse-linked-list/description/)
+
+## Problem Description
+
+Given the `head` of a singly linked list, reverse the list, and return the reversed list.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)
+
+```
+Input: head = [1,2,3,4,5]
+Output: [5,4,3,2,1]
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg)
+
+```
+Input: head = [1,2]
+Output: [2,1]
+```
+
+### Example 3:
+
+```
+Input: head = []
+Output: []
+```
+
+## Constraints
+
+- The number of nodes in the list is the range `[0, 5000]`.
+- `-5000 <= Node.val <= 5000`
+
+**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?

leetcode/reverse_linked_list/__init__.py

@@ -0,0 +1,114 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution\n",
+    "\n",
+    "from leetcode_py import ListNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original: [1, 2, 3, 4, 5]\n",
+      "Expected: [5, 4, 3, 2, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example test case: reverse [1,2,3,4,5] to [5,4,3,2,1]\n",
+    "head_list = [1, 2, 3, 4, 5]\n",
+    "expected_list = [5, 4, 3, 2, 1]\n",
+    "\n",
+    "# Convert lists to linked lists\n",
+    "head = ListNode.from_list(head_list)\n",
+    "expected = ListNode.from_list(expected_list)\n",
+    "print(f\"Original: {head}\")\n",
+    "print(f\"Expected: {expected}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: [5, 4, 3, 2, 1]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[5, 4, 3, 2, 1]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Reverse the linked list: 1->2->3->4->5 becomes 5->4->3->2->1\n",
+    "result = Solution().reverse_list(head)\n",
+    "print(f\"Result: {result}\")\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Test passed! Linked list successfully reversed.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Verify the result matches expected output\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": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/reverse_linked_list/playground.ipynb

@@ -0,0 +1,46 @@
+from leetcode_py import ListNode
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+    def reverse_list(self, head: ListNode[int] | None) -> ListNode[int] | None:
+        if not head:
+            return None
+
+        # Iterative approach using three pointers
+        # Example: [1,2,3] -> [3,2,1]
+        #
+        # Initial: prev curr
+        #          None  ↓
+        #                1 -> 2 -> 3 -> None
+        #
+        prev: ListNode[int] | None = None
+        curr: ListNode[int] | None = head
+
+        while curr:
+            # Store next node before breaking the link
+            next_node = curr.next
+            #
+            #         prev curr next_node
+            #         None  ↓    ↓
+            #               1 -> 2 -> 3 -> None
+            #
+
+            # Reverse the current link
+            curr.next = prev
+            #         None <- 1    2 -> 3 -> None
+            #         prev   curr  next_node
+            #
+
+            # Move pointers forward
+            prev = curr
+            curr = next_node
+            #                1 <- 2    3 -> None
+            #                    prev curr
+            #
+
+        #                1 <- 2 <- 3   None
+        #                         prev curr
+        # prev now points to new head of reversed list
+        return prev

leetcode/reverse_linked_list/solution.py

@@ -0,0 +1,44 @@
+import pytest
+
+from leetcode_py import ListNode
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestReverseLinkedList:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "head_list, expected_list",
+        [
+            ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]),  # Basic case
+            ([1, 2], [2, 1]),  # Two nodes
+            ([1], [1]),  # Single node
+            ([], []),  # Empty list
+            ([1, 2, 3], [3, 2, 1]),  # Odd length
+            ([1, 2, 3, 4], [4, 3, 2, 1]),  # Even length
+            ([-1, -2, -3], [-3, -2, -1]),  # Negative values
+            ([0], [0]),  # Zero value
+            ([5000, -5000], [-5000, 5000]),  # Boundary values
+            ([1, 1, 1], [1, 1, 1]),  # Duplicate values
+        ],
+    )
+    @logged_test
+    def test_reverse_list(self, head_list: list[int], expected_list: list[int]):
+        # Convert input list to linked list structure
+        # e.g., [1,2,3] -> 1->2->3->None
+        head = ListNode.from_list(head_list)
+
+        # Convert expected result list to linked list for comparison
+        # e.g., [3,2,1] -> 3->2->1->None
+        expected = ListNode.from_list(expected_list)
+
+        # Call the reverse_list method to reverse the linked list
+        # This should transform 1->2->3->None into 3->2->1->None
+        result = self.solution.reverse_list(head)
+
+        # Verify that the reversed linked list matches expected output
+        # ListNode supports direct equality comparison
+        assert result == expected