feat: add more problems

Author: wislertt

.templates/leetcode/json/k_closest_points_to_origin.json

@@ -0,0 +1,47 @@
+{
+    "problem_name": "k_closest_points_to_origin",
+    "solution_class_name": "Solution",
+    "problem_number": "973",
+    "problem_title": "K Closest Points to Origin",
+    "difficulty": "Medium",
+    "topics": "Array, Math, Divide and Conquer, Geometry, Sorting, Heap (Priority Queue), Quickselect",
+    "tags": ["grind-75"],
+    "readme_description": "Given an array of `points` where `points[i] = [xi, yi]` represents a point on the **X-Y** plane and an integer `k`, return the `k` closest points to the origin `(0, 0)`.\n\nThe distance between two points on the **X-Y** plane is the Euclidean distance (i.e., `\u221a(x1 - x2)\u00b2 + (y1 - y2)\u00b2`).\n\nYou may return the answer in **any order**. The answer is **guaranteed** to be **unique** (except for the order that it is in).",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg)\n\n```\nInput: points = [[1,3],[-2,2]], k = 1\nOutput: [[-2,2]]\n```\n**Explanation:** The distance between (1, 3) and the origin is sqrt(10). The distance between (-2, 2) and the origin is sqrt(8). Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin. We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]]."
+        },
+        {
+            "content": "```\nInput: points = [[3,3],[5,-1],[-2,4]], k = 2\nOutput: [[3,3],[-2,4]]\n```\n**Explanation:** The answer [[-2,4],[3,3]] would also be accepted."
+        }
+    ],
+    "readme_constraints": "- `1 <= k <= points.length <= 10^4`\n- `-10^4 <= xi, yi <= 10^4`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "k_closest",
+            "parameters": "points: list[list[int]], k: int",
+            "return_type": "list[list[int]]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "KClosestPointsToOrigin",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_k_closest",
+            "parametrize": "points, k, expected",
+            "parametrize_typed": "points: list[list[int]], k: int, expected: list[list[int]]",
+            "test_cases": "[([[1, 3], [-2, 2]], 1, [[-2, 2]]), ([[3, 3], [5, -1], [-2, 4]], 2, [[3, 3], [-2, 4]]), ([[0, 1], [1, 0]], 2, [[0, 1], [1, 0]]), ([[1, 1], [1, 1], [1, 1]], 2, [[1, 1], [1, 1]])]",
+            "body": "result = self.solution.k_closest(points, k)\n# Sort both result and expected for comparison since order doesn't matter\nresult_sorted = sorted(result)\nexpected_sorted = sorted(expected)\nassert result_sorted == expected_sorted"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\npoints = [[1, 3], [-2, 2]]\nk = 1\nexpected = [[-2, 2]]",
+    "playground_execution": "result = Solution().k_closest(points, k)\nresult",
+    "playground_assertion": "assert sorted(result) == sorted(expected)"
+}

.templates/leetcode/json/linked_list_cycle.json

@@ -5,7 +5,7 @@
     "problem_title": "Linked List Cycle",
     "difficulty": "Easy",
     "topics": "Hash Table, Linked List, Two Pointers",
-    "tags": [],
+    "tags": ["grind-75"],
     "readme_description": "Given `head`, the head of a linked list, determine if the linked list has a cycle in it.\n\nThere is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. **Note that `pos` is not passed as a parameter**.\n\nReturn `true` *if there is a cycle in the linked list*. Otherwise, return `false`.",
     "readme_examples": [
         {

.templates/leetcode/json/maximum_subarray.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "maximum_subarray",
+    "solution_class_name": "Solution",
+    "problem_number": "53",
+    "problem_title": "Maximum Subarray",
+    "difficulty": "Medium",
+    "topics": "Array, Divide and Conquer, Dynamic Programming",
+    "tags": ["grind-75"],
+    "readme_description": "Given an integer array `nums`, find the subarray with the largest sum, and return its sum.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: nums = [-2,1,-3,4,-1,2,1,-5,4]\nOutput: 6\n```\n**Explanation:** The subarray [4,-1,2,1] has the largest sum 6."
+        },
+        {
+            "content": "```\nInput: nums = [1]\nOutput: 1\n```\n**Explanation:** The subarray [1] has the largest sum 1."
+        },
+        {
+            "content": "```\nInput: nums = [5,4,-1,7,8]\nOutput: 23\n```\n**Explanation:** The subarray [5,4,-1,7,8] has the largest sum 23."
+        }
+    ],
+    "readme_constraints": "- `1 <= nums.length <= 10^5`\n- `-10^4 <= nums[i] <= 10^4`",
+    "readme_additional": "**Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "max_sub_array",
+            "parameters": "nums: list[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": "MaximumSubarray",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_max_sub_array",
+            "parametrize": "nums, expected",
+            "parametrize_typed": "nums: list[int], expected: int",
+            "test_cases": "[([-2, 1, -3, 4, -1, 2, 1, -5, 4], 6), ([1], 1), ([5, 4, -1, 7, 8], 23), ([-1], -1), ([-2, -1], -1), ([1, 2, 3, 4, 5], 15), ([-5, -2, -8, -1], -1)]",
+            "body": "result = self.solution.max_sub_array(nums)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nnums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]\nexpected = 6",
+    "playground_execution": "result = Solution().max_sub_array(nums)\nresult",
+    "playground_assertion": "assert result == expected"
+}

