leetcode | 删除排序数组中的重复项 && 27.移除元素 | 下一个排列 |全排列

bert里面有个model_build_fn, 返回model_fn, 对这种构造方式的好处不是很了解。调研一波哈：
参考博客1
函数闭包条件：

1. 内嵌函数必须引用一个外部函数里的变量
2. 外嵌函数必须返回内嵌函数

作用： 保持程序上一次运行后的状态，然后继续执行；函数装饰器

def foo():
    num=1
    def add(n):
        nonlocal  num
        num += n
        return num
    return add
f=foo()
print(f(1))  #2
print(f(2))  #4 此时外部函数的变量num已经变成2了

装饰器例子

26. 删除排序数组中的重复项 && 27.移除元素

快慢指针法

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0 : return 0
        i = 0
        for j in range(1, len(nums)):
            if nums[j] != nums[i]:
                i += 1 # 快慢指针
                nums[i] = nums[j]
        return i + 1

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        if len(nums) == 0: return 0
        i = -1
        for j in range(0, len(nums)):
            if nums[j] != val:
                i += 1  # 快慢指针
                nums[i] = nums[j]
        return i + 1

31. 下一个排列

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        1. a[k] < a[k+1] largest index
        2. a[l] > a[k] largest l
        3. 交换l and k
        4. 翻转nums[k+1:-1]
        """
        k = -1
        for i in range(len(nums)-1):
            if nums[i] < nums[i+1]:
                k = i
        if k == -1:
            nums.sort()
        else:
            l = len(nums) - 1
            for i in range(len(nums)-1, -1, -1):
                if nums[i] > nums[k]:
                    l = i
                    break # 找到就可以跳出来了
            nums[k], nums[l] = nums[l], nums[k]
            i, j = k+1, len(nums)-1

            while i < j:
                nums[i], nums[j] = nums[j], nums[i]
                i += 1
                j -= 1

46. 全排列

回溯法

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        ans = []
        def backtrack(first=0):
            if first == n:
            # 这里用nums[:],重新复制一个列表，否则返回的还是原来的引用
                ans.append(nums[:])
                return
            for i in range(first, n):
                nums[first], nums[i] = nums[i], nums[first] # 在第first位置，后面的数字依次占据这个位置试一下
                backtrack(first+1) # first位置决定后，决定first+1的位置，进行不断递归
                nums[first], nums[i] = nums[i], nums[first] # 回溯之后进行还原

        n = len(nums)
        backtrack()
        return ans