python leetcode Task4 查找2

leetcode 1:两数之和

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums=list(enumerate(nums))
        nums.sort(key=lambda x:x[1])
        l,r=0,len(nums)-1
        while l<r:
            if nums[l][1]+nums[r][1]==target:
                return nums[l][0],nums[r][0]
            elif nums[l][1]+nums[r][1]<target:
                l+=1
            else:
                r-=1

leetcode 15:三数之和

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res=[]
        for i in range(len(nums)-2):
            if nums[i]>0:
                bresk
            if i>0 and nums[i]==nums[i-1]:
                continue
            l,r=i+1,len(nums)-1
            while l<r:
                sum=nums[i]+nums[l]+nums[r]
                if sum==0:
                    res.append([nums[i],nums[l],nums[r]])
                    l+=1
                    r-=1
                    while l<r and nums[l]==nums[l-1]:
                        l+=1
                    while l<r and nums[r]==nums[r+1]:
                        r-=1
                elif sum<0:
                    l+=1
                else:
                    r-=1
        return res

leetcode 18:四数之和

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        from itertools import combinations
        res=[]
        for i in combinations(nums,4):
            if sum(i)==target:
                res.append(i)
        res=set(res)
        return res

leetcode 16:最接近的三数之和

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        diff=abs(nums[0]+nums[1]+nums[2]-target)
        res=nums[0]+nums[1]+nums[2]
        for i in range(len(nums)):
            l,r=i+1,len(nums)-1
            t=target-nums[i]
            while l<r:
                if nums[l]+nums[r]==t:
                    return nums[i]+t
                else:
                    if abs(nums[l]+nums[r]-t)<diff:
                        diff=abs(nums[l]+nums[r]-t)
                        res=nums[i]+nums[l]+nums[r]
                    if nums[l]+nums[r]<t:
                        l+=1
                    else:
                        r-=1
        return res

leetcode 454:四数相加II

class Solution:
    def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
        from collections import Counter
        record=Counter()
        for i in range(len(A)):
            for j in range(len(B)):
                record[A[i]+B[j]]+=1
        res=0
        for i in range(len(C)):
            for j in range(len(D)):
                find_num=0-C[i]-D[i]
                if record.get(find_num)!=None:
                    res+=record[find_num]
        return res

leetcode 49:字母异位词分组

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        from collections import defaultdict
        strs_dict=defaultdict(list)
        for str in strs:
            key=''.join(sorted(list(str)))
            strs_dict[key]+=str.split(',')
        return [v for v in strs_dict.values()]

leetcode 447:回旋镖的数量

class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        from collections import Counter
        def f(x1,y1):
            d=Counter((x2-x1)**2+(y2-y1)**2 for x2,y2 in points)
            return sum(t*(t-1) for t in d.values())
        return sum(f(x1,y1) for x1,y1 in points)

leetcode 149:直线上最多的点数

class Solution:
    def maxPoints(self, points: List[List[int]]) -> int:
        if len(points)<=1:
            return len(points)
        res=0
        from collections import defaultdict
        for i in range(len(points)):
            record=defaultdict(int)
            samepoint=0
            for j in range(len(points)):
                if points[i][0]==points[j][0] and points[i][1]==points[j][1]:
                    samepoint+=1
                else:
                    record[self.get_Slope(points,i,j)]+=1
            for v in record.values():
                res=max(res,samepoint)
            res=max(res,samepoint)
        return res
    def get_Slope(self,points,i,j):
        if points[i][1]-points[j][1]==0:
            return float('Inf')
        else:
            return(points[i][0]-points[j][0])/(points[i][1]-points[j][1])

leetcode 219:存在重复元素II

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        dict = {}
        for i in range(len(nums)):
            if nums[i] in dict and i - dict[nums[i]] <= k:
                return True
            dict[nums[i]] = i
        return False

leetcode 220:存在重复元素III

class Solution:
    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                if abs(nums[i] - nums[j]) <= t and j - i  <= k:
                    return True
        return False