feat: add Word Break

Author: wislertt

.templates/leetcode/json/sort_colors.json

@@ -0,0 +1,43 @@
+{
+    "problem_name": "sort_colors",
+    "solution_class_name": "Solution",
+    "problem_number": "75",
+    "problem_title": "Sort Colors",
+    "difficulty": "Medium",
+    "topics": "Array, Two Pointers, Sorting",
+    "tags": ["grind-75"],
+    "readme_description": "Given an array `nums` with `n` objects colored red, white, or blue, sort them **in-place** so that objects of the same color are adjacent, with the colors in the order red, white, and blue.\n\nWe will use the integers `0`, `1`, and `2` to represent the color red, white, and blue, respectively.\n\nYou must solve this problem without using the library's sort function.",
+    "readme_examples": [
+        { "content": "```\nInput: nums = [2,0,2,1,1,0]\nOutput: [0,0,1,1,2,2]\n```" },
+        { "content": "```\nInput: nums = [2,0,1]\nOutput: [0,1,2]\n```" }
+    ],
+    "readme_constraints": "- `n == nums.length`\n- `1 <= n <= 300`\n- `nums[i]` is either `0`, `1`, or `2`.",
+    "readme_additional": "**Follow up:** Could you come up with a one-pass algorithm using only constant extra space?",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "sort_colors",
+            "parameters": "nums: list[int]",
+            "return_type": "None",
+            "dummy_return": ""
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "SortColors",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_sort_colors",
+            "parametrize": "nums, expected",
+            "parametrize_typed": "nums: list[int], expected: list[int]",
+            "test_cases": "[([2, 0, 2, 1, 1, 0], [0, 0, 1, 1, 2, 2]), ([2, 0, 1], [0, 1, 2]), ([0], [0]), ([1], [1]), ([2], [2]), ([0, 1, 2], [0, 1, 2])]",
+            "body": "nums_copy = nums.copy()\nself.solution.sort_colors(nums_copy)\nassert nums_copy == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nnums = [2, 0, 2, 1, 1, 0]\nexpected = [0, 0, 1, 1, 2, 2]",
+    "playground_execution": "nums_copy = nums.copy()\nSolution().sort_colors(nums_copy)\nnums_copy",
+    "playground_assertion": "assert nums_copy == expected"
+}

.templates/leetcode/json/time_based_key_value_store.json

