feat: add 10 more leetcode problems

Author: wislertt

.claude/.dev/problem_lists/unscrapable.py

@@ -8,6 +8,7 @@
     (253, "meeting-rooms-ii"),
     (261, "graph-valid-tree"),
     (271, "encode-and-decode-strings"),
+    (286, "walls-and-gates"),
     (323, "number-of-connected-components-in-an-undirected-graph"),
     (437, "path-sum-iii"),  # Causing issues with next_problem.py - prefer manual creation
     # Add more unscrapable problems as discovered

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/README.md

@@ -0,0 +1,40 @@
+# Best Time to Buy and Sell Stock with Cooldown
+
+**Difficulty:** Medium
+**Topics:** Array, Dynamic Programming
+**Tags:** neetcode-150
+
+**LeetCode:** [Problem 309](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+
+## Problem Description
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:
+
+- After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+## Examples
+
+### Example 1:
+
+```
+Input: prices = [1,2,3,0,2]
+Output: 3
+```
+
+**Explanation:** transactions = [buy, sell, cooldown, buy, sell]
+
+### Example 2:
+
+```
+Input: prices = [1]
+Output: 0
+```
+
+## Constraints
+
+- 1 <= prices.length <= 5000
+- 0 <= prices[i] <= 1000

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/__init__.py

@@ -0,0 +1,8 @@
+def run_max_profit(solution_class: type, prices: list[int]):
+    implementation = solution_class()
+    return implementation.max_profit(prices)
+
+
+def assert_max_profit(result: int, expected: int) -> bool:
+    assert result == expected
+    return True

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/helpers.py

@@ -0,0 +1,29 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_max_profit, run_max_profit
+from solution import Solution
+
+# %%
+# Example test case
+prices = [1, 2, 3, 0, 2]
+expected = 3
+
+# %%
+result = run_max_profit(Solution, prices)
+result
+
+# %%
+assert_max_profit(result, expected)

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/playground.py

@@ -0,0 +1,14 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+    def max_profit(self, prices: list[int]) -> int:
+        # State machine: held (own stock), sold (just sold -> cooldown), reset (no stock)
+        held = float("-inf")
+        sold = float("-inf")
+        reset = 0
+        for price in prices:
+            prev_held, prev_sold, prev_reset = held, sold, reset
+            held = max(prev_held, prev_reset - price)
+            reset = max(prev_reset, prev_sold)
+            sold = prev_held + price
+        return int(max(sold, reset))

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/solution.py

@@ -0,0 +1,35 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_max_profit, run_max_profit
+from .solution import Solution
+
+
+class TestBestTimeToBuyAndSellStockWithCooldown:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "prices, expected",
+        [
+            ([1, 2, 3, 0, 2], 3),
+            ([1], 0),
+            ([1, 2], 1),
+            ([3, 2, 1], 0),
+            ([1, 2, 3], 2),
+            ([1, 2, 4], 3),
+            ([2, 4, 1], 2),
+            ([1, 4, 2], 3),
+            ([1, 2, 3, 0, 2, 5], 6),
+            ([6, 1, 6, 4, 2, 0, 1], 6),
+            ([5], 0),
+            ([1, 2, 3, 4, 5], 4),
+            ([1, 3, 1, 4], 3),
+            ([2, 1], 0),
+        ],
+    )
+    def test_max_profit(self, prices: list[int], expected: int):
+        result = run_max_profit(Solution, prices)
+        assert_max_profit(result, expected)

leetcode/best_time_to_buy_and_sell_stock_with_cooldown/test_solution.py

@@ -0,0 +1,41 @@
+# Burst Balloons
+
+**Difficulty:** Hard
+**Topics:** Array, Dynamic Programming
+**Tags:** neetcode-150
+
+**LeetCode:** [Problem 312](https://leetcode.com/problems/burst-balloons/description/)
+
+## Problem Description
+
+You are given `n` balloons, indexed from `0` to `n - 1`. Each balloon is painted with a number on it represented by an array `nums`. You are asked to burst all the balloons.
+
+If you burst the `ith` balloon, you will get `nums[i - 1] * nums[i] * nums[i + 1]` coins. If `i - 1` or `i + 1` goes out of bounds of the array, then treat it as if there is a balloon with a `1` painted on it.
+
+Return _the maximum coins you can collect by bursting the balloons wisely_.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [3,1,5,8]
+Output: 167
+```
+
+**Explanation:**
+nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
+coins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167
+
+### Example 2:
+
+```
+Input: nums = [1,5]
+Output: 10
+```
+
+## Constraints
+
+- n == nums.length
+- 1 <= n <= 300
+- 0 <= nums[i] <= 100

leetcode/burst_balloons/README.md

@@ -0,0 +1,8 @@
+def run_max_coins(solution_class: type, nums: list[int]):
+    implementation = solution_class()
+    return implementation.max_coins(nums)
+
+
+def assert_max_coins(result: int, expected: int) -> bool:
+    assert result == expected
+    return True