记录在力扣上面做的周赛题，给出自己的解题方法以及学习到的好的解题思路。

第132场双周赛（20240609考）

3174. 清除数字

给你一个字符串，你的任务就是重复一下操作，删除所有的数字字符， 返回删除后的剩下的字符串。

• 删除第一个数据字符以及它左边最近的非数字字符,

利用栈的特性，是字符就压栈，如果是数字，就判断栈是否为空，如果不为空，就出栈，最后返回倒序返回所有栈元素，这里用StringBuilder先进后出来模拟栈。

Java

class Solution {
    public String clearDigits(String s) {
        StringBuilder ans = new StringBuilder();
        for(char c: s.toCharArray()){
            if(Character.isDigit(c)){
                ans.deleteCharAt(ans.length()-1);
            }else{
                ans.append(c);
            }
        }
        return ans.toString();
    }
}

Python

class Solution:
    def clearDigits(self, s: str) -> str:
        ans = list()
        for i in range(len(s)):
            if s[i].isdigit():
                ans.pop()
            else:
                ans.append(s[i])
        return ''.join(ans)

JS

Code...

3175. 找到连续赢 K 场比赛的第一位玩家

题目给出不相同的skil整数l数组表示n为玩家的技能，所有玩家从编号0到n-1排列，比赛方式如下：返回比赛第一位连续赢下k场比赛的玩家。

• 队列中最前面两名玩家进行一场比赛，技能等级更高的玩家胜出
• 比赛后，获胜者保持在队列头，失败者在队列末尾

题目与1535. 找出数组游戏的赢家相同。

Java

class Solution {
    public int findWinningPlayer(int[] skills, int k) {
        int mx = 0; // 定义赢k次的下标
        int win = 0;
        for(int i=1;i<skills.length && win < k;i++){
            if(skills[i] > skills[mx]){
                mx = i;
                win = 0;
            }
            win++;
        }
        return mx;
    }
}

Python

Code...

JS

Code...

第 125 场双周赛（20240302考）

100231. 超过阈值的最少操作数 I

给你一个下标从0开始的整数数组nums和一个整数k。

一次操作中，你可以删除nums中最小的元素

你需要使数组中的所有元素都大于或等于k，请你返回需要的最少操作次数。

循环nums，如果nums[i] < k， 那么结果就加一，最后返回。

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        ans = 0
        for i in nums:
            if i < k:
                ans += 1
        return ans

100232. 超过阈值的最少操作数 II ☆

给你一个下标从0开始的整数数nums和一个整数k。

一次操作中，你将执行：

• 选择nums中最小的两个整数x和y
• 将x和y从nums中删除
• 将$min(x,y)*2+max(x,y)$添加到数组中的任意位置。

注意：只有当nums至少包含两个元素是，你才可以执行以上操作。

你需要是数组中的所有元素都大于或等于k，请你返回需要的最少操作次数。

这里我们需要学习到一个新的数组结构，就是堆，也可以了解一下堆排序。

要求每次选取最小的两个数，在给数组加上最小数*2 + 次小数这个元素，知道最小元素不小于k。

由于数组每次长度减一，因此操作次数不会过多，于是考虑直接模拟。考虑能动态删除最小元素和添加元素的数据结构，使用堆。

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        heapify(nums)  
        cnt = 0
        while nums[0] < k:
            n,m = heappop(nums), heappop(nums)
            x = n * 2 + m 
            heappush(nums, x)
            cnt += 1
        return cnt

在java里面就是用优先级队列来解题。

class Solution {
    public int minOperations(int[] nums, int k) {
        PriorityQueue<Long> queue = new PriorityQueue<>();
        for(int i: nums){
            queue.add((long)i);
        }
        int res = 0;
        while(queue.peek() < k){
            long m1 = queue.poll(), m2 = queue.poll();
            long next = Math.min(m1, m2) * 2 + Math.max(m1, m2);
            queue.add(next);
            ++res;  
        }
        return res;

    }
}

