110

Author: OnlyChristmas

Python/3sum.py

@@ -0,0 +1,112 @@
+'''
+
+
+Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+
+Note:
+
+The solution set must not contain duplicate triplets.
+
+Example:
+
+Given array nums = [-1, 0, 1, 2, -1, -4],
+
+A solution set is:
+[
+  [-1, 0, 1],
+  [-1, -1, 2]
+]
+
+
+
+'''
+
+class Solution:
+    def threeSum(self, nums: 'List[int]') -> 'List[List[int]]':
+
+        # Approach one
+#         from collections import Counter
+#         dic = Counter(nums)
+#         res = []
+#         new_nums = []
+#         for k,v in dic.items():
+#             if k == 0 and v > 2:
+#                 res.append([0,0,0])
+#                 new_nums.append(0)
+#                 continue
+#             if v >= 2:
+#                 if  k != 0 and -2*k in dic.keys():
+#                     res.append([k,k,-2*k])
+#                 new_nums.append(k)
+#             else:
+#                 new_nums.append(k)
+
+#         nums = sorted(new_nums)
+#         length = len(nums) - 1
+#         for i,n in enumerate(nums):
+#             if n > 0 : break
+#             l, r = i + 1, length
+#             while l < r:
+#                 result = nums[l] + nums[r] + n
+#                 if result > 0:
+#                     r -= 1
+#                 elif result == 0:
+#                     res.append([n, nums[l], nums[r]])
+#                     l += 1
+#                     r -= 1
+#                 else:
+#                     l += 1
+#         return res
+
+
+
+
+
+
+        # Approach two      排序后撞指针  O(n2)
+        # nums = sorted(nums)
+        # res = []
+        # length = len(nums) - 1
+        # for i,n in enumerate(nums[:-2]):
+        #     if i > 0 and n == nums[i-1]: continue
+        #     if n > 0 : break
+        #     l, r = i + 1, length
+        #     while l < r:
+        #         result = nums[l] + nums[r] + n
+        #         if result > 0:
+        #             r -= 1
+        #         elif result == 0:
+        #             res.append([n, nums[l], nums[r]])
+        #             l += 1
+        #             while l < r and nums[l - 1] == nums[l]:
+        #                 l += 1
+        #             r -= 1
+        #             while l < r and nums[r] == nums[r + 1]:
+        #                 r -= 1
+        #         else:
+        #             l += 1
+        # return res
+
+
+
+
+
+        # Approach three    O(j*k)       faster than 98% ，但消耗的内存增加
+        from collections import Counter
+        dic = Counter(nums)
+        pos = [x for x in dic if x > 0]
+        neg = [x for x in dic if x < 0]
+        res = []
+
+        if dic.get(0, 0) > 2: res.append([0, 0, 0])   # 单独处理特殊的零
+        for x in pos:                                 #  a、b、c 三数加和为零，若 a < 0 , b > 0 , 则  a < -c < b
+            for y in neg:
+                s = -(x + y)
+                if s in dic:
+                    if s == x and dic[x] > 1:
+                        res.append([x, x, y])
+                    elif s == y and dic[y] > 1:
+                        res.append([x, y, y])
+                    elif y < s < x:
+                        res.append([x, y, s])
+        return res

Python/4sum-ii.py

@@ -0,0 +1,55 @@
+'''
+
+Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.
+
+To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500. All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.
+
+Example:
+
+Input:
+A = [ 1, 2]
+B = [-2,-1]
+C = [-1, 2]
+D = [ 0, 2]
+
+Output:
+2
+
+Explanation:
+The two tuples are:
+1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
+2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
+
+'''
+
+
+
+class Solution:
+    def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
+
+        # Approach one
+        # length = len(A)
+        # res = 0
+        # dic = {}
+        # for i in range(length):
+        #     for j in range(length):
+        #         twosum = A[i] + B[j]
+        #         dic[twosum] = dic.get(twosum, 0) + 1
+        # for i in range(length):
+        #     for j in range(length):
+        #         res += dic.get(- C[i] - D[j], 0)
+        # return res
+
+
+        # Approach two
+        from collections import Counter
+        dicA , dicB ,dicC ,dicD = Counter(A), Counter(B), Counter(C), Counter(D)
+        res = 0
+        dic = {}
+        for a , a_nember in dicA.items():
+            for b , b_nember in dicB.items():
+                dic[a+b] = dic.get(a+b,0) + a_nember * b_nember
+        for c, c_nember in dicC.items():
+            for d, d_nember in dicD.items():
+                res += dic.get(-c-d,0) * c_nember * d_nember
+        return res

Python/4sum.py