@@ -0,0 +1,49 @@
+{
+    "problem_name": "time_based_key_value_store",
+    "solution_class_name": "TimeMap",
+    "problem_number": "981",
+    "problem_title": "Time Based Key-Value Store",
+    "difficulty": "Medium",
+    "topics": "Hash Table, String, Binary Search, Design",
+    "tags": ["grind-75"],
+    "readme_description": "Design a time-based key-value data structure that can store multiple values for the same key at different time stamps and retrieve the key's value at a certain timestamp.\n\nImplement the `TimeMap` class:\n\n- `TimeMap()` Initializes the object of the data structure.\n- `void set(String key, String value, int timestamp)` Stores the key `key` with the value `value` at the given time `timestamp`.\n- `String get(String key, int timestamp)` Returns a value such that `set` was called previously, with `timestamp_prev <= timestamp`. If there are multiple such values, it returns the value associated with the largest `timestamp_prev`. If there are no values, it returns `\"\"`.",
+    "readme_examples": [
+        {
+            "content": "```\nInput\n[\"TimeMap\", \"set\", \"get\", \"get\", \"set\", \"get\", \"get\"]\n[[], [\"foo\", \"bar\", 1], [\"foo\", 1], [\"foo\", 3], [\"foo\", \"bar2\", 4], [\"foo\", 4], [\"foo\", 5]]\nOutput\n[null, null, \"bar\", \"bar\", null, \"bar2\", \"bar2\"]\n```\n\n**Explanation:**\n```\nTimeMap timeMap = new TimeMap();\ntimeMap.set(\"foo\", \"bar\", 1);  // store the key \"foo\" and value \"bar\" along with timestamp = 1.\ntimeMap.get(\"foo\", 1);         // return \"bar\"\ntimeMap.get(\"foo\", 3);         // return \"bar\", since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 is \"bar\".\ntimeMap.set(\"foo\", \"bar2\", 4); // store the key \"foo\" and value \"bar2\" along with timestamp = 4.\ntimeMap.get(\"foo\", 4);         // return \"bar2\"\ntimeMap.get(\"foo\", 5);         // return \"bar2\"\n```"
+        }
+    ],
+    "readme_constraints": "- `1 <= key.length, value.length <= 100`\n- `key` and `value` consist of lowercase English letters and digits.\n- `1 <= timestamp <= 10^7`\n- All the timestamps `timestamp` of `set` are strictly increasing.\n- At most `2 * 10^5` calls will be made to `set` and `get`.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        { "name": "__init__", "parameters": "", "return_type": "None", "dummy_return": "" },
+        {
+            "name": "set",
+            "parameters": "key: str, value: str, timestamp: int",
+            "return_type": "None",
+            "dummy_return": ""
+        },
+        {
+            "name": "get",
+            "parameters": "key: str, timestamp: int",
+            "return_type": "str",
+            "dummy_return": "\"\""
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import TimeMap",
+    "test_class_name": "TimeBasedKeyValueStore",
+    "test_helper_methods": [],
+    "test_methods": [
+        {
+            "name": "test_time_map_operations",
+            "parametrize": "operations, inputs, expected",
+            "parametrize_typed": "operations: list[str], inputs: list[list], expected: list",
+            "test_cases": "[(['TimeMap', 'set', 'get', 'get', 'set', 'get', 'get'], [[], ['foo', 'bar', 1], ['foo', 1], ['foo', 3], ['foo', 'bar2', 4], ['foo', 4], ['foo', 5]], [None, None, 'bar', 'bar', None, 'bar2', 'bar2'])]",
+            "body": "time_map: TimeMap | None = None\nresult: list[str | None] = []\nfor i, op in enumerate(operations):\n    if op == 'TimeMap':\n        time_map = TimeMap()\n        result.append(None)\n    elif op == 'set' and time_map is not None:\n        time_map.set(*inputs[i])\n        result.append(None)\n    elif op == 'get' and time_map is not None:\n        result.append(time_map.get(*inputs[i]))\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import TimeMap",
+    "playground_test_case": "# Example test case\ntime_map = TimeMap()\ntime_map.set('foo', 'bar', 1)\nresult1 = time_map.get('foo', 1)\nresult2 = time_map.get('foo', 3)\ntime_map.set('foo', 'bar2', 4)\nresult3 = time_map.get('foo', 4)\nresult4 = time_map.get('foo', 5)",
+    "playground_execution": "print(f'get(foo, 1): {result1}')\nprint(f'get(foo, 3): {result2}')\nprint(f'get(foo, 4): {result3}')\nprint(f'get(foo, 5): {result4}')",
+    "playground_assertion": "assert result1 == 'bar'\nassert result2 == 'bar'\nassert result3 == 'bar2'\nassert result4 == 'bar2'"
+}

.templates/leetcode/json/word_break.json

@@ -0,0 +1,50 @@
+{
+    "problem_name": "word_break",
+    "solution_class_name": "Solution",
+    "problem_number": "139",
+    "problem_title": "Word Break",
+    "difficulty": "Medium",
+    "topics": "Array, Hash Table, String, Dynamic Programming, Trie, Memoization",
+    "tags": ["grind-75"],
+    "readme_description": "Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.\n\n**Note** that the same word in the dictionary may be reused multiple times in the segmentation.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: s = \"leetcode\", wordDict = [\"leet\",\"code\"]\nOutput: true\n```\n**Explanation:** Return true because \"leetcode\" can be segmented as \"leet code\"."
+        },
+        {
+            "content": "```\nInput: s = \"applepenapple\", wordDict = [\"apple\",\"pen\"]\nOutput: true\n```\n**Explanation:** Return true because \"applepenapple\" can be segmented as \"apple pen apple\".\nNote that you are allowed to reuse a dictionary word."
+        },
+        {
+            "content": "```\nInput: s = \"catsandog\", wordDict = [\"cats\",\"dog\",\"sand\",\"and\",\"cat\"]\nOutput: false\n```"
+        }
+    ],
+    "readme_constraints": "- `1 <= s.length <= 300`\n- `1 <= wordDict.length <= 1000`\n- `1 <= wordDict[i].length <= 20`\n- `s` and `wordDict[i]` consist of only lowercase English letters.\n- All the strings of `wordDict` are **unique**.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "word_break",
+            "parameters": "s: str, word_dict: list[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": "WordBreak",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_word_break",
+            "parametrize": "s, word_dict, expected",
+            "parametrize_typed": "s: str, word_dict: list[str], expected: bool",
+            "test_cases": "[('leetcode', ['leet', 'code'], True), ('applepenapple', ['apple', 'pen'], True), ('catsandog', ['cats', 'dog', 'sand', 'and', 'cat'], False), ('', [], True), ('a', ['a'], True), ('ab', ['a', 'b'], True), ('abcd', ['a', 'abc', 'd'], True)]",
+            "body": "result = self.solution.word_break(s, word_dict)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ns = 'leetcode'\nword_dict = ['leet', 'code']\nexpected = True",
+    "playground_execution": "result = Solution().word_break(s, word_dict)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= permutations
+PROBLEM ?= word_break
 FORCE ?= 0
 COMMA := ,
 

leetcode/combination_sum/tests.py

@@ -24,6 +24,7 @@ def setup_method(self):
                 [
                     [2, 2, 2, 2, 2, 2, 2, 2, 2],
                     [2, 2, 2, 2, 2, 2, 3, 3],
+                    [2, 2, 2, 2, 3, 7],
                     [2, 2, 2, 3, 3, 3, 3],
                     [2, 2, 7, 7],
                     [2, 3, 3, 3, 7],

leetcode/sort_colors/README.md

@@ -0,0 +1,39 @@
+# Sort Colors
+
+**Difficulty:** Medium
+**Topics:** Array, Two Pointers, Sorting
+**Tags:** grind-75
+
+**LeetCode:** [Problem 75](https://leetcode.com/problems/sort-colors/description/)
+
+## Problem Description
+
+Given an array `nums` with `n` objects colored red, white, or blue, sort them **in-place** so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
+
+We will use the integers `0`, `1`, and `2` to represent the color red, white, and blue, respectively.
+
+You must solve this problem without using the library's sort function.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+```
+
+### Example 2:
+
+```
+Input: nums = [2,0,1]
+Output: [0,1,2]
+```
+
+## Constraints
+
+- `n == nums.length`
+- `1 <= n <= 300`
+- `nums[i]` is either `0`, `1`, or `2`.
+
+**Follow up:** Could you come up with a one-pass algorithm using only constant extra space?

leetcode/sort_colors/__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 = [2, 0, 2, 1, 1, 0]\n",
+    "expected = [0, 0, 1, 1, 2, 2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 0, 1, 1, 2, 2]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nums_copy = nums.copy()\n",
+    "Solution().sort_colors(nums_copy)\n",
+    "nums_copy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert nums_copy == 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/sort_colors/playground.ipynb

@@ -0,0 +1,19 @@
+class Solution:
+    # Dutch National Flag Algorithm - partitions array into 3 regions using 2 pointers
+    # Creates: [0s][1s][2s] with left/right boundaries, mid processes unvisited elements
+    # Time: O(n)
+    # Space: O(1)
+    def sort_colors(self, nums: list[int]) -> None:
+        left = mid = 0
+        right = len(nums) - 1
+
+        while mid <= right:
+            if nums[mid] == 0:
+                nums[left], nums[mid] = nums[mid], nums[left]
+                left += 1
+                mid += 1
+            elif nums[mid] == 1:
+                mid += 1
+            else:
+                nums[mid], nums[right] = nums[right], nums[mid]
+                right -= 1

leetcode/sort_colors/solution.py

@@ -0,0 +1,27 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestSortColors:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "nums, expected",
+        [
+            ([2, 0, 2, 1, 1, 0], [0, 0, 1, 1, 2, 2]),
+            ([2, 0, 1], [0, 1, 2]),
+            ([0], [0]),
+            ([1], [1]),
+            ([2], [2]),
+            ([0, 1, 2], [0, 1, 2]),
+        ],
+    )
+    @logged_test
+    def test_sort_colors(self, nums: list[int], expected: list[int]):
+        nums_copy = nums.copy()
+        self.solution.sort_colors(nums_copy)
+        assert nums_copy == expected