代码随想录算法训练营第四期第二天| 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵II

没想到强度会这么高，一天3题的话，前面我还是仗着自己刷过多次赶赶进度，后面要怎么办啊，最近工作上我也在给自己上强度，但是感觉没休息好，有点白搭的味道，白天精神不好，其实心态也不好。

前两天看到了李贺的那首《苦昼短》，读到“吾不识青天高，黄地厚，唯见月寒日暖，来煎人寿”，倏然一阵凉意，时光如水，转瞬即逝，不能再虚度光阴了。

977. 有序数组的平方

# 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

# 示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

#

# 示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        slow, fast = 0, len(nums) - 1
        res = []
        while slow <= fast:
            ss = nums[slow]*nums[slow]
            ff = nums[fast]*nums[fast]
            if ss > ff:
                res.append(ss)
                slow += 1
            else:
                res.append(ff)
                fast -= 1
        return res[::-1]

这里我看了一下卡哥的视频，从后面开始赋值，确实比我最后还反转一次要优秀

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，

返回 0 。

输入：target = 7, nums = [2,3,1,2,4,3]

输出：2

解释：子数组[4,3]是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]

输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]

输出：0

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        slow, fast = 0, 0
        n = len(nums)
        sum_ = 0
        res = []
        for i in range(n):
            if nums[i] >= target:
                return 1
            sum_ += nums[i]
            while sum_ >= target:
                res.append(i-slow+1)
                sum_ -= nums[slow]
                slow += 1
        if len(res) == 0:
            return 0
        else:
            return min(res)

if __name__ == '__main__':
    target = 7
    nums = [2, 3, 1, 2, 4, 3]
    aa = Solution()
    s= aa.minSubArrayLen(target,nums)
    print(s)   

#有点感慨，仔细想了一会儿，我居然做出来了，虽然这里多设定了一个没用的fast变量

59.螺旋矩阵II

# 给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

# 输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        startx, starty = 0, 0
        index = 1
        count = 1
        num = n // 2
        res = [[0] * n for _ in range(n)]
        for i in range(num):
            for _ in range(n - index): # round 1
                res[startx][starty] = count
                starty += 1
                count += 1
            for _ in range(n - index): # round 2
                res[startx][starty] = count
                startx += 1
                count += 1
            for _ in range(n - index): # round 3
                res[startx][starty] = count
                starty -= 1
                count += 1
            for _ in range(n - index): # round 4
                res[startx][starty] = count
                startx -= 1
                count += 1
            startx += 1
            starty += 1
            index += 2
        if n % 2 == 1:
            res[num][num] = count
        return res

"""
00 01 02 03
10 11 12 13
20 21 22 23
30 31 32 33

a
x: 0->0 y:0->3
x: 0->3 y:3->3
x: 3->3 y:3->0
x: 3->0 y:0->0
有点感慨吧，这道题其实在9月5号左右有仔细看过，也研究过卡哥的视频和方法，但确实解答的很吃力
没想到时隔两个月，我能够自己想起来方法，然后一点点调试，把这道中等题目写出来
加油，还是会有进步的
"""
if __name__ == '__main__':
    ss = Solution()
    n = 6
    res = ss.generateMatrix(n)
    for i in res:
        print(i)

结果如下：

 就这样吧，有点信心，就是太晚了。