feat: add 5 more leetcode problems

Author: wisarootl

.cursor/commands/test-quality-assurance.md

@@ -21,8 +21,8 @@ make p-gen PROBLEM={problem_name} FORCE=1
 # Step 3: Restore original solution ONLY
 cp leetcode/{problem_name}_backup/solution.py leetcode/{problem_name}/solution.py
 
-# Step 4: Verify mypy passes (CRITICAL for CI)
-poetry run mypy leetcode/{problem_name}/test_solution.py --explicit-package-bases --install-types --non-interactive --check-untyped-defs
+# Step 4: Verify linting pass (CRITICAL for CI)
+make p-lint PROBLEM={problem_name}
 
 # Step 5: Verify tests pass (expected to fail if solution is incomplete)
 make p-test PROBLEM={problem_name}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= top_k_frequent_elements
+PROBLEM ?= palindromic_substrings
 FORCE ?= 0
 COMMA := ,
 

leetcode/longest_repeating_character_replacement/README.md

@@ -0,0 +1,39 @@
+# Longest Repeating Character Replacement
+
+**Difficulty:** Medium
+**Topics:** Hash Table, String, Sliding Window
+**Tags:** blind-75
+
+**LeetCode:** [Problem 424](https://leetcode.com/problems/longest-repeating-character-replacement/description/)
+
+## Problem Description
+
+You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.
+
+Return the length of the longest substring containing the same letter you can get after performing the above operations.
+
+## Examples
+
+### Example 1:
+
+```
+Input: s = "ABAB", k = 2
+Output: 4
+Explanation: Replace the two 'A's with two 'B's or vice versa.
+```
+
+### Example 2:
+
+```
+Input: s = "AABABBA", k = 1
+Output: 4
+Explanation: Replace the one 'A' in the middle with 'B' and form "AABBBBA".
+The substring "BBBB" has the longest repeating letters, which is 4.
+There may exists other ways to achieve this answer too.
+```
+
+## Constraints
+
+1 <= s.length <= 10^5
+s consists of only uppercase English letters.
+0 <= k <= s.length

leetcode/longest_repeating_character_replacement/__init__.py

@@ -0,0 +1,8 @@
+def run_character_replacement(solution_class: type, s: str, k: int):
+    implementation = solution_class()
+    return implementation.characterReplacement(s, k)
+
+
+def assert_character_replacement(result: int, expected: int) -> bool:
+    assert result == expected
+    return True

leetcode/longest_repeating_character_replacement/helpers.py

@@ -0,0 +1,30 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_character_replacement, run_character_replacement
+from solution import Solution
+
+# %%
+# Example test case
+s = "ABAB"
+k = 2
+expected = 4
+
+# %%
+result = run_character_replacement(Solution, s, k)
+result
+
+# %%
+assert_character_replacement(result, expected)

leetcode/longest_repeating_character_replacement/playground.py

@@ -0,0 +1,34 @@
+class Solution:
+
+    # Time: O(n) - single pass through string
+    # Space: O(1) - at most 26 characters in count dict
+    def characterReplacement(self, s: str, k: int) -> int:
+        """
+        Find the length of the longest substring with same character
+        after at most k replacements using sliding window approach.
+        """
+        if not s:
+            return 0
+
+        count: dict[str, int] = {}
+        left = 0
+        max_freq = 0
+        max_length = 0
+
+        for right in range(len(s)):
+            # Expand window: add character at right pointer
+            count[s[right]] = count.get(s[right], 0) + 1
+            max_freq = max(max_freq, count[s[right]])
+
+            # Shrink window if needed: if we need more than k replacements
+            # Current window size = right - left + 1
+            # Characters to replace = window_size - max_freq
+            # If characters_to_replace > k, we need to shrink
+            if (right - left + 1) - max_freq > k:
+                count[s[left]] -= 1
+                left += 1
+
+            # Update max length
+            max_length = max(max_length, right - left + 1)
+
+        return max_length

leetcode/longest_repeating_character_replacement/solution.py

@@ -0,0 +1,36 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_character_replacement, run_character_replacement
+from .solution import Solution
+
+
+class TestLongestRepeatingCharacterReplacement:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "s, k, expected",
+        [
+            ("ABAB", 2, 4),
+            ("AABABBA", 1, 4),
+            ("AAAA", 0, 4),
+            ("ABCDE", 0, 1),
+            ("ABCDE", 4, 5),
+            ("A", 0, 1),
+            ("A", 1, 1),
+            ("AAAB", 0, 3),
+            ("AAAB", 1, 4),
+            ("ABABAB", 2, 5),
+            ("ABABAB", 3, 6),
+            ("ABCDEF", 0, 1),
+            ("ABCDEF", 1, 2),
+            ("ABCDEF", 5, 6),
+            ("AABABBA", 2, 5),
+        ],
+    )
+    def test_character_replacement(self, s: str, k: int, expected: int):
+        result = run_character_replacement(Solution, s, k)
+        assert_character_replacement(result, expected)

leetcode/longest_repeating_character_replacement/test_solution.py

@@ -0,0 +1,45 @@
+# Non-overlapping Intervals
+
+**Difficulty:** Medium
+**Topics:** Array, Dynamic Programming, Greedy, Sorting
+**Tags:** blind-75
+
+**LeetCode:** [Problem 435](https://leetcode.com/problems/non-overlapping-intervals/description/)
+
+## Problem Description
+
+Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
+
+Note that intervals which only touch at a point are non-overlapping. For example, [1, 2] and [2, 3] are non-overlapping.
+
+## Examples
+
+### Example 1:
+
+```
+Input: intervals = [[1,2],[2,3],[3,4],[1,3]]
+Output: 1
+Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.
+```
+
+### Example 2:
+
+```
+Input: intervals = [[1,2],[1,2],[1,2]]
+Output: 2
+Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping.
+```
+
+### Example 3:
+
+```
+Input: intervals = [[1,2],[2,3]]
+Output: 0
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+```
+
+## Constraints
+
+1 <= intervals.length <= 10^5
+intervals[i].length == 2
+-5 _ 10^4 <= starti < endi <= 5 _ 10^4