feat: add more problems

Author: wislertt

.templates/leetcode/json/kth_smallest_element_in_a_bst.json

@@ -5,7 +5,7 @@
     "problem_title": "Kth Smallest Element in a BST",
     "difficulty": "Medium",
     "topics": "Tree, Depth-First Search, Binary Search Tree, Binary Tree",
-    "tags": [],
+    "tags": ["grind-75"],
     "readme_description": "Given the `root` of a binary search tree, and an integer `k`, return the `k`th smallest value (1-indexed) of all the values of the nodes in the tree.",
     "readme_examples": [
         {

.templates/leetcode/json/minimum_window_substring.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "minimum_window_substring",
+    "solution_class_name": "Solution",
+    "problem_number": "76",
+    "problem_title": "Minimum Window Substring",
+    "difficulty": "Hard",
+    "topics": "Hash Table, String, Sliding Window",
+    "tags": ["grind-75", "neetcode-150"],
+    "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": [
+        {
+            "content": "```\nInput: s = \"ADOBECODEBANC\", t = \"ABC\"\nOutput: \"BANC\"\n```\n**Explanation:** The minimum window substring \"BANC\" includes 'A', 'B', and 'C' from string t."
+        },
+        {
+            "content": "```\nInput: s = \"a\", t = \"a\"\nOutput: \"a\"\n```\n**Explanation:** The entire string s is the minimum window."
+        },
+        {
+            "content": "```\nInput: s = \"a\", t = \"aa\"\nOutput: \"\"\n```\n**Explanation:** Both 'a's from t must be included in the window. Since the largest window of s only has one 'a', return empty string."
+        }
+    ],
+    "readme_constraints": "- `m == s.length`\n- `n == t.length`\n- `1 <= m, n <= 10^5`\n- `s` and `t` consist of uppercase and lowercase English letters.",
+    "readme_additional": "**Follow up:** Could you find an algorithm that runs in `O(m + n)` time?",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "min_window",
+            "parameters": "s: str, t: str",
+            "return_type": "str",
+            "dummy_return": "\"\""
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "MinimumWindowSubstring",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_min_window",
+            "parametrize": "s, t, expected",
+            "parametrize_typed": "s: str, t: str, expected: str",
+            "test_cases": "[(\"ADOBECODEBANC\", \"ABC\", \"BANC\"), (\"a\", \"a\", \"a\"), (\"a\", \"aa\", \"\")]",
+            "body": "result = self.solution.min_window(s, t)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ns = \\\"ADOBECODEBANC\\\"\nt = \\\"ABC\\\"\nexpected = \\\"BANC\\\"",
+    "playground_execution": "result = Solution().min_window(s, t)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

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

leetcode/kth_smallest_element_in_a_bst/README.md

@@ -2,7 +2,7 @@
 
 **Difficulty:** Medium
 **Topics:** Tree, Depth-First Search, Binary Search Tree, Binary Tree
-**Tags:**
+**Tags:** grind-75
 
 **LeetCode:** [Problem 230](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
 

leetcode/minimum_window_substring/README.md

@@ -0,0 +1,51 @@
+# Minimum Window Substring
+
+**Difficulty:** Hard
+**Topics:** Hash Table, String, Sliding Window
+**Tags:** grind-75, neetcode-150
+
+**LeetCode:** [Problem 76](https://leetcode.com/problems/minimum-window-substring/description/)
+
+## Problem 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 `""`.
+
+The testcases will be generated such that the answer is unique.
+
+## Examples
+
+### Example 1:
+
+```
+Input: s = "ADOBECODEBANC", t = "ABC"
+Output: "BANC"
+```
+
+**Explanation:** The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
+
+### Example 2:
+
+```
+Input: s = "a", t = "a"
+Output: "a"
+```
+
+**Explanation:** The entire string s is the minimum window.
+
+### Example 3:
+
+```
+Input: s = "a", t = "aa"
+Output: ""
+```
+
+**Explanation:** Both 'a's from t must be included in the window. Since the largest window of s only has one 'a', return empty string.
+
+## Constraints
+
+- `m == s.length`
+- `n == t.length`
+- `1 <= m, n <= 10^5`
+- `s` and `t` consist of uppercase and lowercase English letters.
+
+**Follow up:** Could you find an algorithm that runs in `O(m + n)` time?

leetcode/minimum_window_substring/__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",
+    "s = \"ADOBECODEBANC\"\n",
+    "t = \"ABC\"\n",
+    "expected = \"BANC\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'BANC'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().min_window(s, t)\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
+}

leetcode/minimum_window_substring/playground.ipynb

@@ -0,0 +1,48 @@
+from collections import Counter
+
+
+class Solution:
+    # Sliding Window
+    # Time: O(m + n) where m = len(s), n = len(t)
+    # Space: O(k) where k is unique chars in t
+    def min_window(self, s: str, t: str) -> str:
+        if not t or len(t) > len(s):
+            return ""
+
+        need = Counter(t)
+
+        left = 0
+        formed = 0
+        required = len(need)
+        window_counts: dict[str, int] = {}
+
+        # Result: (window length, left, right)
+        ans: tuple[float, int | None, int | None] = (float("inf"), None, None)
+
+        for right in range(len(s)):
+            char = s[right]
+            window_counts[char] = window_counts.get(char, 0) + 1
+
+            # Check if current char frequency matches desired frequency in t
+            if char in need and window_counts[char] == need[char]:
+                formed += 1
+
+            # Contract window until it's no longer valid
+            while left <= right and formed == required:
+                char = s[left]
+
+                # Update result if this window is smaller
+                if right - left + 1 < ans[0]:
+                    ans = (right - left + 1, left, right)
+
+                # Remove from left
+                window_counts[char] -= 1
+                if char in need and window_counts[char] < need[char]:
+                    formed -= 1
+
+                left += 1
+
+        if ans[0] == float("inf"):
+            return ""
+        assert ans[1] is not None and ans[2] is not None
+        return s[ans[1] : ans[2] + 1]

leetcode/minimum_window_substring/solution.py

@@ -0,0 +1,39 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestMinimumWindowSubstring:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "s, t, expected",
+        [
+            # Basic cases
+            ("ADOBECODEBANC", "ABC", "BANC"),
+            ("a", "a", "a"),
+            ("a", "aa", ""),
+            # Edge cases
+            ("", "a", ""),  # Empty s
+            ("a", "", ""),  # Empty t
+            ("", "", ""),  # Both empty
+            ("ab", "ba", "ab"),  # Same length
+            ("abc", "cba", "abc"),  # Entire string needed
+            # Duplicates
+            ("ADOBECODEBANC", "AABC", "ADOBECODEBA"),  # Correct: needs 2 A's, 1 B, 1 C
+            ("aa", "aa", "aa"),
+            # No solution
+            ("abc", "def", ""),
+            ("a", "b", ""),
+            # Multiple valid windows
+            ("ADOBECODEBANC", "AB", "BA"),  # Correct: "BA" is shorter than "ADOB"
+            ("abcdef", "cf", "cdef"),
+        ],
+    )
+    @logged_test
+    def test_min_window(self, s: str, t: str, expected: str):
+        result = self.solution.min_window(s, t)
+        assert result == expected