Python 练习数组 [遍历]: LeetCode 485 495 414

Candiwind~

已于 2024-01-10 18:58:38 修改

阅读量354

点赞数 9

分类专栏： LeetCode 文章标签： python leetcode 算法

于 2024-01-10 14:49:16 首次发布

本文链接：https://blog.csdn.net/weixin_46756690/article/details/135495204

版权

LeetCode 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

从这一篇开始先按照下面的做题顺序练习
https://www.jianshu.com/p/460edbe3dc36

Python 练习数组: LeetCode 485 最大连续 1 的个数

给定一个二进制数组nums ，计算其中最大连续1的个数。

示例 1：
输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续1 ，所以最大连续1的个数是3.
示例 2:
输入：nums = [1,0,1,1,0,1]
输出：2

提示：
1 <= nums.length <= 1e5
nums[i]不是0就是1.

485-题解一

一次遍历
设置两个变量ones_num和max_ones_num，记录当前的连续1数量和全局最大连续1数量
遍历一次数组，如果元素为1则ones_num加1，否则更新max_ones_num并将ones_num清零

class Solution(object):
    def findMaxConsecutiveOnes(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max_ones_num = 0
        ones_num = 0
        for num in nums:
            if num == 1:
                ones_num += 1
            else:
                max_ones_num = max(max_ones_num, ones_num)
                ones_num = 0

        max_ones_num = max(max_ones_num, ones_num)
        return max_ones_num

时空复杂度评测结果波动较大，不过基本分布在前20%

485-题解二

字符串处理
使用Python的字符串处理方法，也可以实现一样的功能，同时代码更简洁

class Solution(object):
    def findMaxConsecutiveOnes(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums_str = "".join(map(str, nums))
        nums_str_ones = nums_str.split("0")
        return max([len(ones) for ones in nums_str_ones])

时空复杂度与题解一相当

Python 练习数组: LeetCode 495 提莫攻击

在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。
当提莫攻击艾希，艾希的中毒状态正好持续duration秒。
正式地讲，提莫在t 发起攻击意味着艾希在时间区间[t, t + duration - 1]（含t和t + duration - 1）处于中毒状态。如果提莫在中毒影响结束前再次攻击，中毒状态计时器将会重置，在新的攻击之后，中毒影响将会在duration秒后结束。
给你一个非递减的整数数组timeSeries，其中timeSeries[i]表示提莫在timeSeries[i]秒时对艾希发起攻击，以及一个表示中毒持续时间的整数duration。
返回艾希处于中毒状态的总秒数。

示例 1：
输入：timeSeries = [1,4], duration = 2
输出：4
解释：提莫攻击对艾希的影响如下：

第1秒，提莫攻击艾希并使其立即中毒。中毒状态会维持2秒，即第1秒和第2秒。
第4秒，提莫再次攻击艾希，艾希中毒状态又持续2秒，即第4秒和第5秒。

艾希在第1、2、4、5 秒处于中毒状态，所以总中毒秒数是4 。

示例 2：
输入：timeSeries = [1,2], duration = 2
输出：3
解释：提莫攻击对艾希的影响如下：

第1秒，提莫攻击艾希并使其立即中毒。中毒状态会维持2秒，即第1秒和第2秒。
第2秒，提莫再次攻击艾希，并重置中毒计时器，艾希中毒状态需要持续2秒，即第2秒和第3秒。
艾希在第1、2、3 秒处于中毒状态，所以总中毒秒数是3。

提示：
1 <= timeSeries.length <= 1e4
0 <= timeSeries[i], duration <= 1e7
timeSeries 按非递减顺序排列

495-题解

一次遍历
通过一次遍历，就可以统计出总的持续时间

class Solution(object):
    def findPoisonedDuration(self, timeSeries, duration):
        """
        :type timeSeries: List[int]
        :type duration: int
        :rtype: int
        """
        all_duration = 0
        for i in range(len(timeSeries)-1):
            all_duration += min(timeSeries[i+1] - timeSeries[i], duration)
        all_duration += duration
        return all_duration

Python 练习数组: LeetCode 414 第三大的数

给你一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。

示例 1：
输入：[3, 2, 1]
输出：1
解释：第三大的数是1。

示例 2：
输入：[1, 2]
输出：2
解释：第三大的数不存在, 所以返回最大的数2。

示例 3：
输入：[2, 2, 3, 1]
输出：1
解释：注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。
此例中存在两个值为2的数，它们都排第二。在所有不同数字中排第三大的数为1。

提示：
1 <= nums.length <= 1e4
-2^31^ <= nums[i] <= 2^31^ - 1

进阶：你能设计一个时间复杂度 O(n) 的解决方案吗？

414-题解一

一次遍历
通过一次遍历，得到数组中前三大的数。注意要排除出数组的重复元素。时间复杂度为O(n)

class Solution(object):
    def thirdMax(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max = -2**32
        second_max = -2**32
        third_max = -2**32
        for num in nums:
            if num == max or num == second_max or num == third_max:
                continue
            if num > max:
                third_max, second_max, max = second_max, max, num
            elif num > second_max:
                third_max, second_max = second_max, num
            elif num > third_max:
                third_max = num

        if third_max != -2**32:
            return third_max
        else:
            return max

414-题解二

内置方法去重排序
使用set()方法实现Python列表元素去重，同时可以采用sorted()方法快速得到排序后的结果，直接得到列表中第三大的数

class Solution(object):
    def thirdMax(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums_norepeat = list(set(nums))
        if len(nums_norepeat) < 3:
            return max(nums_norepeat)
        return sorted(nums_norepeat)[-3]