relocate

Author: lexiconium

leetcode/array/3sum.cc renamed to leetcode/3sum.cc

@@ -0,0 +1,6 @@
+# https://leetcode.com/problems/apply-bitwise-operations-to-make-strings-equal/description/
+
+
+class Solution:
+    def makeStringsEqual(self, s: str, target: str) -> bool:
+        return ("1" in s) == ("1" in target)

leetcode/array/3sum.py renamed to leetcode/3sum.py

@@ -0,0 +1,11 @@
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+class Solution:
+    def maxProfit(self, prices: list[int]) -> int:
+        max_profit, min_p = 0, float("inf")
+
+        for p in prices:
+            max_profit = max(p - min_p, max_profit)
+            min_p = min(p, min_p)
+
+        return max_profit

leetcode/apply_bitwise_operations_to_make_strings_equal.py

@@ -0,0 +1,48 @@
+# https://leetcode.com/problems/build-a-matrix-with-conditions/description/
+
+from collections import defaultdict, deque
+
+
+class Solution:
+    def buildMatrix(
+        self, k: int, rowConditions: list[list[int]], colConditions: list[list[int]]
+    ) -> list[list[int]]:
+        def topological_sorted(conditions: list[tuple[int, int]]) -> list[int]:
+            graph = defaultdict(list)
+            counter = defaultdict(int)
+
+            for high, low in conditions:
+                graph[high].append(low)
+                counter[low] += 1
+
+            q = deque([node for node in range(1, k + 1) if counter[node] == 0])
+            sorted_nodes = []
+
+            while q:
+                node = q.popleft()
+                sorted_nodes.append(node)
+
+                for children in graph[node]:
+                    counter[children] -= 1
+
+                    if counter[children] == 0:
+                        q.append(children)
+
+            if len(sorted_nodes) < k:
+                return []
+
+            return sorted_nodes
+
+        if not (row_sorted := topological_sorted(rowConditions)):
+            return []
+
+        if not (col_sorted := topological_sorted(colConditions)):
+            return []
+
+        mat = [[0 for _ in range(k)] for _ in range(k)]
+        col_sorted_indices = {v: i for i, v in enumerate(col_sorted)}
+
+        for r, v in enumerate(row_sorted):
+            mat[r][col_sorted_indices[v]] = v
+
+        return mat

leetcode/array/best_time_to_buy_and_sell_stock.py

@@ -0,0 +1,13 @@
+# https://leetcode.com/problems/climbing-stairs/description/
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n < 3:
+            return n
+
+        a, b = 1, 2
+
+        for _ in range(n - 2):
+            b, a = a + b, b
+
+        return b

leetcode/array/array_partition_I.cc renamed to leetcode/array_partition_I.cc

@@ -0,0 +1,35 @@
+# https://leetcode.com/problems/corporate-flight-bookings/description/
+
+import heapq
+from itertools import accumulate
+
+
+class Solution:
+    def corpFlightBookings(self, bookings: list[list[int]], n: int) -> list[int]:
+        bookings = sorted(bookings, reverse=True)
+
+        lasts = []
+        total, totals = 0, []
+
+        for m in range(1, n + 1):
+            while lasts and lasts[0][0] < m:
+                last, seats = heapq.heappop(lasts)
+                total -= seats
+
+            while bookings and bookings[-1][0] <= m:
+                first, last, seats = bookings.pop()
+                total += seats
+
+                heapq.heappush(lasts, (last, seats))
+
+            totals.append(total)
+
+        return totals
+
+    def corpFlightBookings(self, bookings: list[list[int]], n: int) -> list[int]:
+        diffs = [0 for _ in range(n + 1)]
+        for first, last, seats in bookings:
+            diffs[first - 1] += seats
+            diffs[last] -= seats
+
+        return list(accumulate(diffs))[:-1]

leetcode/array/array_partition_I.py renamed to leetcode/array_partition_I.py

@@ -0,0 +1,10 @@
+# https://leetcode.com/problems/counting-bits
+
+class Solution:
+    def countBits(self, n: int) -> list[int]:
+        dp = [0] * (n + 1)
+
+        for m in range(1, n + 1):
+            dp[m] = dp[m >> 1] + (m & 1)
+
+        return dp

