上面是以前搞的 iis 发布。

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        # 贪心算法
        g.sort()
        s.sort()
        i = 0
        j = 0
        while i < len(g) and j < len(s):
            if g[i] <= s[j]:
                i += 1
            j += 1
        return i

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        return s in (s + s)[1: len(s)*2 -1]

class Solution:
    def minMoves(self, nums: List[int]) -> int:
        sum = 0
        minmum = min(nums)
        for i in nums:
            sum += i-minmum
        return sum

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        # 将所有正数作为数组下标，置对应数组值为负值。那么，仍为正数的位置即为（未出现过）消失的数字。
        for num in nums:
            nums[abs(num)-1] = -abs(nums[abs(num)-1])
        print(nums)
        return [i+1 for i,num in enumerate(nums) if num>0]

class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        result=0
        for m in points:
            dic={}
            for j in points:
                distance=(m[0]-j[0])**2+(m[1]-j[1])**2
                if distance not in dic:
                    dic[distance]=1
                else:
                    dic[distance]+=1
            for val in dic.values():
                if val>=2:
                    result+=val*(val-1)
        return result

class Solution:
    def compress(self, chars: List[str]) -> int:
        count = 1

        length = len(chars)
        for index in range(length-1, -1, -1):
            if index > 0 and chars[index] == chars[index-1]:
                count += 1
            else:
                end = index+count
                chars[index: end] = [chars[index]] if count == 1 else [chars[index]] +  list(str(count))
                count = 1

        return len(chars)

class Solution:
    def arrangeCoins(self, n: int) -> int:
        c = 0
        while n > c:
            c = c + 1
            n = n - c
        return c

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def pathSum(self, root, sum):
        if root == None:
            return 0
        return self.count(root,sum)+self.pathSum(root.left,sum)+self.pathSum(root.right,sum)
    def count(self,root,sum):
        if root ==None:
            return 0
        return int(root.val == sum) + self.count(root.left,sum-root.val) + self.count(root.right,sum-root.val)

class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())