.templates/leetcode/json/reverse_linked_list_ii.json

@@ -5,7 +5,7 @@
     "problem_title": "Reverse Linked List II",
     "difficulty": "Medium",
     "topics": "Linked List",
-    "tags": ["grind-75"],
+    "tags": [],
     "readme_description": "Given the `head` of a singly linked list and two integers `left` and `right` where `left <= right`, reverse the nodes of the list from position `left` to position `right`, and return the reversed list.",
     "readme_examples": [
         { "content": "```\nInput: head = [1,2,3,4,5], left = 2, right = 4\nOutput: [1,4,3,2,5]\n```" },

.templates/leetcode/json/valid_palindrome.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "valid_palindrome",
+    "solution_class_name": "Solution",
+    "problem_number": "125",
+    "problem_title": "Valid Palindrome",
+    "difficulty": "Easy",
+    "topics": "Two Pointers, String",
+    "tags": ["grind-75"],
+    "readme_description": "A phrase is a **palindrome** if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.\n\nGiven a string `s`, return `true` if it is a **palindrome**, or `false` otherwise.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: s = \"A man, a plan, a canal: Panama\"\nOutput: true\n```\n**Explanation:** \"amanaplanacanalpanama\" is a palindrome."
+        },
+        {
+            "content": "```\nInput: s = \"race a car\"\nOutput: false\n```\n**Explanation:** \"raceacar\" is not a palindrome."
+        },
+        {
+            "content": "```\nInput: s = \" \"\nOutput: true\n```\n**Explanation:** s is an empty string \"\" after removing non-alphanumeric characters. Since an empty string reads the same forward and backward, it is a palindrome."
+        }
+    ],
+    "readme_constraints": "- `1 <= s.length <= 2 * 10^5`\n- `s` consists only of printable ASCII characters.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "is_palindrome",
+            "parameters": "s: str",
+            "return_type": "bool",
+            "dummy_return": "False"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "ValidPalindrome",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_is_palindrome",
+            "parametrize": "s, expected",
+            "parametrize_typed": "s: str, expected: bool",
+            "test_cases": "[(\"A man, a plan, a canal: Panama\", True), (\"race a car\", False), (\" \", True), (\"\", True), (\"a\", True), (\"Madam\", True), (\"No 'x' in Nixon\", True), (\"Mr. Owl ate my metal worm\", True)]",
+            "body": "result = self.solution.is_palindrome(s)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ns = \"A man, a plan, a canal: Panama\"\nexpected = True",
+    "playground_execution": "result = Solution().is_palindrome(s)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= linked_list_cycle
+PROBLEM ?= k_closest_points_to_origin
 FORCE ?= 0
 
 sync_submodules:

leetcode/k_closest_points_to_origin/README.md

@@ -0,0 +1,42 @@
+# K Closest Points to Origin
+
+**Difficulty:** Medium
+**Topics:** Array, Math, Divide and Conquer, Geometry, Sorting, Heap (Priority Queue), Quickselect
+**Tags:** grind-75
+
+**LeetCode:** [Problem 973](https://leetcode.com/problems/k-closest-points-to-origin/description/)
+
+## Problem Description
+
+Given an array of `points` where `points[i] = [xi, yi]` represents a point on the **X-Y** plane and an integer `k`, return the `k` closest points to the origin `(0, 0)`.
+
+The distance between two points on the **X-Y** plane is the Euclidean distance (i.e., `√(x1 - x2)² + (y1 - y2)²`).
+
+You may return the answer in **any order**. The answer is **guaranteed** to be **unique** (except for the order that it is in).
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg)
+
+```
+Input: points = [[1,3],[-2,2]], k = 1
+Output: [[-2,2]]
+```
+
+**Explanation:** The distance between (1, 3) and the origin is sqrt(10). The distance between (-2, 2) and the origin is sqrt(8). Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin. We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].
+
+### Example 2:
+
+```
+Input: points = [[3,3],[5,-1],[-2,4]], k = 2
+Output: [[3,3],[-2,4]]
+```
+
+**Explanation:** The answer [[-2,4],[3,3]] would also be accepted.
+
+## Constraints
+
+- `1 <= k <= points.length <= 10^4`
+- `-10^4 <= xi, yi <= 10^4`

leetcode/k_closest_points_to_origin/__init__.py

@@ -0,0 +1,57 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": ["from solution import Solution"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": ["# Example test case\npoints = [[1, 3], [-2, 2]]\nk = 1\nexpected = [[-2, 2]]"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": ["result = Solution().k_closest(points, k)\nresult"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": ["assert sorted(result) == sorted(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/k_closest_points_to_origin/playground.ipynb

@@ -0,0 +1,16 @@
+import heapq
+
+
+class Solution:
+    # Time: O(n log k)
+    # Space: O(k)
+    def k_closest(self, points: list[list[int]], k: int) -> list[list[int]]:
+        heap: list[tuple[int, list[int]]] = []
+
+        for x, y in points:
+            dist = x * x + y * y
+            heapq.heappush(heap, (-dist, [x, y]))
+            if len(heap) > k:
+                heapq.heappop(heap)
+
+        return [point for _, point in heap]