daily

Author: TurtleSmoke

problems/problem_0874/solution_1.py

@@ -0,0 +1,50 @@
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def robotSim(self, commands: List[int], obstacles: List[List[int]]) -> int:
+        obstacles = set((x + y * 1j for x, y in obstacles))
+        res = 0
+        pos = 0
+        direction = 1j
+        for cmd in commands:
+            if cmd == -1:
+                direction *= -1j
+            elif cmd == -2:
+                direction *= 1j
+            else:
+                for _ in range(cmd):
+                    if pos + direction in obstacles:
+                        break
+                    pos += direction
+                res = max(res, int(pos.real) ** 2 + int(pos.imag) ** 2)
+
+        return res
+
+
+tests = [
+    (
+        ([4, -1, 3], []),
+        25,
+    ),
+    (
+        ([4, -1, 4, -2, 4], [[2, 4]]),
+        65,
+    ),
+    (
+        ([6, -1, -1, 6], []),
+        36,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().robotSim(*inputs)
+    assert output == expected

problems/problem_0947/solution_1.py

@@ -0,0 +1,49 @@
+from typing import List
+import pytest
+
+
+class Solution:
+    def removeStones(self, stones: List[List[int]]) -> int:
+        union_find = {}
+
+        def find(x):
+            if x != union_find[x]:
+                union_find[x] = find(union_find[x])
+            return union_find[x]
+
+        def union(x, y):
+            union_find.setdefault(x, x)
+            union_find.setdefault(y, y)
+            union_find[find(x)] = find(y)
+
+        for x, y in stones:
+            union(x, ~y)
+
+        return len(stones) - len({find(x) for x in union_find})
+
+
+tests = [
+    (
+        ([[0, 0], [0, 1], [1, 0], [1, 2], [2, 1], [2, 2]],),
+        5,
+    ),
+    (
+        ([[0, 0], [0, 2], [1, 1], [2, 0], [2, 2]],),
+        3,
+    ),
+    (
+        ([[0, 0]],),
+        0,
+    ),
+    (
+        ([[0, 1], [1, 0], [1, 1]],),
+        2,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().removeStones(*inputs)
+    assert output == expected

problems/problem_1367/solution_1.py

@@ -0,0 +1,53 @@
+from typing import Optional
+
+import pytest
+
+from problems.utils import ListNode
+from problems.utils import TreeNode
+
+
+class Solution:
+    def isSubPath(self, head: Optional[ListNode], root: Optional[TreeNode]) -> bool:
+        def dfs(head, root):
+            if not head:
+                return True
+            if not root:
+                return False
+            return head.val == root.val and (dfs(head.next, root.left) or dfs(head.next, root.right))
+
+        if not head:
+            return True
+        if not root:
+            return False
+        return dfs(head, root) or self.isSubPath(head, root.left) or self.isSubPath(head, root.right)
+
+
+tests = [
+    (
+        ([4, 2, 8], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        True,
+    ),
+    (
+        ([1, 4, 2, 6], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        True,
+    ),
+    (
+        ([1, 4, 2, 6, 8], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        False,
+    ),
+    (
+        ([1, 10], [1, None, 1, 10, 1, 9]),
+        True,
+    ),
+    (
+        ([2, 2, 1], [2, None, 2, None, 2, None, 1]),
+        True,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().isSubPath(ListNode.from_list(inputs[0]), TreeNode.from_list(inputs[1]))
+    assert output == expected

problems/problem_1367/solution_2.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+import pytest
+
+from problems.utils import ListNode
+from problems.utils import TreeNode
+
+
+class Solution:
+    def isSubPath(self, head: Optional[ListNode], root: Optional[TreeNode]) -> bool:
+        sub_path = []
+        while head:
+            sub_path.append(head.val)
+            head = head.next
+
+        suffix_dp = [0] * len(sub_path)
+        j = 0
+        for i in range(1, len(sub_path)):
+            while j and sub_path[i] != sub_path[j]:
+                j = suffix_dp[j - 1]
+            j += sub_path[i] == sub_path[j]
+            suffix_dp[i] = j
+
+        def dfs(root, i):
+            if not root:
+                return False
+            while i and root.val != sub_path[i]:
+                i = suffix_dp[i - 1]
+            i += root.val == sub_path[i]
+            return i == len(suffix_dp) or dfs(root.left, i) or dfs(root.right, i)
+
+        return dfs(root, 0)
+
+
+tests = [
+    (
+        ([4, 2, 8], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        True,
+    ),
+    (
+        ([1, 4, 2, 6], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        True,
+    ),
+    (
+        ([1, 4, 2, 6, 8], [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3]),
+        False,
+    ),
+    (
+        ([1, 10], [1, None, 1, 10, 1, 9]),
+        True,
+    ),
+    (
+        ([2, 2, 1], [2, None, 2, None, 2, None, 1]),
+        True,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().isSubPath(ListNode.from_list(inputs[0]), TreeNode.from_list(inputs[1]))
+    assert output == expected

problems/problem_1514/solution_1.py

@@ -0,0 +1,56 @@
+import heapq
+from collections import defaultdict
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def maxProbability(
+        self, n: int, edges: List[List[int]], succProb: List[float], start_node: int, end_node: int
+    ) -> float:
+        graph = defaultdict(list)
+        for (s, d), w in zip(edges, succProb):
+            graph[s].append((w, d))
+            graph[d].append((w, s))
+
+        pq = [(-1, start_node)]
+        seen = set()
+
+        while pq:
+            cost, current = heapq.heappop(pq)
+            if current == end_node:
+                return -cost
+
+            seen.add(current)
+            for weight, neighbor in graph[current]:
+                if neighbor not in seen:
+                    heapq.heappush(pq, (cost * weight, neighbor))
+
+        return 0
+
+
+tests = [
+    (
+        (3, [[0, 1], [1, 2], [0, 2]], [0.5, 0.5, 0.2], 0, 2),
+        0.25000,
+    ),
+    (
+        (3, [[0, 1], [1, 2], [0, 2]], [0.5, 0.5, 0.3], 0, 2),
+        0.30000,
+    ),
+    (
+        (3, [[0, 1]], [0.5], 0, 2),
+        0.00000,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().maxProbability(*inputs)
+    assert output == expected

problems/problem_1894/solution_1.py

@@ -0,0 +1,32 @@
+import bisect
+import pytest
+from typing import List
+
+
+class Solution:
+    def chalkReplacer(self, chalk: List[int], k: int) -> int:
+        cum_sum = [0] * len(chalk)
+        cum_sum[0] = chalk[0]
+        for i in range(1, len(chalk)):
+            cum_sum[i] = cum_sum[i - 1] + chalk[i]
+        k = k % cum_sum[-1]
+        return bisect.bisect_right(cum_sum, k)
+
+
+tests = [
+    (
+        ([5, 1, 5], 22),
+        0,
+    ),
+    (
+        ([3, 4, 1, 2], 25),
+        1,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().chalkReplacer(*inputs)
+    assert output == expected

problems/problem_1905/solution_1.py

@@ -0,0 +1,53 @@
+from typing import List
+
+import pytest
+
+
+class Solution:
+    def countSubIslands(self, grid1: List[List[int]], grid2: List[List[int]]) -> int:
+        def dfs(i, j):
+            if i < 0 or j < 0 or i >= len(grid2) or j >= len(grid2[0]) or grid2[i][j] == 0:
+                return
+
+            grid2[i][j] = 0
+            for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
+                dfs(i + dx, j + dy)
+
+        for i in range(len(grid2)):
+            for j in range(len(grid2[0])):
+                if grid2[i][j] == 1 and grid1[i][j] == 0:
+                    dfs(i, j)
+
+        res = 0
+        for i in range(len(grid2)):
+            for j in range(len(grid2[0])):
+                if grid2[i][j] == 1:
+                    res += 1
+                    dfs(i, j)
+
+        return res
+
+
+tests = [
+    (
+        (
+            [[1, 1, 1, 0, 0], [0, 1, 1, 1, 1], [0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 1, 0, 1, 1]],
+            [[1, 1, 1, 0, 0], [0, 0, 1, 1, 1], [0, 1, 0, 0, 0], [1, 0, 1, 1, 0], [0, 1, 0, 1, 0]],
+        ),
+        3,
+    ),
+    (
+        (
+            [[1, 0, 1, 0, 1], [1, 1, 1, 1, 1], [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [1, 0, 1, 0, 1]],
+            [[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [0, 1, 0, 1, 0], [0, 1, 0, 1, 0], [1, 0, 0, 0, 1]],
+        ),
+        2,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize("inputs, expected", tests)
+def test_validator(inputs, expected):
+    output = Solution().countSubIslands(*inputs)
+    assert output == expected

problems/problem_1945/solution_1.py

@@ -0,0 +1,35 @@
+import pytest
+
+
+class Solution:
+    def getLucky(self, s: str, k: int) -> int:
+        res = "".join(map(lambda x: str(ord(x) - 96), s))
+        for _ in range(k):
+            res = str(sum(map(int, res)))
+        return int(res)
+
+
+tests = [
+    (
+        ("iiii", 1),
+        36,
+    ),
+    (
+        ("leetcode", 2),
+        6,
+    ),
+    (
+        ("zbax", 2),
+        8,
+    ),
+]
+
+
+@pytest.mark.timeout(2)
+@pytest.mark.parametrize(
+    "inputs, expected",
+    tests,
+)
+def test_validator(inputs, expected):
+    output = Solution().getLucky(*inputs)
+    assert output == expected