双周赛：

5984. 拆分数位后四位数字的最小和

class Solution:def minimumSum(self, num: int) -> int:a, b, c, d = sorted(list(map(int, str(num))))return 10 * (a + b) + c + d

str(num)得到字符串序列，然后用map函数对序列的每个字符转换为数字，最后变为列表并且排序，最小的两个数 a、b 一定在十位所以乘10，个位则是 c 和 d。

5985. 根据给定数字划分数组

我的：

class Solution:def pivotArray(self, nums: List[int], pivot: int) -> List[int]:s = []e = []l = []for i in nums:if i < pivot:s.append(i)elif i == pivot:e.append(i)else:l.append(i)return s+e+l

大佬的：

class Solution:def pivotArray(self, nums: List[int], pivot: int) -> List[int]:ans = []for x in nums:if x < pivot:ans.append(x)for x in nums:if x == pivot:ans.append(x)for x in nums:if x > pivot:ans.append(x)return ans

区别不大，我是用三个列表分别记录小于、等于和大于 pivot 的数，然后把它们加起来。当然也可以循环 nums 三次，依次添加三种数进入 ans 中。

5986. 设置时间的最少代价

class Solution:def minCostSetTime(self, startAt: int, moveCost: int, pushCost: int, targetSeconds: int) -> int:ans = 10**9 for tmp in range(10000):  # 0000 到 9999 即所有情况a = list(map(int, str(tmp)))last = startAtneed = 0for x in a:if x != last:need += moveCostlast = xneed += pushCostif tmp // 100 * 60 + tmp % 100 == targetSeconds:  # 正好是目标时间ans = min(ans, need)return ans

这题的基本思路是分类讨论，但是有点复杂。大佬的思路简单粗暴，直接枚举四个数字的所有情况，计算其代价，如果这四个数字对应的正好是目标时间，则比较其代价与当前最少代价，更新最少代价。

5987. 删除元素后和的最小差值

class Solution:def minimumDifference(self, nums: List[int]) -> int:n = len(nums) // 3left = [0 for _ in range(3 * n + 1)]        #左侧最小的n个数的和right = [0 for _ in range(3 * n + 1)]       #右侧最大的n个数的和l_max = []                          #每次要删除那个最大的数for i in range(3 * n):left[i + 1] = left[i] + nums[i]heapq.heappush(l_max, -1 * nums[i]) # 最大堆if n <= i:    # 堆中最多有 n 个元素，一旦超过就开始 popleft[i + 1] -= -1 * l_max[0]   # 最大的数会被 pop，所以要减去heapq.heappop(l_max)  # 删除堆中最大的数r_min = []                          #每次要删除那个最小的数for i in range(3 * n - 1, -1, -1):right[i] = right[i + 1] + nums[i]heapq.heappush(r_min, nums[i])  # 最小堆if i < 2 * n:  # 堆中最多有 n 个元素，一旦超过就开始 popright[i] -= r_min[0]  # 最小的数会被 pop，所以要减去heapq.heappop(r_min)  # 删除堆中最小的数res = float('inf')for i in range(n, 2 * n + 1):  # 枚举分割点cur = left[i] - right[i]   # 前面部分减后面部分的值res = min(res, cur)return res

周赛

6000. 对奇偶下标分别排序

我的：

