more lc

Author: NotFish232

src/python_solutions/1297_maximum-number-of-occurrences-of-a-substring.py

@@ -0,0 +1,24 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
+        freqs = {}
+
+        for i in range(len(s)):
+            for k in range(minSize, maxSize + 1):
+                if i + k - 1 < len(s):
+                    sub = s[i : i + k]
+
+                    uniques = len(set(sub))
+
+                    if uniques <= maxLetters:
+                        if sub not in freqs:
+                            freqs[sub] = 0
+                        freqs[sub] += 1
+
+        return 0 if len(freqs) == 0 else max(freqs.values())
+
+
+# end_submission

src/python_solutions/1461_check-if-a-string-contains-all-binary-codes-of-size-k.py

@@ -0,0 +1,15 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def hasAllCodes(self, s: str, k: int) -> bool:
+        st = set()
+
+        for i in range(len(s) - k + 1):
+            st.add(s[i : i + k])
+
+        return len(st) == 2**k
+
+
+# end_submission

src/python_solutions/1743_restore-the-array-from-adjacent-pairs.py

@@ -0,0 +1,42 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
+        num_edges = {}
+        edges = {}
+
+        for a, b in adjacentPairs:
+            if a not in num_edges:
+                num_edges[a] = 0
+            num_edges[a] += 1
+
+            if b not in num_edges:
+                num_edges[b] = 0
+            num_edges[b] += 1
+
+            if a not in edges:
+                edges[a] = []
+            edges[a].append(b)
+
+            if b not in edges:
+                edges[b] = []
+            edges[b].append(a)
+
+        prev = None
+        cur = next(iter(k for k, v in num_edges.items() if v == 1))
+
+        res = [cur]
+
+        while len(res) != len(adjacentPairs) + 1:
+            old_prev = prev
+            prev = cur
+            cur = edges[cur][0] if edges[cur][0] != old_prev else edges[cur][1]
+
+            res.append(cur)
+
+        return res
+
+
+# end_submission

src/python_solutions/1785_minimum-elements-to-add-to-form-a-given-sum.py

@@ -0,0 +1,12 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def minElements(self, nums: List[int], limit: int, goal: int) -> int:
+        sm = sum(nums)
+
+        return (abs(sm - goal) + limit - 1) // limit
+
+
+# end_submission

src/python_solutions/1898_maximum-number-of-removable-characters.py

@@ -0,0 +1,37 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def maximumRemovals(self, s: str, p: str, removable: List[int]) -> int:
+        l = 0
+        r = len(removable)
+
+        ans = -1
+
+        while l <= r:
+            m = (l + r) // 2
+
+            r_set = set(removable[:m])
+
+            p_idx = 0
+            good = False
+
+            for i, ch in enumerate(s):
+                if i not in r_set and ch == p[p_idx]:
+                    p_idx += 1
+
+                if p_idx == len(p):
+                    good = True
+                    break
+
+            if good:
+                l = m + 1
+                ans = m
+            else:
+                r = m - 1
+
+        return ans
+
+
+# end_submission

src/python_solutions/2420_find-all-good-indices.py

@@ -0,0 +1,23 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def goodIndices(self, nums: List[int], k: int) -> List[int]:
+        n = len(nums)
+
+        l = [1] * n
+        r = [1] * n
+
+        for i in range(1, len(nums)):
+            if nums[i] <= nums[i - 1]:
+                l[i] = l[i - 1] + 1
+
+        for i in reversed(range(len(nums) - 1)):
+            if nums[i] <= nums[i + 1]:
+                r[i] = r[i + 1] + 1
+
+        return [i for i in range(k, n - k) if l[i - 1] >= k and r[i + 1] >= k]
+
+
+# end_submission

src/python_solutions/2546_apply-bitwise-operations-to-make-strings-equal.py

@@ -0,0 +1,12 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def makeStringsEqual(self, s: str, target: str) -> bool:
+        return (
+            any(x == "1" for x in s) and any(x == "1" for x in target)
+        ) or s == target
+
+
+# end_submission

src/python_solutions/2772_apply-operations-to-make-all-array-elements-equal-to-zero.py

@@ -0,0 +1,28 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def checkArray(self, nums: List[int], k: int) -> bool:
+        q = deque()
+
+        diff = 0
+
+        for i, n in enumerate(nums):
+            if len(q) > 0 and q[0][0] == i - k:
+                diff -= q.popleft()[1]
+
+            if diff > n:
+                return False
+
+            if diff < n:
+                if i + k > len(nums):
+                    return False
+
+                q.append((i, n - diff))
+                diff = n
+
+        return True
+
+
+# end_submission

src/python_solutions/3635_earliest-finish-time-for-land-and-water-rides-ii.py

@@ -0,0 +1,27 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def earliestFinishTime(
+        self,
+        landStartTime: List[int],
+        landDuration: List[int],
+        waterStartTime: List[int],
+        waterDuration: List[int],
+    ) -> int:
+        ans = float("inf")
+
+        for s1, d1, s2, d2 in [
+            (landStartTime, landDuration, waterStartTime, waterDuration),
+            (waterStartTime, waterDuration, landStartTime, landDuration),
+        ]:
+            s = min(t + d for t, d in zip(s1, d1))
+
+            for t, d in zip(s2, d2):
+                ans = min(ans, max(s, t) + d)
+
+        return ans
+
+
+# end_submission

src/python_solutions/3782_last-remaining-integer-after-alternating-deletion-operations.py

@@ -0,0 +1,32 @@
+from common import *
+
+
+# start_submission
+class Solution:
+    def lastInteger(self, n: int) -> int:
+        if n == 1:
+            return n
+
+        ans = 1
+        cnt = 1
+
+        while True:
+            n = (n + 1) // 2
+
+            if n == 1:
+                return ans
+
+            cnt *= 2
+
+            if n % 2 == 0:
+                ans += cnt
+
+            n = (n + 1) // 2
+
+            if n == 1:
+                return ans
+
+            cnt *= 2
+
+
+# end_submission