【100Days of 100 line Code】5 day

刷了十道easy题，简单是简单，坑也是真的多啊。

 半夜三点了，好困

LeetCode #14 最长公共前缀

判断是否为空列表，判断是否有空字符串在列表里面，对列表进行去重处理。对列表最短元素进行查找，（最短元素必满足最长公共前缀条件。水桶短板原理）返回最短元素位置，个数，是否全为1个长度，最短长度 四个维度。为1长度超过一个，则为没有最长公共前缀（以对列表进行去重处理）。如果列表只有一个元素，则返回这个元素。如果不全为一个长度且最短长度为1.判断列表内所有元素是否有公共前缀。不满足上列条件则证明有公共前缀在进行判断，取最短列表元素作为对比目标，依次对比，找到断点t，返回目标[0:t]

这题坑是真的有很多，半天时间花这道题上面了。。。

class Solution(object):
    def longestCommonPrefix(self, strs):
        if strs != []:
            if '' in strs:
                return ''
            strs = list(set(strs))
            shortest, longflag, seat, onestr = self.shortestStr(strs)
            contrast_strs = strs[seat]
            strs.pop(seat)
            if onestr > 1:
                return ''
            if len(strs) == 0:
                return contrast_strs
            if longflag == False and shortest == 1:
                for i in range(len(strs)):
                    if contrast_strs != strs[i] :
                        break
                    else :
                        return ''
            t = 0
            while t < shortest:
                for i in range(len(strs)):
                    if contrast_strs[t] == strs[i][t]:
                        a = contrast_strs[0:t]
                    else:
                        return contrast_strs[0:t]
                t += 1
            return contrast_strs[0:t]
        else :
            return ''

    def shortestStr(self,strs):
        lenght = 1000000
        flag = True
        seat = 0
        oneTime = 0
        for i in range(len(strs)):
            if len(strs[i]) < lenght:
                lenght = len(strs[i])
                seat = i
            if len(strs[i]) != 1:
                flag = False
            else :
                oneTime += 1
        return lenght, flag, seat, oneTime

LeetCode #20 有效的括号

这题比较简单，创建一个括号类型字典，一个新的列表储存值。

字符串为空值返回true，这里踩了一次坑。再判断字符串长度，如果除2有余数，不可能满足条件，返回false。

判断第一个字符 是否再字典中，不在的话，即不满足条件。

从s[1]开始查找。如果s[i]在括号类型字典内，且与之前存的类型对应的话，新建列表删除该符号，如果不在s[i]内的话，

存入新建列表，与后面的进行匹配。

最后返回 new_list == [] 若全部匹配，则为true，有值未被删除，则为false

class Solution(object):
    def isValid(self, s):
        bracketTpye ={
            ')':'(',
            '}':'{',
            ']':'['
        }
        new_list = []
        if s == '' :
            return True
        if len(s)%2 != 0 :
            return False
        if s[0] not in bracketTpye:
            new_list.append(s[0])
        else :
            return False     
        for i in s[1:] :
            if i in bracketTpye and bracketTpye[i] == new_list[-1]:
                new_list.pop()
            else :
                new_list.append(i)
        return new_list == []

LeetCode #28. 实现strStr()

这题比较简单，判断目标字符串是否等于对象字符串里面，或者目标字符串为空值 

不在的话判断目标字符串是否存在于对象字符串

在的话，直接查找位置，不在返回值

class Solution(object):
    def strStr(self, haystack, needle):
        if needle == '' or haystack == needle :
            return 0
        else :
            if needle in haystack :
                for i in range(0,len(haystack)-len(needle)+1):
                    if haystack[i:len(needle)+i] == needle:
                        return i
            return -1

LeetCode #53 最大子序和

把当前位置的数与前一位之和相加，若大于当前位置的数的话，把当前位置的数替换成两数之和。

在对nums进行排序，取最大值

class Solution:
    def maxSubArray(self, nums):
        for i in range(1,len(nums)):
            if nums[i]+nums[i-1] > nums[i]:
                nums[i] = nums[i]+nums[i-1]
        nums.sort()
        return nums[-1]

LeetCode #最后一个单词的长度

对字符串进行倒序处理。

创建一个状态指针，指示英文字母之前有没有空格。

从后开始查找，遇到空格且指针指示空格之前没有字母，直接跳过

遇到英文字母，对指针状态进行改变，长度变量加一

遇到空格，指针指示空格之前有字母，跳出循环。

class Solution(object):
    def lengthOfLastWord(self, s):
        s = s[::-1]
        flag = True
        strlong = 0
        for i in range(len(s)):
            if s[i]== " " and flag :
                continue
            elif s[i] != ' ':
                flag = False
                strlong += 1
            else :
                break
        return strlong

LeetCode #69 x的平方根

二分法

用了一次循环，内存溢出，然后改用二分查找，AC了

设置左坐标指针=0，右坐标指针x

判断 左边小于右边

mid = 等于左右两数之和的一半

当mid的平方大于时x在左边，移动右指针

当 mid的平方小于时x在右边，移动左指针

class Solution:
    def mySqrt(self, x):
        left=0;right=x
        while left<right:
            mid=int((left+right)/2)
            if x<mid**2:
                right=mid
            else:
                left=mid+1
        if left>1:
            return left-1
        else:
            return left

LeetCode #70 爬楼梯

递推，类似于斐波那契数列。每一集台阶可以走的种数等于前两集之和

创建一个数组，储存每一级台阶可以走的种数。

1集台阶 1种 1步

2集台阶 2种 1步1步 2步

3集台阶 3种 1步1步1步 2步1步 1步2步

4集台阶 5种 3+2

5集台阶 8种 5+3

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        pace = []
        pace.append(1)
        pace.append(1)
        for i in range(2, n+1):
            pace.append(pace[i-1]+pace[i-2])
        return pace[n]

LeetCode #88 合并两个有序数组

合并，排序

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        for i in range(m,m+n):
            nums1[i] = nums2[i-m]
        nums1.sort()