back at it

Author: aluferraz

leetcode/editor/en/Q2071/MaximumNumberOfTasksYouCanAssign.py

@@ -0,0 +1,59 @@
+from typing import List
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def maxTaskAssign(self, tasks: List[int], workers: List[int], pills: int, strength: int) -> int:
+
+        N = len(tasks)
+        M = len(workers)
+        left = 0
+        right = N + 1
+        ans = 0
+        tasks.sort()
+        workers.sort()
+        INF = 10 ** 20
+
+        def go(i, j, target):
+            if i == target:
+                return 0, 0
+            if j == M:
+                return INF, 0
+
+            if workers[j] >= tasks[i]:
+                used, completed = go(i + 1, j + 1, target)
+                return used, completed + 1
+            else:
+                if workers[j] + strength >= tasks[i]:
+                    used_taking, completed_taking = go(i + 1, j + 1, target)
+                    used_taking += 1
+                    completed_taking += 1
+                    used_skipping, completed_skipping = go(i, j + 1, target)
+                    used_ignoring, completed_ignoring = go(i + 1, j, target)
+                    options = [(used_taking, -completed_taking), (used_skipping, -completed_skipping),
+                               (used_ignoring, -completed_ignoring)]
+                    options.sort()
+                    ans_here = options[0]
+                    return ans_here[0], abs(ans_here[1])
+
+            return INF
+
+        def good(target):
+            min_pills = go(0, 0, target)
+            return min_pills < pills
+
+        while left < right:
+            mid = (left + right) // 2
+            if good(mid):
+                ans = mid
+                left = mid + 1
+            else:
+                right = mid
+        return ans
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+
+class MaximumNumberOfTasksYouCanAssign(Solution):
+    pass

leetcode/editor/en/Q2843/CountSymmetricIntegers.py

@@ -0,0 +1,11 @@
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def countSymmetricIntegers(self, low: int, high: int) -> int:
+        dp = [0] * len(str(high))
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+
+class CountSymmetricIntegers(Solution):
+    pass

leetcode/editor/en/Q3403/FindTheLexicographicallyLargestStringFromTheBoxI.py

@@ -0,0 +1,38 @@
+# leetcode submit region begin(Prohibit modification and deletion)
+
+class Solution:
+    def answerString(self, word: str, num_friends: int) -> str:
+        n = len(word)
+        if num_friends > n:
+            return ""
+        if num_friends == 1:
+            return word
+
+        highest_char = max(word)  # the best single letter we can start with
+        best = ""
+
+        for i, ch in enumerate(word):
+            if ch != highest_char:
+                continue
+
+            remaining = num_friends - (i + 1)  # friends still waiting to cut
+
+            if remaining <= 0:
+                # everyone has already “cut” in or before this position,
+                # so we can keep the whole suffix
+                candidate = word[i:]
+            else:
+                # leave at least `remaining` letters after our slice
+                # end index is exclusive, so this is safe
+                candidate = word[i:n - remaining]
+
+            best = max(best, candidate)
+
+        return best
+
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+
+class FindTheLexicographicallyLargestStringFromTheBoxI(Solution):
+    pass

main.py

@@ -1,4 +1,5 @@
-from leetcode.editor.en.Q416.PartitionEqualSubsetSum import PartitionEqualSubsetSum
+from leetcode.editor.en.Q3403.FindTheLexicographicallyLargestStringFromTheBoxI import \
+    FindTheLexicographicallyLargestStringFromTheBoxI
 
 if __name__ == '__main__':
-    print(PartitionEqualSubsetSum().canPartition([1, 5, 11, 5]))
+    print(FindTheLexicographicallyLargestStringFromTheBoxI().answerString("gggg", 4))