@@ -0,0 +1,79 @@
+'''
+
+Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
+
+Note:
+
+The solution set must not contain duplicate quadruplets.
+
+Example:
+
+Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.
+
+A solution set is:
+[
+  [-1,  0, 0, 1],
+  [-2, -1, 1, 2],
+  [-2,  0, 0, 2]
+]
+
+
+'''
+
+
+
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+
+        # Approach one    O(n3)
+        # from collections import Counter
+        # dic = Counter(nums)
+        # res = []
+        # nums = sorted(nums)
+        # length = len(nums) - 1
+        # for i in range(length-2):
+        #     if i != 0 and nums[i] == nums[i - 1]: continue     # 避免重复答案
+        #     key = target - nums[i]
+        #     for j in range(i + 1, length-1):
+        #         if j != i + 1 and nums[j] == nums[j - 1]: continue   # 避免重复答案
+        #         twosum = key - nums[j]
+        #         l,r = j+1 , length
+        #         while l < r:
+        #             ans = nums[l] + nums[r]
+        #             if twosum < ans:
+        #                 r -= 1
+        #             elif twosum == ans:
+        #                 res.append([nums[i],nums[j],nums[l],nums[r]])
+        #                 r -= 1
+        #                 while nums[r] == nums[r + 1] and l < r:
+        #                     r -= 1
+        #                 l += 1
+        #                 while nums[l] == nums[l - 1] and l < r:
+        #                     l += 1
+        #             else:
+        #                 l += 1
+        # return res
+
+
+
+        # Approach two  O(n2)
+        res = set()
+        nums = sorted(nums)
+        length = len(nums)
+        dic = {}
+        if length < 4 or 4 * nums[0] > target or 4 * nums[-1] < target: return []
+        for i in range(length-1):
+            for j in range(i+1,length):
+                twosum = nums[i] + nums[j]
+                if twosum in dic.keys():
+                    dic[twosum].append((i,j))
+                else:
+                    dic[twosum] = [(i,j)]
+        for i in range(length-1):
+            for j in range(i+1,length):
+                ans = target - nums[i] - nums[j]
+                if dic.get(ans, 0) != 0:
+                    for k in dic.get(ans):
+                        if k[0] > j:
+                            res.add((nums[i] , nums[j] , nums[k[0]] , nums[k[1]] ))
+        return list(res)

Python/contains-duplicate-ii.py

@@ -0,0 +1,32 @@
+'''
+
+Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+Example 1:
+
+Input: nums = [1,2,3,1], k = 3
+Output: true
+Example 2:
+
+Input: nums = [1,0,1,1], k = 1
+Output: true
+Example 3:
+
+Input: nums = [1,2,3,1,2,3], k = 2
+Output: false
+
+'''
+
+
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        # Approach one
+        dic = {}
+        for i , n in enumerate(nums):
+            if n not in dic:
+                dic[n] = i
+            elif i - dic.get(n) <= k:
+                return True
+            else:
+                dic[n] = i
+        return False

Python/contains-duplicate-iii.py

@@ -0,0 +1,78 @@
+'''
+Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
+
+Example 1:
+
+Input: nums = [1,2,3,1], k = 3, t = 0
+Output: true
+Example 2:
+
+Input: nums = [1,0,1,1], k = 1, t = 2
+Output: true
+Example 3:
+
+Input: nums = [1,5,9,1,5,9], k = 2, t = 3
+Output: false
+
+
+'''
+
+
+class Solution:
+    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
+
+        # Approach one    TLE
+        # length = len(nums)
+        # if length < 2 or t < 0: return False
+        # l , r = 0 , 1
+        # while l <= r:
+        #     if r > length - 1: return False
+        #     if abs(nums[r] - nums[l]) <= t:
+        #         if 0 < r - l <= k:
+        #             return True
+        #         else:
+        #             if r - l < k and r < length - 1:
+        #                 r += 1
+        #             elif r - l == k or r == length - 1:
+        #                 l += 1
+        #                 r = l+1
+        #             else:
+        #                 l += 1
+        #     else:
+        #         if r - l < k and r < length - 1:
+        #             r += 1
+        #         elif r - l == k or r == length - 1:
+        #             l += 1
+        #             r = l+1
+        #         else:
+        #             l += 1
+        # return False
+
+
+
+        # Approach two    低效
+        # length = len(nums)
+        # if length < 2 or t < 0 or k < 0: return False
+        # dic = []
+        # for i,n in enumerate(nums):
+        #     if t == 0:     # 一个超长的例子需要特殊处理
+        #         if n in dic:
+        #             return True
+        #     else:
+        #         for j in dic:
+        #             if abs(j - n) <= t:
+        #                 return True
+        #     dic.append(n)
+        #     if len(dic) > k: del dic[0]
+        # return False
+
+
+        # Approach three
+        length = len(nums)
+        if k <= 0: return False
+        if t == 0 and len(set(nums)) == length: return False
+        for i in range(length - 1):
+            for j in range(i+1, min(i+1+k , length)):
+                if j - i <= k and abs(nums[j] - nums[i]) <= t:
+                    return True
+        return False

Python/group-anagrams.py

@@ -0,0 +1,33 @@
+'''
+Given an array of strings, group anagrams together.
+
+Example:
+
+Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
+Output:
+[
+  ["ate","eat","tea"],
+  ["nat","tan"],
+  ["bat"]
+]
+Note:
+
+All inputs will be in lowercase.
+The order of your output does not matter.
+
+
+'''
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+
+        # Approach one
+        dic = {}
+        for i in strs:
+            ii = ''.join(sorted(i))
+            if dic.get(ii,0) != 0:
+                dic[ii].append(i)
+            else:
+                dic[ii] = [i]
+        return [i for i in dic.values()]