feat: add Permutations

Author: wislertt

.templates/leetcode/json/combination_sum.json

@@ -0,0 +1,48 @@
+{
+    "problem_name": "combination_sum",
+    "solution_class_name": "Solution",
+    "problem_number": "39",
+    "problem_title": "Combination Sum",
+    "difficulty": "Medium",
+    "topics": "Array, Backtracking",
+    "tags": ["grind-75"],
+    "readme_description": "Given an array of **distinct** integers `candidates` and a target integer `target`, return *a list of all **unique combinations** of* `candidates` *where the chosen numbers sum to* `target`. You may return the combinations in **any order**.\n\nThe **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.\n\nThe test cases are generated such that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: candidates = [2,3,6,7], target = 7\nOutput: [[2,2,3],[7]]\n```\n**Explanation:** 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. 7 is a candidate, and 7 = 7. These are the only two combinations."
+        },
+        {
+            "content": "```\nInput: candidates = [2,3,5], target = 8\nOutput: [[2,2,2,2],[2,3,3],[3,5]]\n```"
+        },
+        { "content": "```\nInput: candidates = [2], target = 1\nOutput: []\n```" }
+    ],
+    "readme_constraints": "- 1 <= candidates.length <= 30\n- 2 <= candidates[i] <= 40\n- All elements of candidates are distinct.\n- 1 <= target <= 40",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "combination_sum",
+            "parameters": "candidates: list[int], target: int",
+            "return_type": "list[list[int]]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "CombinationSum",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_combination_sum",
+            "parametrize": "candidates, target, expected",
+            "parametrize_typed": "candidates: list[int], target: int, expected: list[list[int]]",
+            "test_cases": "[([2, 3, 6, 7], 7, [[2, 2, 3], [7]]), ([2, 3, 5], 8, [[2, 2, 2, 2], [2, 3, 3], [3, 5]]), ([2], 1, [])]",
+            "body": "result = self.solution.combination_sum(candidates, target)\n# Sort both result and expected for comparison\nresult_sorted = [sorted(combo) for combo in result]\nexpected_sorted = [sorted(combo) for combo in expected]\nresult_sorted.sort()\nexpected_sorted.sort()\nassert result_sorted == expected_sorted"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ncandidates = [2, 3, 6, 7]\ntarget = 7\nexpected = [[2, 2, 3], [7]]",
+    "playground_execution": "result = Solution().combination_sum(candidates, target)\nresult",
+    "playground_assertion": "# Sort for comparison\nresult_sorted = [sorted(combo) for combo in result]\nexpected_sorted = [sorted(combo) for combo in expected]\nresult_sorted.sort()\nexpected_sorted.sort()\nassert result_sorted == expected_sorted"
+}

.templates/leetcode/json/permutations.json

@@ -0,0 +1,46 @@
+{
+    "problem_name": "permutations",
+    "solution_class_name": "Solution",
+    "problem_number": "46",
+    "problem_title": "Permutations",
+    "difficulty": "Medium",
+    "topics": "Array, Backtracking",
+    "tags": ["grind-75"],
+    "readme_description": "Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in any order.",
+    "readme_examples": [
+        {
+            "content": "```\nInput: nums = [1,2,3]\nOutput: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]\n```"
+        },
+        { "content": "```\nInput: nums = [0,1]\nOutput: [[0,1],[1,0]]\n```" },
+        { "content": "```\nInput: nums = [1]\nOutput: [[1]]\n```" }
+    ],
+    "readme_constraints": "- 1 <= nums.length <= 6\n- -10 <= nums[i] <= 10\n- All the integers of nums are unique.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "permute",
+            "parameters": "nums: list[int]",
+            "return_type": "list[list[int]]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "TestPermutations",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_permute",
+            "parametrize": "nums, expected",
+            "parametrize_typed": "nums: list[int], expected: list[list[int]]",
+            "test_cases": "[([1, 2, 3], [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]), ([0, 1], [[0, 1], [1, 0]]), ([1], [[1]])]",
+            "body": "result = self.solution.permute(nums)\n        # Sort both result and expected for comparison since order doesn't matter\n        result_sorted = [sorted(perm) for perm in result]\n        expected_sorted = [sorted(perm) for perm in expected]\n        result_sorted.sort()\n        expected_sorted.sort()\n        assert len(result) == len(expected)\n        assert result_sorted == expected_sorted"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nnums = [1, 2, 3]\nexpected = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]",
+    "playground_execution": "result = Solution().permute(nums)\nresult",
+    "playground_assertion": "# Check that we have the right number of permutations\nassert len(result) == len(expected)\n# Sort for comparison since order doesn't matter\nresult_sorted = [sorted(perm) for perm in result]\nexpected_sorted = [sorted(perm) for perm in expected]\nresult_sorted.sort()\nexpected_sorted.sort()\nassert result_sorted == expected_sorted"
+}

Makefile

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

