updates

Author: wuduhren

problems/python3/contains-duplicate.py

@@ -0,0 +1,7 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        seen = set()
+        for num in nums:
+            if num in seen: return True
+            seen.add(num)
+        return False

problems/python3/hand-of-straights.py

@@ -0,0 +1,18 @@
+class Solution:
+    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
+        if len(hand)%groupSize!=0: return False
+        
+        counter = collections.Counter(hand)
+        h = list(counter.keys())
+        heapq.heapify(h)
+        
+        while h:
+            minNum = h[0]
+            for n in range(minNum, minNum+groupSize):
+                if counter[n]<=0: return False
+                counter[n] -= 1
+                if counter[n]==0:
+                    if h[0]!=n: return False
+                    heapq.heappop(h)
+        
+        return True

problems/python3/merge-triplets-to-form-target-triplet.py

@@ -0,0 +1,15 @@
+"""
+If any element in the triplets is larger than the element in target, it cannot be used.
+Check if we have all 3 index found the same value.
+"""
+class Solution:
+    def mergeTriplets(self, triplets: List[List[int]], target: List[int]) -> bool:
+        okIndex = set()
+        
+        for a, b, c in triplets:
+            if a>target[0] or b>target[1] or c>target[2]: continue
+            if a==target[0]: okIndex.add(0)
+            if b==target[1]: okIndex.add(1)
+            if c==target[2]: okIndex.add(2)
+        
+        return len(okIndex)==3

problems/python3/partition-labels.py

@@ -0,0 +1,26 @@
+"""
+Time: O(N)
+Space: O(N)
+
+For each char, store its max index in maxIndex.
+Iterate through the string, update the "currMax" along the way.
+currMax is the place we can partition unless it get updated again.
+If the current index is the currMax, update "ans".
+"""
+class Solution:
+    def partitionLabels(self, s: str) -> List[int]:
+        ans = []
+        maxIndex = {}
+        
+        for i, c in enumerate(s):
+            maxIndex[c] = i
+        
+        currMax = 0
+        processedLength = 0
+        for i, c in enumerate(s):
+            currMax = max(currMax, maxIndex[c])
+            if i==currMax:
+                ans.append(i+1 - processedLength)
+                processedLength += ans[-1]
+
+        return ans

problems/python3/two-sum.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        #needed: {number required : counter part index}
+        needed = {}
+        for i, num in enumerate(nums):
+            if num in needed:
+                return (needed[num], i)
+            needed[target-num] = i

problems/python3/valid-anagram.py

@@ -0,0 +1,17 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        counter = collections.Counter()
+        
+        for c in s:
+            counter[c] += 1
+        
+        for c in t:
+            if c not in counter:
+                return False
+            counter[c] -= 1
+        
+        for c in counter:
+            if counter[c]>0:
+                return False
+        
+        return True

problems/python3/valid-parenthesis-string.py

@@ -0,0 +1,23 @@
+class Solution:
+    def checkValidString(self, s: str) -> bool:
+        leftMin = 0
+        leftMax = 0
+        
+        for c in s:
+            if c=='(':
+                leftMin += 1
+                leftMax += 1
+            elif c==')':
+                leftMin -= 1
+                leftMax -= 1
+            else:
+                leftMin -= 1
+                leftMax += 1
+            
+            if leftMax<0:
+                return False
+            
+            if leftMin<0:
+                leftMin = 0
+        
+        return leftMin == 0