feat: add more questions

Author: wislertt

.templates/leetcode/json/minimum_window_substring.json

@@ -5,7 +5,7 @@
     "problem_title": "Minimum Window Substring",
     "difficulty": "Hard",
     "topics": "Hash Table, String, Sliding Window",
-    "tags": ["grind-75", "neetcode-150"],
+    "tags": ["grind-75"],
     "readme_description": "Given two strings `s` and `t` of lengths `m` and `n` respectively, return the **minimum window substring** of `s` such that every character in `t` (including duplicates) is included in the window. If there is no such substring, return the empty string `\"\"`.\n\nThe testcases will be generated such that the answer is unique.",
     "readme_examples": [
         {

.templates/leetcode/json/search_in_rotated_sorted_array.json

@@ -0,0 +1,44 @@
+{
+    "problem_name": "search_in_rotated_sorted_array",
+    "solution_class_name": "Solution",
+    "problem_number": "33",
+    "problem_title": "Search in Rotated Sorted Array",
+    "difficulty": "Medium",
+    "topics": "Array, Binary Search",
+    "tags": ["grind-75"],
+    "readme_description": "There is an integer array `nums` sorted in ascending order (with **distinct** values).\n\nPrior to being passed to your function, `nums` is **possibly left rotated** at an unknown index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be left rotated by 3 indices and become `[4,5,6,7,0,1,2]`.\n\nGiven the array `nums` **after** the possible rotation and an integer `target`, return *the index of* `target` *if it is in* `nums`*, or* `-1` *if it is not in* `nums`.\n\nYou must write an algorithm with `O(log n)` runtime complexity.",
+    "readme_examples": [
+        { "content": "```\nInput: nums = [4,5,6,7,0,1,2], target = 0\nOutput: 4\n```" },
+        { "content": "```\nInput: nums = [4,5,6,7,0,1,2], target = 3\nOutput: -1\n```" },
+        { "content": "```\nInput: nums = [1], target = 0\nOutput: -1\n```" }
+    ],
+    "readme_constraints": "- `1 <= nums.length <= 5000`\n- `-10^4 <= nums[i] <= 10^4`\n- All values of `nums` are **unique**.\n- `nums` is an ascending array that is possibly rotated.\n- `-10^4 <= target <= 10^4`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "search",
+            "parameters": "nums: list[int], target: int",
+            "return_type": "int",
+            "dummy_return": "-1"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "SearchInRotatedSortedArray",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_search",
+            "parametrize": "nums, target, expected",
+            "parametrize_typed": "nums: list[int], target: int, expected: int",
+            "test_cases": "[([4, 5, 6, 7, 0, 1, 2], 0, 4), ([4, 5, 6, 7, 0, 1, 2], 3, -1), ([1], 0, -1), ([1], 1, 0), ([3, 1], 1, 1)]",
+            "body": "result = self.solution.search(nums, target)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nnums = [4, 5, 6, 7, 0, 1, 2]\ntarget = 0\nexpected = 4",
+    "playground_execution": "result = Solution().search(nums, target)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= minimum_window_substring
+PROBLEM ?= search_in_rotated_sorted_array
 FORCE ?= 0
 
 sync_submodules:

leetcode/container_with_most_water/tests.py

@@ -10,7 +10,29 @@ def setup_method(self):
         self.solution = Solution()
 
     @pytest.mark.parametrize(
-        "height, expected", [([1, 8, 6, 2, 5, 4, 8, 3, 7], 49), ([1, 1], 1), ([1, 2, 1], 2)]
+        "height, expected",
+        [
+            # Original cases
+            ([1, 8, 6, 2, 5, 4, 8, 3, 7], 49),
+            ([1, 1], 1),
+            ([1, 2, 1], 2),
+            # Edge cases
+            ([2, 1], 1),
+            ([1, 2], 1),
+            ([0, 2], 0),
+            ([2, 0], 0),
+            # Increasing heights
+            ([1, 2, 3, 4, 5], 6),
+            # Decreasing heights
+            ([5, 4, 3, 2, 1], 6),
+            # Same heights
+            ([3, 3, 3, 3], 9),
+            # Large differences
+            ([1, 1000, 1], 2),
+            ([1000, 1, 1000], 2000),
+            # Multiple peaks
+            ([2, 3, 4, 5, 18, 17, 6], 17),
+        ],
     )
     @logged_test
     def test_max_area(self, height: list[int], expected: int):

leetcode/evaluate_reverse_polish_notation/tests.py

@@ -12,9 +12,24 @@ def setup_method(self):
     @pytest.mark.parametrize(
         "tokens, expected",
         [
+            # Original cases
             (["2", "1", "+", "3", "*"], 9),
             (["4", "13", "5", "/", "+"], 6),
             (["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"], 22),
+            # Single number
+            (["42"], 42),
+            # Negative numbers
+            (["-1"], -1),
+            (["1", "-1", "+"], 0),
+            # Basic operations
+            (["3", "4", "+"], 7),
+            (["5", "2", "-"], 3),
+            (["6", "3", "*"], 18),
+            (["8", "2", "/"], 4),
+            # Division with negatives
+            (["-3", "4", "+", "2", "*", "1", "-"], 1),
+            # Complex expression
+            (["15", "7", "1", "1", "+", "/", "/", "3", "*", "2", "1", "1", "+", "+", "-"], 11),
         ],
     )
     @logged_test

leetcode/insert_interval/tests.py

@@ -12,8 +12,25 @@ def setup_method(self):
     @pytest.mark.parametrize(
         "intervals, new_interval, expected",
         [
+            # Original cases
             ([[1, 3], [6, 9]], [2, 5], [[1, 5], [6, 9]]),
             ([[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]], [4, 8], [[1, 2], [3, 10], [12, 16]]),
+            # Empty intervals
+            ([], [5, 7], [[5, 7]]),
+            # Insert at beginning
+            ([[3, 5], [6, 9]], [1, 2], [[1, 2], [3, 5], [6, 9]]),
+            # Insert at end
+            ([[1, 3], [6, 9]], [10, 12], [[1, 3], [6, 9], [10, 12]]),
+            # No overlap
+            ([[1, 2], [4, 5]], [3, 3], [[1, 2], [3, 3], [4, 5]]),
+            # Complete overlap
+            ([[1, 5]], [2, 3], [[1, 5]]),
+            # Merge all intervals
+            ([[1, 2], [3, 4], [5, 6]], [0, 7], [[0, 7]]),
+            # Adjacent intervals
+            ([[1, 3], [6, 9]], [4, 5], [[1, 3], [4, 5], [6, 9]]),
+            # Touch boundaries
+            ([[1, 3], [6, 9]], [3, 6], [[1, 9]]),
         ],
     )
     @logged_test

leetcode/minimum_window_substring/README.md

@@ -2,7 +2,7 @@
 
 **Difficulty:** Hard
 **Topics:** Hash Table, String, Sliding Window
-**Tags:** grind-75, neetcode-150
+**Tags:** grind-75
 
 **LeetCode:** [Problem 76](https://leetcode.com/problems/minimum-window-substring/description/)
 

leetcode/search_in_rotated_sorted_array/README.md

@@ -0,0 +1,48 @@
+# Search in Rotated Sorted Array
+
+**Difficulty:** Medium
+**Topics:** Array, Binary Search
+**Tags:** grind-75
+
+**LeetCode:** [Problem 33](https://leetcode.com/problems/search-in-rotated-sorted-array/description/)
+
+## Problem Description
+
+There is an integer array `nums` sorted in ascending order (with **distinct** values).
+
+Prior to being passed to your function, `nums` is **possibly left rotated** at an unknown index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be left rotated by 3 indices and become `[4,5,6,7,0,1,2]`.
+
+Given the array `nums` **after** the possible rotation and an integer `target`, return _the index of_ `target` _if it is in_ `nums`_, or_ `-1` _if it is not in_ `nums`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+```
+
+### Example 2:
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 3
+Output: -1
+```
+
+### Example 3:
+
+```
+Input: nums = [1], target = 0
+Output: -1
+```
+
+## Constraints
+
+- `1 <= nums.length <= 5000`
+- `-10^4 <= nums[i] <= 10^4`
+- All values of `nums` are **unique**.
+- `nums` is an ascending array that is possibly rotated.
+- `-10^4 <= target <= 10^4`

leetcode/search_in_rotated_sorted_array/__init__.py

@@ -0,0 +1,80 @@
+{
+ "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",
+    "nums = [4, 5, 6, 7, 0, 1, 2]\n",
+    "target = 0\n",
+    "expected = 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().search(nums, target)\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
+}