Task03：查找1

35. 搜索插入位置
    

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if not nums:
            return None
        left = 0
        right = len(nums) - 1
        if nums[left] == target:
            return left
        if nums[right] == target:
            return right
        if nums[left] > target:
            return 0
        if nums[right] <target:
            return len(nums)
        while left < right-1:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            if nums[mid] < target:
                left = mid
            else:
                right = mid
        if nums[left] == target:
            return left
        else:
            return right

202. 快乐数
     

class Solution:
    def isHappy(self, n: int) -> bool:
        past = n
        collect = [n]
        while True:
            nums = list(str(past))
            sums = 0
            for i in nums:
                sums += int(i)**2
            if sums == 1:
                return True
            if sums in collect:
                return False
            past = sums
            collect.append(sums)

205. 同构字符串
     

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s)!= len(t):
            return False            
        def create_dic(s):
            dic=dict()
            for a in s:
                if a in dic.keys():
                    dic[a] = dic[a] + 1
                else:
                    dic[a] = 0
            return dic
        dic1 = create_dic(s)
        dic2 = create_dic(t)
        return dic1 == dic2

242. 有效的字母异位词
     

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s)!= len(t):
            return False            
        def create_dic(s):
            dic=dict()
            for a in s:
                if a in dic.keys():
                    dic[a] = dic[a] + 1
                else:
                    dic[a] = 0
            return dic
        dic1 = create_dic(s)
        dic2 = create_dic(t)
        return dic1 == dic2

290. 单词规律

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        pattern = list(pattern)
        str = str.split()
        if len(pattern) != len(str):
            return False
        dic = dict()
        words = []
        for p,s in zip(pattern,str):
            if p not in dic.keys():
                if s in words:
                    return False
                dic[p] = s
                words.append(s)
            elif dic[p] != s:
                return False
        return True

349. 两个数组的交集

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:        
        return list(set(nums1) & set(nums2))

350. 两个数组的交集 II

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        dic = {num:[0,0] for num in nums1+nums2}
        for i in nums1:
            dic[i][0] += 1
        for i in nums2:
            dic[i][1] += 1
        res = []
        for i in dic:
            res += [i]*min([dic[i][0],dic[i][1]])
        return res

410. 分割数组的最大值

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        n = len(nums)
        f = [[10**18] * (m + 1) for _ in range(n + 1)]
        sub = [0]
        for elem in nums:
            sub.append(sub[-1] + elem)
        
        f[0][0] = 0
        for i in range(1, n + 1):
            for j in range(1, min(i, m) + 1):
                for k in range(i):
                    f[i][j] = min(f[i][j], max(f[k][j - 1], sub[i] - sub[k]))
        
        return f[n][m]

451. 根据字符出现频率排序

class Solution:
    def frequencySort(self, s: str) -> str:
        if not s:
            return ''
        dic = dict()
        for i in s:
            if i not in dic.keys():
                dic[i] = 1
            else:
                dic[i] += 1
        dic = [(k,dic[k]) for k in dic]
        dic.sort(key=lambda x:x[1],reverse=True)
        res = ''
        for i in dic:
            res += i[0]*i[1]
        return res

540. 有序数组中的单一元素

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return nums[0]
        left = 0
        right = len(nums) - 2
        while left < right - 1:
            if nums[left] != nums[left+1]:
                return nums[left]
            if nums[right] != nums[right+1]:
                return nums[right+1]
            mid = (left + right) // 2
            if nums[mid] != nums[mid+1]:
                if nums[mid+1] ==nums[mid+2]:
                    mid += 1
                else:
                    return nums[mid+1]
            if (right - mid) % 2 == 0:
                right = mid
            else:
                left = mid
            # print(left,right)
        if nums[left] !=nums[left+1]:
            return nums[left]
        else:
            return nums[right+1]