daily

Author: TurtleSmoke

problems/problem_0052/solution_1.py

@@ -0,0 +1,39 @@
+import pytest
+
+
+class Solution:
+    def totalNQueens(self, n: int) -> int:
+        def dfs(c, rows):
+            if c == n:
+                return 1
+
+            res = 0
+            for r in range(n):
+                if all(r != x and abs(r - x) != abs(c - y) for y, x in enumerate(rows)):
+                    res += dfs(c + 1, rows + [r])
+
+            return res
+
+        return dfs(0, [])
+
+
+tests = [
+    (
+        (4,),
+        2,
+    ),
+    (
+        (1,),
+        1,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().totalNQueens(*inputs)
+    assert output == expected

problems/problem_0054/solution_1.py

@@ -0,0 +1,37 @@
+import pytest
+from typing import List
+import numpy as np
+
+
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        matrix = np.asarray(matrix)
+
+        while matrix.size > 0:
+            res.extend(matrix[0])
+            matrix = np.rot90(matrix[1:])
+
+        return res
+
+
+tests = [
+    (
+        ([[1, 2, 3], [4, 5, 6], [7, 8, 9]],),
+        [1, 2, 3, 6, 9, 8, 7, 4, 5],
+    ),
+    (
+        ([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],),
+        [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7],
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().spiralOrder(*inputs)
+    assert output == expected

problems/problem_0075/solution_1.py

@@ -0,0 +1,42 @@
+from collections import Counter
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def sortColors(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        count = Counter(nums)
+        current = 0
+        for i in range(len(nums)):
+            while count[current] <= 0:
+                current += 1
+
+            nums[i] = current
+            count[current] -= 1
+
+
+tests = [
+    (
+        ([2, 0, 2, 1, 1, 0],),
+        [0, 0, 1, 1, 2, 2],
+    ),
+    (
+        ([2, 0, 1],),
+        [0, 1, 2],
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    input = inputs[0]
+    Solution().sortColors(input)
+    assert input == expected

problems/problem_0075/solution_2.py

@@ -0,0 +1,45 @@
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def sortColors(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        red, white, blue = 0, 0, len(nums) - 1
+
+        while white <= blue:
+            if nums[white] == 0:
+                nums[red], nums[white] = nums[white], nums[red]
+                red += 1
+                white += 1
+            elif nums[white] == 1:
+                white += 1
+            else:
+                nums[white], nums[blue] = nums[blue], nums[white]
+                blue -= 1
+
+
+tests = [
+    (
+        ([2, 0, 2, 1, 1, 0],),
+        [0, 0, 1, 1, 2, 2],
+    ),
+    (
+        ([2, 0, 1],),
+        [0, 1, 2],
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    input = inputs[0]
+    Solution().sortColors(input)
+    assert input == expected

problems/problem_0260/solution_1.py

@@ -0,0 +1,38 @@
+from functools import reduce
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> List[int]:
+        xor = reduce(lambda x, y: x ^ y, nums)
+        nz = xor & -xor
+        res1 = reduce(lambda x, y: x ^ y, filter(lambda x: x & nz, nums))
+        return [res1, res1 ^ xor]
+
+
+tests = [
+    (
+        ([1, 2, 1, 3, 2, 5],),
+        [3, 5],
+    ),
+    (
+        ([-1, 0],),
+        [-1, 0],
+    ),
+    (
+        ([0, 1],),
+        [1, 0],
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().singleNumber(*inputs)
+    assert sorted(output) == sorted(expected)

problems/problem_0330/solution_1.py

@@ -0,0 +1,45 @@
+from typing import List
+import pytest
+
+
+class Solution:
+    def minPatches(self, nums: List[int], n: int) -> int:
+        miss = 0
+        res = 0
+        i = 0
+        while miss < n:
+            x = nums[i] if i < len(nums) else n + 2
+            if x > miss + 1:
+                miss = miss * 2 + 1
+                res += 1
+            else:
+                miss += x
+                i += 1
+        return res
+
+
+tests = [
+    (
+        ([1, 3], 6),
+        1,
+    ),
+    (
+        ([1, 5, 10], 20),
+        2,
+    ),
+    (
+        ([1, 2, 2], 5),
+        0,
+    ),
+    (
+        ([1, 3], 2147483647),
+        30,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().minPatches(*inputs)
+    assert output == expected

problems/problem_0344/solution_1.py

@@ -0,0 +1,34 @@
+import pytest
+from typing import List
+
+
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        """
+        Do not return anything, modify s in-place instead.
+        """
+        for i in range(len(s) // 2):
+            s[i], s[-i - 1] = s[-i - 1], s[i]
+
+
+tests = [
+    (
+        (["h", "e", "l", "l", "o"],),
+        ["o", "l", "l", "e", "h"],
+    ),
+    (
+        (["H", "a", "n", "n", "a", "h"],),
+        ["h", "a", "n", "n", "a", "H"],
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    input = inputs[0]
+    Solution().reverseString(input)
+    assert input == expected