Leetcode notes: biweekly contest 71

• LeetCode note ：Biweekly Contest 71
  • 1. Topic 1
    • 1. Their thinking
    • 2. Code implementation
  • 2. Topic two
    • 1. Their thinking
    • 2. Code implementation
  • 3. Topic three
    • 1. Their thinking
    • 2. Code implementation
  • 4. Topic four
    • 1. Their thinking
    • 2. Code implementation

1. Topic 1

The link to question 1 is as follows ：

• 2160. Minimum Sum of Four Digit Number After Splitting Digits

1. Their thinking

This question allows 0 At the beginning , Therefore, the overall idea is relatively simple , Only need to 4 Take out a number , Then put the two smaller numbers in the tens , The remaining two large numbers can be placed in single digits .

2. Code implementation

give python The code implementation is as follows ：

class Solution:
    def minimumSum(self, num: int) -> int:
        digits = []
        while num != 0:
            digits.append(num % 10)
            num = num // 10
        digits = sorted(digits)
        return 10*sum(digits[:2]) + sum(digits[2:])

The submitted code was evaluated ： Time consuming 43ms, Take up memory 13.8MB.

2. Topic two

The link to question 2 is as follows ：

• 2161. Partition Array According to Given Pivot

1. Their thinking

My thinking on this question is more violent , Direct the data according to pivot Divided into three piles , Then reassemble .

2. Code implementation

give python The code implementation is as follows ：

class Solution:
    def pivotArray(self, nums: List[int], pivot: int) -> List[int]:
        less = [x for x in nums if x < pivot]
        equal = [x for x in nums if x == pivot]
        large = [x for x in nums if x > pivot]
        return less + equal + large

The submitted code was evaluated ： Time consuming 2373ms, Take up memory 31.6MB.

3. Topic three

The link to question 3 is as follows ：

• 2162. Minimum Cost to Set Cooking Time

1. Their thinking

This question is actually quite direct , Calculate according to the meaning of the question , The only thing to notice is that , Because seconds can reach 99, Therefore, there may be multiple settings at some times , You need to compare the two sizes .

2. Code implementation

give python The code implementation is as follows ：

class Solution:
    def minCostSetTime(self, startAt: int, moveCost: int, pushCost: int, targetSeconds: int) -> int:
        minute, second = targetSeconds // 60, targetSeconds % 60
        def get_cost(minute, second):
            digits = (f"{
      minute:02d}" + f"{
      second:02d}").lstrip("0")
            res, pre = 0, str(startAt)
            for ch in digits:
                res += pushCost
                if ch != pre:
                    res += moveCost
                pre = ch
            return res
        
        res = get_cost(minute, second) if minute < 100 else math.inf
        if minute > 0 and second + 60 < 100:
            res = min(res, get_cost(minute-1, second+60))
        return res

The submitted code was evaluated ： Time consuming 59ms, Take up memory 13.9MB.

4. Topic four

The link to question 4 is as follows ：

• 2163. Minimum Difference in Sums After Removal of Elements

1. Their thinking

The idea of this question is to choose a separation point in the middle , Left selection n The smallest element , Select... On the right n The biggest element , Then calculate the difference .

therefore , We are just traversing the separation point in the middle , Then count the left and right front n The sum of the largest or smallest elements , Then calculate the difference . The maintenance of the former array can be efficiently implemented through heap arrangement .

2. Code implementation

give python The code implementation is as follows ：

class Solution:
    def minimumDifference(self, nums: List[int]) -> int:
        n = len(nums) // 3
        left = [-x for x in nums[:n]]
        right = nums[-n:]
        ls, rs = sum(left), sum(right)
        heapq.heapify(left)
        heapq.heapify(right)
        
        cnt = [[ls, rs] for _ in range(n+1)]
        for i in range(n):
            heapq.heappush(left, -nums[n+i])
            lpop = heapq.heappop(left)
            cnt[i+1][0] = cnt[i][0] - nums[n+i] - lpop
            
            heapq.heappush(right, nums[2*n-1-i])
            rpop = heapq.heappop(right)
            cnt[n-1-i][1] = cnt[n-i][1] + nums[2*n-1-i] - rpop
        return -max(sum(x) for x in cnt)         

The submitted code was evaluated ： Time consuming 3545ms, Take up memory 46.3MB.