leetcode/combination_sum/README.md

@@ -0,0 +1,47 @@
+# Combination Sum
+
+**Difficulty:** Medium
+**Topics:** Array, Backtracking
+**Tags:** grind-75
+
+**LeetCode:** [Problem 39](https://leetcode.com/problems/combination-sum/description/)
+
+## Problem Description
+
+Given an array of **distinct** integers `candidates` and a target integer `target`, return _a list of all **unique combinations** of_ `candidates` _where the chosen numbers sum to_ `target`. You may return the combinations in **any order**.
+
+The **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
+
+The test cases are generated such that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.
+
+## Examples
+
+### Example 1:
+
+```
+Input: candidates = [2,3,6,7], target = 7
+Output: [[2,2,3],[7]]
+```
+
+**Explanation:** 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. 7 is a candidate, and 7 = 7. These are the only two combinations.
+
+### Example 2:
+
+```
+Input: candidates = [2,3,5], target = 8
+Output: [[2,2,2,2],[2,3,3],[3,5]]
+```
+
+### Example 3:
+
+```
+Input: candidates = [2], target = 1
+Output: []
+```
+
+## Constraints
+
+- 1 <= candidates.length <= 30
+- 2 <= candidates[i] <= 40
+- All elements of candidates are distinct.
+- 1 <= target <= 40

leetcode/combination_sum/__init__.py

@@ -0,0 +1,57 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": ["from solution import Solution"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": ["# Example test case\ncandidates = [2, 3, 6, 7]\ntarget = 7\nexpected = [[2, 2, 3], [7]]"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": ["result = Solution().combination_sum(candidates, target)\nresult"]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": ["# Sort for comparison\nresult_sorted = [sorted(combo) for combo in result]\nexpected_sorted = [sorted(combo) for combo in expected]\nresult_sorted.sort()\nexpected_sorted.sort()\nassert result_sorted == expected_sorted"]
+  }
+ ],
+ "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": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/combination_sum/playground.ipynb

@@ -0,0 +1,19 @@
+class Solution:
+    # Time: O(N^(T/M)) where N=len(candidates), T=target, M=min(candidates)
+    # Space: O(T/M) recursion + O(K * T/M) output, where K = number of solutions
+    def combination_sum(self, candidates: list[int], target: int) -> list[list[int]]:
+        result = []
+
+        def backtrack(start: int, path: list[int], remaining: int) -> None:
+            if remaining == 0:
+                result.append(path[:])
+                return
+
+            for i in range(start, len(candidates)):
+                if candidates[i] <= remaining:
+                    path.append(candidates[i])
+                    backtrack(i, path, remaining - candidates[i])
+                    path.pop()
+
+        backtrack(0, [], target)
+        return result

leetcode/combination_sum/solution.py

@@ -0,0 +1,43 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestCombinationSum:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "candidates, target, expected",
+        [
+            ([2, 3, 6, 7], 7, [[2, 2, 3], [7]]),
+            ([2, 3, 5], 8, [[2, 2, 2, 2], [2, 3, 3], [3, 5]]),
+            ([2], 1, []),
+            ([1], 1, [[1]]),
+            ([1], 2, [[1, 1]]),
+            ([2, 3, 4], 6, [[2, 2, 2], [2, 4], [3, 3]]),
+            (
+                [7, 3, 2],
+                18,
+                [
+                    [2, 2, 2, 2, 2, 2, 2, 2, 2],
+                    [2, 2, 2, 2, 2, 2, 3, 3],
+                    [2, 2, 2, 3, 3, 3, 3],
+                    [2, 2, 7, 7],
+                    [2, 3, 3, 3, 7],
+                    [3, 3, 3, 3, 3, 3],
+                ],
+            ),
+        ],
+    )
+    @logged_test
+    def test_combination_sum(self, candidates: list[int], target: int, expected: list[list[int]]):
+        result = self.solution.combination_sum(candidates, target)
+        # Sort both result and expected for comparison
+        result_sorted = [sorted(combo) for combo in result]
+        expected_sorted = [sorted(combo) for combo in expected]
+        result_sorted.sort()
+        expected_sorted.sort()
+        assert result_sorted == expected_sorted

leetcode/combination_sum/tests.py

@@ -0,0 +1,40 @@
+# Permutations
+
+**Difficulty:** Medium
+**Topics:** Array, Backtracking
+**Tags:** grind-75
+
+**LeetCode:** [Problem 46](https://leetcode.com/problems/permutations/description/)
+
+## Problem Description
+
+Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in any order.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [1,2,3]
+Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+```
+
+### Example 2:
+
+```
+Input: nums = [0,1]
+Output: [[0,1],[1,0]]
+```
+
+### Example 3:
+
+```
+Input: nums = [1]
+Output: [[1]]
+```
+
+## Constraints
+
+- 1 <= nums.length <= 6
+- -10 <= nums[i] <= 10
+- All the integers of nums are unique.