Add solutions of some easy and medium problems from the 'Arrays & Hashing' section.

Author: vmmc2

Arrays & Hashing/Easy/contains_duplicate.py

@@ -0,0 +1,11 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        freq = {}
+
+        for num in nums:
+            current_freq = freq.get(num, 0)
+            freq[num] = current_freq + 1
+            if(freq[num] > 1):
+                return True
+
+        return False

Arrays & Hashing/Easy/two_sum.py

@@ -0,0 +1,9 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        idx_dict = {}
+
+        for i in range(0, len(nums)):
+            needed_value = target - nums[i]
+            if needed_value in idx_dict:
+                return [i, idx_dict[needed_value]]
+            idx_dict[nums[i]] = i

Arrays & Hashing/Easy/valid_anagram.py

@@ -0,0 +1,8 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        if len(s) != len(t):
+            return False
+        elif sorted(s) == sorted(t):
+            return True
+
+        return False

Arrays & Hashing/Medium/group_anagrams.py

@@ -0,0 +1,22 @@
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        anagrams = [ ]
+        sortedAnagrams = [ ]
+
+        for i in range(0, len(strs)):
+            sortedString = sorted(strs[i])
+            if i == 0:
+                anagrams.append( [strs[i]] )
+                sortedAnagrams.append(sortedString)
+            else:
+                hasFoundGroup = False
+                for j in range(0, len(sortedAnagrams)):
+                    if sortedString == sortedAnagrams[j]:
+                        hasFoundGroup = True
+                        anagrams[j].append(strs[i])
+                        break
+                if hasFoundGroup == False:
+                    anagrams.append( [strs[i]] )
+                    sortedAnagrams.append(sortedString)
+
+        return anagrams

Arrays & Hashing/Medium/longest_consecutive_sequence.py

@@ -0,0 +1,40 @@
+from collections import defaultdict
+
+class Solution:
+    def dfs(self, vertex: int, graph: defaultdict, visited: defaultdict, componentSize: int) -> None:
+        visited[vertex] = True
+        componentSize[0] += 1
+        
+        for neighbor in graph[vertex]:
+            if(neighbor not in visited):
+                self.dfs(neighbor, graph, visited, componentSize)
+
+        return
+
+    def longestConsecutive(self, nums: List[int]) -> int:
+        n = len(nums)
+        graph = { }
+        visited = { }
+    
+        for i in range(0, n):
+            vertex = nums[i]
+            if vertex in graph:
+                continue
+            graph[vertex] = []
+            if(vertex - 1 in graph):
+                graph[vertex].append(vertex - 1)
+                graph[vertex - 1].append(vertex)
+            if(vertex + 1 in graph):
+                graph[vertex].append(vertex + 1)
+                graph[vertex + 1].append(vertex)
+
+        answer = 0
+        for i in range(0, n):
+            vertex = nums[i]
+            if(vertex in visited):
+                continue
+            current = [0]
+            self.dfs(vertex, graph, visited, current)
+            answer = max(answer, current[0])
+
+        return answer

Arrays & Hashing/Medium/product_of_array_except_self.py

@@ -0,0 +1,16 @@
+# Non-Optimal Solution - Runtime Complexity: O(n²)
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        answer = [1 for i in range(0, n)]
+
+        for i in range(0, n):
+            product = 1
+            for j in range(0, n):
+                if i != j:
+                    product *= nums[j]
+            answer[i] = product
+
+        return answer
+

Arrays & Hashing/Medium/top_k_frequent_elements.py

@@ -0,0 +1,14 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        freqDict = { }
+        
+        for num in nums:
+            freqDict[num] = freqDict.get(num, 0) + 1
+
+        kvPairs = [(value, key) for key, value in freqDict.items()]
+        kvPairs = sorted(kvPairs)
+        kvPairs.reverse()
+        kvPairs = kvPairs[ : k]
+        answer = [pair[1] for pair in kvPairs]
+
+        return answer

Arrays & Hashing/Medium/valid_sudoku.py

@@ -0,0 +1,34 @@
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        digits = [str(i) for i in range(1, 10)]
+
+        # Checking each row
+        for i in range(0, len(board)):
+            freq = { }
+            for j in range(0, len(board)):
+                if(board[i][j] in digits):
+                    freq[board[i][j]] = freq.get(board[i][j], 0) + 1
+                    if(freq[board[i][j]] > 1):
+                        return False
+
+        # Checking each column
+        for i in range(0, len(board)):
+            freq = { }
+            for j in range(0, len(board)):
+                if(board[j][i] in digits):
+                    freq[board[j][i]] = freq.get(board[j][i], 0) + 1
+                    if(freq[board[j][i]] > 1):
+                        return False
+
+        # Checking each 3x3 sub-grid
+        for i in range(0, len(board), 3):
+            for j in range(0, len(board), 3):
+                freq = { }
+                for x in range(0, 3):
+                    for y in range(0, 3):
+                        if(board[i + x][j + y] in digits):
+                            freq[board[i + x][j + y]] = freq.get(board[i + x][j + y], 0) + 1
+                            if(freq[board[i + x][j + y]] > 1):
+                                return False
+
+        return True