D. J.:

- Added the leetcode problem and solution for 22, 39, 51 and 52

Author: nobodyPerfecZ

README.md

@@ -38,18 +38,22 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [19 Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
 - [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/)
 - [21 Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+- [22 Generate Parentheses](https://leetcode.com/problems/generate-parentheses/description/)
 - [25 Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/description/)
 - [26 Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/)
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
 - [28 Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/description/)
 - [30 Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/description/)
 - [36 Valid Sudoku](https://leetcode.com/problems/valid-sudoku/description/)
+- [39 Combination Sum](https://leetcode.com/problems/combination-sum/description/)
 - [42 Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/description/)
 - [45 Jump Game II](https://leetcode.com/problems/jump-game-ii/description/)
 - [46 Permutations](https://leetcode.com/problems/permutations/description/)
 - [48 Rotate Image](https://leetcode.com/problems/rotate-image/description/)
 - [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/description/)
 - [50 Pow(x_n)](https://leetcode.com/problems/powx-n/description/)
+- [51 N-Queens](https://leetcode.com/problems/n-queens/description/)
+- [52 N-Queens II](https://leetcode.com/problems/n-queens-ii/description/)
 - [54 Spiral Matrix](https://leetcode.com/problems/spiral-matrix/description/)
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
 - [58 Length of Last Word](https://leetcode.com/problems/length-of-last-word/description/)

awesome_python_leetcode/_22_generate_parentheses.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def generateParenthesis(self, n: int) -> List[str]:
+        """
+        Given n pairs of parentheses, write a function to generate all combinations of
+        well-formed parentheses.
+        """
+        res = []
+
+        def dfs(p: str, openP: int, endP: int):
+            if openP == n and endP == n:
+                res.append(p)
+                return
+            if openP < n:
+                dfs(p + "(", openP + 1, endP)
+            if openP > endP and endP < n:
+                dfs(p + ")", openP, endP + 1)
+
+        dfs("", 0, 0)
+        return res

awesome_python_leetcode/_39_combination_sum.py

@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        """
+        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.
+        """
+        res = []
+
+        def dfs(i: int, pair: List[int], total: int):
+            if total == target:
+                res.append(pair.copy())
+                return
+            if i >= len(candidates) or total > target:
+                return
+
+            pair.append(candidates[i])
+            dfs(i, pair, total + candidates[i])
+            pair.pop()
+            dfs(i + 1, pair, total)
+
+        dfs(0, [], 0)
+        return res

awesome_python_leetcode/_51_n_queens.py

@@ -0,0 +1,40 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def solveNQueens(self, n: int) -> List[List[str]]:
+        """
+        The n-queens puzzle is the problem of placing n queens on an n x n chessboard
+        such that no two queens attack each other.
+
+        Given an integer n, return all distinct solutions to the n-queens puzzle. You
+        may return the answer in any order.
+
+        Each solution contains a distinct board configuration of the n-queens'
+        placement, where 'Q' and '.' both indicate a queen and an empty space,
+        respectively.
+        """
+        res = []
+        cols, diags, anti_diags = set(), set(), set()
+
+        def dfs(row: int, pairs: List[str]):
+            if row == n:
+                res.append(pairs.copy())
+                return
+            for col in range(n):
+                if col in cols or (row + col) in diags or (row - col) in anti_diags:
+                    continue
+                cols.add(col)
+                diags.add(row + col)
+                anti_diags.add(row - col)
+                pairs.append(col * "." + "Q" + (n - col - 1) * ".")
+                dfs(row + 1, pairs)
+                pairs.pop()
+                cols.remove(col)
+                diags.remove(row + col)
+                anti_diags.remove(row - col)
+
+        dfs(0, [])
+        return res

awesome_python_leetcode/_52_n_queens_II.py

@@ -0,0 +1,32 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def totalNQueens(self, n: int) -> int:
+        """
+        The n-queens puzzle is the problem of placing n queens on an n x n chessboard
+        such that no two queens attack each other.
+
+        Given an integer n, return the number of distinct solutions to the n-queens
+        puzzle.
+        """
+        count = 0
+        cols, diags, anti_diags = set(), set(), set()
+
+        def dfs(row: int):
+            if row == n:
+                nonlocal count
+                count += 1
+                return
+            for col in range(n):
+                if col in cols or (row + col) in diags or (row - col) in anti_diags:
+                    continue
+                cols.add(col)
+                diags.add(row + col)
+                anti_diags.add(row - col)
+                dfs(row + 1)
+                cols.remove(col)
+                diags.remove(row + col)
+                anti_diags.remove(row - col)
+
+        dfs(0)
+        return count

tests/test_22_generate_parentheses.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._22_generate_parentheses import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (3, ["((()))", "(()())", "(())()", "()(())", "()()()"]),
+        (1, ["()"]),
+    ],
+)
+def test_func(n: int, expected: List[str]):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().generateParenthesis(n)
+    assert combinations == expected

tests/test_39_combination_sum.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._39_combination_sum import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["candidates", "target", "expected"],
+    argvalues=[
+        ([2, 3, 6, 7], 7, [[2, 2, 3], [7]]),
+        ([2, 3, 5], 8, [[2, 2, 2, 2], [2, 3, 3], [3, 5]]),
+        ([2], 1, []),
+    ],
+)
+def test_func(candidates: List[int], target: int, expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().combinationSum(candidates, target)
+    assert combinations == expected

tests/test_51_n_queens.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._51_n_queens import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (4, [[".Q..", "...Q", "Q...", "..Q."], ["..Q.", "Q...", "...Q", ".Q.."]]),
+        (1, [["Q"]]),
+    ],
+)
+def test_func(n: int, expected: List[List[str]]):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().solveNQueens(n)
+    assert combinations == expected

tests/test_52_n_queens_II.py

@@ -0,0 +1,16 @@
+import pytest
+
+from awesome_python_leetcode._52_n_queens_II import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (4, 2),
+        (1, 1),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().totalNQueens(n)
+    assert combinations == expected