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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

        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

        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

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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。