updates

Author: wuduhren

problems/python3/encode-and-decode-strings.py

@@ -0,0 +1,23 @@
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        output = ''
+        for string in strs:
+            output += str(len(string))+'#'+string
+        return output
+        
+
+    def decode(self, s: str) -> List[str]:
+        output = []
+        i = 0
+        
+        while i<len(s):
+            j = i+1
+            
+            while s[j]!='#': j += 1
+                    
+            l = int(s[i:j])
+            string = s[j+1:j+1+l]
+            output.append(string)
+            i = j+1+l
+            
+        return output

problems/python3/group-anagrams.py

@@ -0,0 +1,23 @@
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        def normalize(string: str) -> str:
+            counter = collections.Counter()
+            ans = ''
+            
+            for c in string:
+                counter[c] += 1
+            
+            for c in 'abcdefghijklmnopqrstuvwxyz':
+                if counter[c]>0:
+                    ans += c+str(counter[c])
+            return ans
+                    
+        group = collections.defaultdict(list)
+        ans = []
+        
+        for string in strs:
+            group[normalize(string)].append(string)
+        
+        for normalizedString in group:
+            ans.append(group[normalizedString])    
+        return ans

problems/python3/product-of-array-except-self.py

@@ -0,0 +1,45 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        #left[i] := product of all nums left of nums[i] (not include nums[i])
+        left = [1]
+        temp = 1
+        for num in nums:
+            temp *= num
+            left.append(temp)
+        
+        #right[i] := product of all nums right of nums[i] (not include nums[i])
+        right = []
+        temp = 1
+        for num in reversed(nums):
+            temp *= num
+            right.append(temp)
+        right.reverse()
+        right.append(1)
+        right = right[1:]
+        
+        ans = []
+        for i in range(len(nums)):
+            ans.append(left[i]*right[i])
+        return ans
+
+#In Place
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        N = len(nums)
+        ans = [0]*N
+        
+        #generate "left"
+        ans[0] = 1
+        for i in range(1, N):
+            ans[i] = ans[i-1]*nums[i-1]
+        
+        #generate "right"
+        temp = 1
+        for i in range(N-2, -1, -1):
+            temp *= nums[i+1]
+            ans[i] *= temp
+        
+        return ans
+            
+    
+    

problems/python3/top-k-frequent-elements.py

@@ -0,0 +1,53 @@
+#Bucket Sort
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        bucket = collections.defaultdict(list)
+        counter = collections.Counter(nums)
+        ans = []
+        
+        for num in counter:
+            bucket[counter[num]].append(num)
+        
+        tempCount = len(nums)
+        while len(ans)<k:
+            ans.extend(bucket[tempCount])
+            tempCount -= 1
+        
+        return ans
+
+#QuickSelect
+class Solution:
+    def topKFrequent(self, nums: List[int], K: int) -> List[int]:
+        def quickSelect(freqs, s, e, K):
+            i = s
+            t = s
+            j = e
+            pivot = freqs[(s+e)//2][1]
+            
+            while t<=j:
+                if freqs[t][1]<pivot:
+                    freqs[i], freqs[t] = freqs[t], freqs[i]
+                    i += 1
+                    t +=1
+                elif freqs[t][1]>pivot:
+                    freqs[j], freqs[t] = freqs[t], freqs[j]
+                    j -= 1
+                else:
+                    t += 1
+            if e-j>=K:
+                return quickSelect(freqs, j+1, e, K)
+            elif e-(i-1)>=K:
+                return pivot
+            else:
+                return quickSelect(freqs, s, i-1, K-(e-i+1))
+                
+        counts = collections.Counter(nums)
+        freqs = [(num, counts[num]) for num in counts]
+        ans = []
+        
+        KthLargestFreq = quickSelect(freqs, 0, len(freqs)-1, K)
+        
+        for num, freq in freqs:
+            if freq>=KthLargestFreq:
+                ans.append(num)
+        return ans

problems/python3/valid-sudoku.py

@@ -0,0 +1,37 @@
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        def rowIsValid(i):
+            used = set()
+            for j in range(N):
+                if board[i][j]=='.': continue
+                if board[i][j] in used: return False
+                used.add(board[i][j])
+            return True
+        
+        def columnIsValid(i):
+            used = set()
+            for j in range(N):
+                if board[j][i]=='.': continue
+                if board[j][i] in used: return False
+                used.add(board[j][i])
+            return True
+        
+        def isBoxValid(i1, i2, j1, j2):
+            used = set()
+            for i in range(i1, i2+1):
+                for j in range(j1, j2+1):
+                    if board[i][j]=='.': continue
+                    if board[i][j] in used: return False
+                    used.add(board[i][j])
+            return True
+                
+        N = 9
+        for i in range(N):
+            if not rowIsValid(i): return False
+            if not columnIsValid(i): return False
+        
+        for i in range(0, N, 3):
+            for j in range(0, N, 3):
+                if not isBoxValid(i, i+2, j, j+2): return False
+        
+        return True