第124场双周赛（20240217考）

昨天晚上第一次参加力扣的竞赛，在最后半个小时，终于答对了一道简单题。算是在力扣里面走出了第一步了。

100221. 相同分数的最大操作数目 I

题目给出一个整数数组nums，如果nums至少包含2个元素，你可以执行一下操作：

• 选择nums中前两个元素并将他们删除

一次操作的分数是被删除元素的和

在确保所有操作分数相同的前提下，请你求出最多能进行多少次操作。

看给出的题目样例，我们只需要保存前两个元素的和，然后依次向后遍历两位，如果值与前面两位相同，次数加一，不相等的话，就直接返回。

这里有几个注意点：

1、如果是用for循环，步长为2来处理的话，需要判断是否下表越界，因为有些数组是奇数个，有些是偶数个，这样导致最后只存在一个元素的情况。

2、第二个就是，如果中间存在着不满足条件的元素，需要直接返回

Java

class Solution {
    public int maxOperations(int[] nums) {
        int count = 0;
        int score = nums[0] + nums[1];
        int n = nums.length;
        for(int i=0;i<n;i=i+2){
            if(i+1<n){
                int _score = nums[i] + nums[i+1];
                if(score == _score){
                    count++;
                }
                else{
                    break;
                }
            }
        }
        return count;
    }
}

Python3

class Solution:
    def maxOperations(self, nums: List[int]) -> int:
        count = 0
        score = nums[0] + nums[1]
        for i in range(0, len(nums), 2):
            if i+1 < len(nums):  # 防止数组越界
                _score = nums[i] + nums[i+1]
                if score == _score:
                    count += 1
                else:
                    break  # 遇到后面不满足的就直接退出
        return count

3039. 进行操作使字符串为空

给你一个字符串s

请你进行以下操作直到s为空

• 每次操作一次遍历a到z，如果当前字符出现在s中，那么删除出现位置最早的字符。

请你返回最后一次操作之前的字符串s

参考灵神给出的题解。

作者：灵茶山艾府 统计字母出现次数和最后一次出现的下标（Python/Java/C++/Go）

提示 1 最后一次操作时，剩下的字母互不相同。(因为如果有相同字母，那么操作后还有剩余字母。)

提示 2 设字母的最大出现次数为mx

由于删除是从左到右进行的，最后剩下的就是出现次数等于 mx\textit{mx}mx 的靠右字母（相同字母取出现位置最右的）。

class Solution:
    def lastNonEmptyString(self, s: str) -> str:
        last = {c: i for i, c in enumerate(s)}
        cnt = Counter(s)
        mx = max(cnt.values())
        ids = sorted(last[ch] for ch, c in cnt.items() if c == mx)
        return ''.join(s[i] for i in ids)

第123场双周赛（20240203考）

3024. 三角形类型

先判断是不是三角行，如果是在判断是哪一类三角形。

class Solution:
    def triangleType(self, nums: List[int]) -> str:
        # is triangle
        a,b,c = nums
        if a+b<=c or a+c<=b or b+c<=a:
            return 'none'
        _nums = set(nums)
        if len(_nums) == 1:
            return 'equilateral'
        if len(_nums) == 2:
            return 'isosceles'
        if len(_nums) == 3:
            return 'scalene'
        return 'none'

看了灵神的题解，不得不说，他们的题解的思路就是比现在的自己要好，要精髓。

class Solution:
    def triangleType(self, nums: List[int]) -> str:
        nums.sort()
        a, b, c = nums

        if a+b <= c: # 排序后，只需要比较a+b和c
            return 'none'
        if a == c:  # 排序了，如果a==c，说明b==c
            return 'equilateral'
        if a == b or b == c:
            return 'isosceles'
        return 'scalene'

Changelog

Last Updated: View All Changelog

• 3d2e0-

  feat(wiki): algo: 算法总结

  On 3/30/25