【100Days of 100 line Code】12 day

25号LeetCode复盘

#缺失的第一个正数

相对比较简单，但是难度是困难。。

先对特殊数据进行判断，

一.空集，空集的话 缺失的第一个正整数就是1，so return 1

二.最小的数字大于1，同样的返回1

如果不是上面两种情况，则对数组进行遍历

判断是否存在nums[i]<0,nums[i+1]>1。若存在这种情况，则nums[i]为负数，而nums[i+1]为大于1的正整数，可得出缺失的最小的正整数为1

判断是否存在nums[i]>=0,nums[i+1]>nums[i]+1。若存在这种情况，则nums[i]与nums[i+1]都大于0，且nums[i]与nums[i+1]不是连续的正整数，可得出

缺失的最小正整数为nums[i]+1

若不存在上述情况，则证明数组元素为连续的正整数，答案即为最大元素值加一

class Solution(object):
    def firstMissingPositive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if nums == [] :
            return 1
        nums.sort()
        if nums[0]>0 and nums[0] != 1:
            return 1
        for i in range(len(nums)-1):
            if nums[i]<0 and nums[i+1]> 1:
                return 1
            elif nums[i]>=0 and nums[i+1]>nums[i]+1:
                return nums[i]+1
        return nums[-1]+1

这种算法比较初级，提交之后看了另外一个大佬的代码，思路很清奇

设一个初始值res=0

当数组元素nums[i]=res,res+=1

最后就返回res，是不是很厉害。手动笑哭

res = 0
for i in nums:
    if i == res :
        res += 1

# 转置矩阵

这个也算是比较easy的困难题了

同样的先判断特殊例，空列表，如果是的话直接返回''就好

然后新建一个列表A

两个循环嵌套，外层循环是len(A[0])次，决定新数组的子列表个数，内层循环是len(A)，决定新列表里每个子列表由几个元素组成

再创建一个新列表B，储存每个子列表的元素

当内层循环完一次之后将列表B添加到列表A中即可

class Solution(object):
    def transpose(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        if A == False :
            return ''
        new_A = []
        for j in range(len(A[0])):
            new_list = []
            for i in range(len(A)):
                new_list.append(A[i][j])
            new_A.append(new_list)
        return new_A