add weekly-contest 122d

Author: Navy.Tian

weekly-contest/122d/p1_3009.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    def minimumCost(self, nums: List[int]) -> int:
+        ans = nums[0]
+        nums = nums[1:]
+        x1 = min(nums)
+        nums.remove(x1)
+        ans += x1
+        x2 = min(nums)
+        ans += x2
+        nums.remove(x2)
+        return ans
+
+
+if __name__ == "__main__":
+    assert Solution().minimumCost(nums=[1, 2, 3, 12]) == 6
+    assert Solution().minimumCost(nums=[10, 3, 1, 1]) == 12
+    assert Solution().minimumCost(nums=[5, 4, 3]) == 12

weekly-contest/122d/p2_3010.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+
+
+class Solution:
+    def canSortArray(self, nums: List[int]) -> bool:
+        return self._can_up_order(nums)
+
+    # def _can_down_order(self, nums: Optional[List[int]] = None) -> bool:
+    #     if nums is None:
+    #         nums = []
+    #     for i in range(0, len(nums)):
+    #         for j in range(i + 1, len(nums)):
+    #             if nums[i] < nums[j]:
+    #                 if self._has_equal_one_bit(nums[i], nums[j]):
+    #                     nums[i], nums[j] = nums[j], nums[i]
+    #                 else:
+    #                     return False
+    #     return True
+
+    def _can_up_order(self, nums: Optional[List[int]] = None) -> bool:
+        if nums is None:
+            nums = []
+        for i in range(0, len(nums)):
+            for j in range(i + 1, len(nums)):
+                if nums[i] > nums[j]:
+                    if self._has_equal_one_bit(nums[i], nums[j]):
+                        nums[i], nums[j] = nums[j], nums[i]
+                    else:
+                        return False
+        return True
+
+    def _has_equal_one_bit(self, x: int, y: int) -> bool:
+        return self._get_one_bit_count(x) == self._get_one_bit_count(y)
+
+    def _get_one_bit_count(self, number: int) -> int:
+        cnt = 0
+        while number:
+            if number & 1:
+                cnt += 1
+            number >>= 1
+        return cnt
+
+
+if __name__ == "__main__":
+    assert Solution().canSortArray(nums=[8, 4, 2, 30, 15]) is True
+    assert Solution().canSortArray(nums=[1, 2, 3, 4, 5]) is True
+    assert Solution().canSortArray(nums=[3, 16, 8, 4, 2]) is False

weekly-contest/122d/p3_3011.py

@@ -0,0 +1,41 @@
+from typing import List
+
+
+class Solution:
+    def minimumArrayLength(self, nums: List[int]) -> int:
+        # TODO: timeout
+        nums.sort()
+        temp_set = set(nums)
+        zero = 0
+        while True and len(nums) > 1:
+            maxs = nums[-1]
+            if maxs == 0:
+                zero += 1
+                nums.remove(maxs)
+            mins = nums[0]
+            if mins == 0:
+                zero += 1
+                nums.remove(mins)
+            if maxs > 0 and mins > 0:
+                maybe1 = mins % maxs
+                maybe2 = maxs % mins
+                if mins % maxs == 0:
+                    zero += 1
+                    nums = nums[1:-1]
+                elif maybe2 != 0 and maybe2 not in temp_set:
+                    nums = [maybe2] + nums[1:-1]
+                    temp_set.add(maybe2)
+                else:
+                    nums = [maybe1] + nums[1:-1]
+                    temp_set.add(maybe1)
+        return len(nums) + zero
+
+
+if __name__ == "__main__":
+    assert Solution().minimumArrayLength(nums=[1, 4, 3, 1]) == 1
+    assert Solution().minimumArrayLength(nums=[5, 5, 5, 10, 5]) == 2
+    assert Solution().minimumArrayLength(nums=[2, 3, 4]) == 1
+    assert Solution().minimumArrayLength(nums=[3, 3, 1]) == 1
+    assert Solution().minimumArrayLength(nums=[0, 0, 0]) == 3
+    assert Solution().minimumArrayLength(nums=[0, 0, 1]) == 3
+    assert Solution().minimumArrayLength(nums=[5, 2, 2, 2, 9, 10]) == 1

weekly-contest/122d/p4_3012.py

@@ -0,0 +1,16 @@
+"""
+https://leetcode.cn/problems/divide-an-array-into-subarrays-with-minimum-cost-ii/description/
+"""
+from typing import List
+
+
+class Solution:
+    def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
+        # TODO
+        ...
+
+
+if __name__ == "__main__":
+    assert Solution().minimumCost(nums=[1, 3, 2, 6, 4, 2], k=3, dist=3) == 5
+    assert Solution().minimumCost(nums=[10, 1, 2, 2, 2, 1], k=4, dist=3) == 15
+    assert Solution().minimumCost(nums=[10, 8, 18, 9], k=3, dist=1) == 36