27:簡單題就是簡單題 跟之前做的刪重複的一樣啊

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        i = 0
        for each in nums:
            if each != val:
                nums[i] = each
                i 
 
+= 1
        return i

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/remove-element/solution/wa-ka-ka-ka-ka-by-yizhu-jia-qzu9/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

28:

對不起對不起對不起 實在不會寫KMP演算法/.... 所以 對不起 對不起 對不起

        if needle not in haystack:
            return -1
        elif needle 
 
== '':
            return 0
        else:
            for i in range(len(haystack)):
                if haystack[i:len(needle)+i] == needle[:]:
                    return i

29實現除法 邊界問題好煩人

        def div2(a,b):
            if a<b :
                return 0
            count = 0
            sav = b
            
 
while b +b <= a:
                b = b+b
                count += 1
            if a - b >= sav:
                return 2**count + div2(a-b,sav)
            else:
                return 2**count


        flag = 0
        if (dividend >0 and divisor<0) or(dividend <0 and divisor>0):
            flag = 1
        dividend = abs(dividend)
        divisor = abs(divisor)
        count = div2(dividend,divisor)
        if count > 2**31-1:
            if flag == 0:
                count = 2**31-1 
            else:
                count = 2**31
        if flag == 1:
            return -count
        return count

30:困難題!!!!! 我是看答案思路自己寫的程式碼 然後 全靠除錯.........

class Solution(object):
    def findSubstring(self, s, words):
        """
        :type s: str
        :type words: List[str]
        :rtype: List[int]
        """
        n = len(words[0])
        nw = len(words)
        ls = len(s)
        dict1 = {}
        dict2 = {}
        rel = []
        for each in words:
            if each not in dict1:
                dict1[each] = 1
                dict2[each] = 0
            else:
                dict1[each] += 1            #建立兩個字典
        for i in range(n):                  #從0到n-1作為開始去遍歷
            pos = i    
            j = 0                   
            for each in dict2:
                dict2[each] = 0               #每次遍歷初始化  pos指向初始  字典清空  j表示視窗遍歷位置要指向開頭
            while pos < ls-n*nw +n:
                tar = s[pos+j*n:pos+n*(j+1)]              # 每次分析一個詞的長度
                if tar in dict2:
                    dict2[tar] += 1 
                    if dict1 == dict2:                      #兩個字典相等 去掉視窗起始位置後移n 加入結果 繼續
                        rel.append(pos)
                        dict2[s[pos:pos+n]] -= 1
                        pos += n
                    elif dict2[tar]>dict1[tar]:                  #大了  就不停去掉開始的 直到值相等 
                        FALG = 1                                   #因為最多大一 所以去一個就夠
                        while FALG:
                            dict2[s[pos:pos+n]] -= 1
                            if s[pos:pos+n] == tar:
                                FALG = 0
                            pos += n
                            j -= 1
                        j += 1
                    else:
                        j += 1                             #無事發生  往後推一個視窗
                else:                                 #出現沒有的單詞 就把視窗往後移 越過這個視窗 並清空字典
                    pos = pos+n*(j+1)
                    j = 0
                    for each in dict2:
                        dict2[each] = 0

        return rel

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/solution/bie-wen-wen-jiu-shi-diao-shi-de-li-liang-6wxu/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

31 實現獲取 下一個排列 的函式，演算法需要將給定數字序列重新排列成字典序中下一個更大的排列（即，組合出下一個更大的整數）。

如果不存在下一個更大的排列，則將數字重新排列成最小的排列（即升序排列）。

必須 原地 修改，只允許使用額外常數空間

最後那個反轉 第一次用sorted 然後用reverse 結果都不行 哭了 只能手寫
誰能看懂我程式碼就服他 我自己都搞不懂了 快
沒想到這也能超越8.6成的人

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        pos = -1
        flag = 0
        while abs(pos)<len(nums) :
            if nums[pos-1] < nums [pos]:
                flag = pos-1
                break
            pos -= 1
        if flag != 0:
            nextmaxpos = flag +1
            for i in range(-1,flag,-1):
                if nums[i] < nums[nextmaxpos] and nums[i] > nums[flag]:
                    nextmaxpos = i
            nums[flag],nums[nextmaxpos] = nums[nextmaxpos] ,nums[flag]

            for j in range(pos-1,-1):
                minpos = -1
                for i in range(j,-1):
                    if nums[i+1] < nums[minpos]:
                        minpos = i+1
                nums[flag+1] ,nums[minpos]= nums[minpos],nums[flag+1]
                flag += 1
        else:
            l = 0
            r= len(nums)-1
            while(l<r):
                nums[l] ,nums[r]= nums[r],nums[l]
                l+=1
                r-=1

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/next-permutation/solution/shui-neng-kan-dong-wo-dai-ma-jiu-fu-ta-b-ln8t/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。