leetcode/array/best_time_to_buy_and_sell_stock.cc renamed to leetcode/best_time_to_buy_and_sell_stock.cc

@@ -0,0 +1,15 @@
+# https://leetcode.com/problems/fibonacci-number/description/
+
+class Solution:
+    def fib(self, n: int) -> int:
+        if n == 0:
+            return 0
+        if n < 3:
+            return 1
+
+        a = b = 1
+
+        for _ in range(n - 2):
+            a, b = a + b, a
+
+        return a

leetcode/best_time_to_buy_and_sell_stock.py

@@ -0,0 +1,27 @@
+# https://leetcode.com/problems/four-divisors/submissions/943173970/
+
+from collections import defaultdict
+
+
+class Solution:
+    def sumFourDivisors(self, nums: list[int]) -> int:
+        divisors = defaultdict(set)
+        divisors_sums = defaultdict(int)
+        divisors_sum = 0
+
+        for n in nums:
+            if n in divisors and len(divisors[n]) == 4:
+                divisors_sum += divisors_sums[n]
+                continue
+
+            for m in range(1, int(n ** (1 / 2) + 1)):
+                div, mod = divmod(n, m)
+                if mod == 0:
+                    divisors[n] |= {div, m}
+
+            divisors_sums[n] = sum(divisors[n])
+
+            if len(divisors[n]) == 4:
+                divisors_sum += divisors_sums[n]
+
+        return divisors_sum

leetcode/dp/best_time_to_buy_and_sell_stock_III.cc renamed to leetcode/best_time_to_buy_and_sell_stock_III.cc

@@ -0,0 +1,8 @@
+# https://leetcode.com/problems/frog-jump-ii/description/
+
+
+class Solution:
+    def maxJump(self, stones: list[int]) -> int:
+        if len(stones) == 2:
+            return stones[1] - stones[0]
+        return max(stones[i + 2] - stones[i] for i in range(len(stones) - 2))

leetcode/dp/best_time_to_buy_and_sell_stock_III.py renamed to leetcode/best_time_to_buy_and_sell_stock_III.py

@@ -0,0 +1,17 @@
+# https://leetcode.com/problems/get-maximum-in-generated-array/description/
+
+class Solution:
+    def getMaximumGenerated(self, n: int) -> int:
+        if n < 2:
+            return n
+
+        dp = [0] * (n + 1)
+        dp[1] = 1
+
+        for m in range(2, n + 1):
+            dp[m] = dp[m // 2]
+
+            if m % 2:
+                dp[m] += + dp[m // 2 + 1]
+
+        return max(dp)

leetcode/dp/best_time_to_buy_and_sell_stock_III.rs renamed to leetcode/best_time_to_buy_and_sell_stock_III.rs

@@ -0,0 +1,19 @@
+# https://leetcode.com/problems/is-subsequence/description/
+
+class Solution:
+    def isSubsequence(self, s: str, t: str) -> bool:
+        if not s:
+            return True
+
+        i = 0
+
+        for c in t:
+            if c != s[i]:
+                continue
+
+            i += 1
+
+            if i == len(s):
+                return True
+
+        return False

leetcode/dp/best_time_to_buy_and_sell_stock_IV.cc renamed to leetcode/best_time_to_buy_and_sell_stock_IV.cc

@@ -0,0 +1,27 @@
+# https://leetcode.com/problems/knight-probability-in-chessboard/description/
+
+
+from functools import cache
+
+
+class Solution:
+    def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
+        def is_valid(r: int, c: int) -> bool:
+            return 0 <= r < n and 0 <= c < n
+
+        @cache
+        def dfs(r: int, c: int, depth: int = 0) -> int:
+            if not is_valid(r, c):
+                return 0
+            if depth == k:
+                return 1
+
+            return sum(
+                dfs(r + dr, c + dc, depth + 1)
+                for dr, dc in (
+                    (-1, -2), (-2, -1), (-2, 1), (-1, 2),
+                    (1, -2), (2, -1), (2, 1), (1, 2)
+                )
+            )
+
+        return dfs(row, column) / 8**k