训练营Day 2 : 977.有序数组的平方 || 209.长度最小的子数组 || 59.螺旋矩阵II (围绕双指针)

977.有序数组的平方

感慨确实是python的封装使得刷题会easy很多，甚至一行代码就可以搞定了；但是这个题要是使用C++做，对于排序这部分还是需要再回顾的，感觉忘得差不多了

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        return sorted([i**2 for i in nums])

补：但是看了解析之后，其实这道题因为输入的数组是单调有序的，可以走的方向是从双指针得角度去考虑的，其实哪怕是C++其实也可以不用考虑排序的

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        #for i in range(len(nums)):
        #    nums[i] = nums[i]*nums[i]
        #return sorted([i**2 for i in nums])
        left = 0
        right = len(nums) -1
        results = [i for i in nums]
        #print(results)
        k = len(nums) -1
        while left <= right:
            if (nums[left]**2) > (nums[right]**2):
                results[k] = nums[left]**2  
                left +=1
            else:
                results[k] =nums[right]**2
                right -=1
            k -=1

        return results

209.长度最小的子数组

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        results = float("inf")   # 定义一个无限大的数
        total = 0
        for num in nums:
            if num == target:
                return 1
            total += num
        if total < target:
            return 0 

        left, right = 0,0
        sum = 0
        for num in nums:
            sum += num
            while sum >= target:
                results = min(results, right - left +1)
                sum -= nums[left]
                left +=1
            right +=1
        return results

补： 这里有一点是只去return 最小的那个长度，如果需要去return 具体的子数组，那么我觉得还是需要建立一个dict来记录left和right，这里的key值可以就是最小的子数组长度， 感觉就是记录下来最小的长度时的right和left即可了，之后再进行返回

59.螺旋矩阵II

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        nums = [[0] * n for _ in range(n)]  #构建二维数组，这个刚开始做的时候忘了怎么构建了
        startX, startY = 0,0 
        offset =1  
        count= 1
        while (offset <= (n//2)):
            for i in range(startY, n - offset):
                nums[startX][i] = count
                count +=1
            for i in range(startY, n - offset):
                nums[i][n - offset] = count
                count +=1
            for i in range(n - offset, startX,-1):
                nums[n - offset][i] = count
                count +=1
            for i in range(n - offset, startY,-1):
                nums[i][startY] = count
                count +=1
            startY +=1
            startX +=1
            offset +=1
        print(count)
        if n%2==1:
            nums[n//2 ][n//2 ] = count
        return nums

核心控制循环不变量，最开始要分析这个循环具有的特点，自己在草稿纸上推演了一下，分为了四部分，但是看了视频又意识到循环时“每条边的处理逻辑应该一致”，确定是左闭右开。

offset是循环继续的点，四个边的长度在下降依赖于该变量；

还有一点忘记的是在python中构建二维数组，这个也是看了样例才反应过来；

nums = [[0] * n for _ in range(n)]