class Solution:def sortEvenOdd(self, nums: List[int]) -> List[int]:n = len(nums)odds = [nums[i] for i in range(n) if i % 2 == 1]evens = [nums[i] for i in range(n) if i % 2 == 0]odds.sort(reverse=True)evens.sort()ans = []for i in range(n):if i % 2 == 0:ans.append(evens[i // 2])else:ans.append(odds[(i-1) // 2])return ans

大佬的：

class Solution:def sortEvenOdd(self, nums: List[int]) -> List[int]:a = sorted(nums[0::2])b = sorted(nums[1::2], reverse=True)to_ret = []while len(a)+len(b) > 0 :if len(a) > 0 :to_ret.append(a.pop(0))if len(b) > 0 :to_ret.append(b.pop(0))return to_ret

优化点：1、取奇偶下标的元素不需要判断下标的奇偶，只需要设置步长为 2 ，起点为 0、1即可；2、排序应习惯用 sorted ，可以少写一行；3、要从头开始取元素，可以用 pop(0)。

6001. 重排数字的最小值

我的：

class Solution:def smallestNumber(self, num: int) -> int:if num < 0:num_list = list(map(int, str(num)[1:]))num_list.sort(reverse=True)ans = 0for i in range(len(num_list)):ans = ans * 10 + num_list[i]ans = -anselif num == 0:ans = 0else:num_list = list(map(int, str(num)))num_list.sort()num_zeros = num_list.count(0)ans = 0if num_zeros == 0:for i in range(len(num_list)):ans = ans * 10 + num_list[i]else:ans = num_list[num_zeros]for i in range(num_zeros):ans = ans * 10for i in range(num_zeros+1, len(num_list)):ans = ans * 10 + num_list[i]return ans

大佬的：

class Solution:def smallestNumber(self, num: int) -> int:if num == 0 :return numif num < 0 :return -int(''.join(sorted(str(num)[1:], reverse=True)))if num > 0 :num = str(num)ct = len([1 for t in num if t == '0'])num = sorted([t for t in num if not t == '0'])return int(num[0] + '0'*ct + ''.join(num[1:]))

虽然都是分类讨论找规律，但是在表达上我还是不够简洁。实际上就三种情况：num 等于 0，则返回 0；num 小于 0，则按照数字从大到小返回；num 大于 0，则取最小的正数作为第一个数，然后跟 0，最后是其余正数。

6002. 设计位集

class Bitset:def __init__(self, size: int):self.size = sizeself.listt = [0] * sizeself.vcount = 0   # 记录 1 的个数self.isflip = False # 记录是否翻转def fix(self, idx: int) -> None:if not self.isflip :if not self.listt[idx] == 1 :self.vcount += 1self.listt[idx] = 1else :if not self.listt[idx] == 0 :self.vcount += 1self.listt[idx] = 0def unfix(self, idx: int) -> None:if not self.isflip :if not self.listt[idx] == 0 :self.vcount -= 1self.listt[idx] = 0else :if not self.listt[idx] == 1 :self.vcount -= 1self.listt[idx] = 1def flip(self) -> None:self.isflip = not self.isflipself.vcount = self.size - self.vcountdef all(self) -> bool:return self.vcount == self.sizedef one(self) -> bool:return self.vcount > 0def count(self) -> int:return self.vcountdef toString(self) -> str:if not self.isflip :return ''.join([str(t) for t in self.listt])else :return ''.join([str(1-t) for t in self.listt])

这题很容易超时，必须优化，而优化的点主要是两个：1、翻转操作不需要真的翻转，只需要用一个布尔标志记录是否处于翻转状态即可；2、由于初始时全为 0，所以在赋值 1 时可以用一个变量记录 1 出现的次数，这样就不用每次都计算有多少个 1 了。

6003. 移除所有载有违禁货物车厢所需的最少时间

正统的做法是动态规划，参考这篇题解

class Solution:def minimumTime(self, s: str) -> int:n = len(s)suf = [0] * (n + 1)for i in range(n - 1, -1, -1):suf[i] = suf[i + 1] if s[i] == '0' else min(suf[i + 1] + 2, n - i)ans = suf[0]pre = 0for i, ch in enumerate(s):if ch == '1':pre = min(pre + 2, i + 1)ans = min(ans, pre + suf[i + 1])return ans

另外有一种做法挺有意思，如图所示：

class Solution:def minimumTime(self, s: str) -> int:lists = [1 if i == "1" else -1 for i in s]for i in range(1, len(lists)):if lists[i - 1] < 0:lists[i] += lists[i - 1]return len(lists) + min(min(lists), 0)