From d4c79478d704da410e082577b148513cf729f0a8 Mon Sep 17 00:00:00 2001
From: saebaebae <73720393+saebaebae@users.noreply.github.com>
Date: Thu, 27 Jan 2022 17:47:04 -0800
Subject: [PATCH 1/2] hash table practice, all tests passing

---
 hash_practice/exercises.py | 108 +++++++++++++++++++++++++++++++++++--
 1 file changed, 105 insertions(+), 3 deletions(-)

diff --git a/hash_practice/exercises.py b/hash_practice/exercises.py
index 48bf95e..1d57d39 100644
--- a/hash_practice/exercises.py
+++ b/hash_practice/exercises.py
@@ -5,7 +5,24 @@ def grouped_anagrams(strings):
         Time Complexity: ?
         Space Complexity: ?
     """
-    pass
+
+    result = []
+    hash = {}
+
+    for word in strings:
+        new_word = "".join(sorted(word))
+        if new_word in hash:
+            hash[new_word].append(word)
+        else:
+            hash[new_word] = [word]
+
+    for value in hash.values():
+        result.append(value)
+    
+    return result
+    
+            
+
 
 def top_k_frequent_elements(nums, k):
     """ This method will return the k most common elements
@@ -13,7 +30,27 @@ def top_k_frequent_elements(nums, k):
         Time Complexity: ?
         Space Complexity: ?
     """
-    pass
+    if not nums or k <= 0: 
+        return []
+
+    hash = {}
+    result = []
+
+    for n in nums:
+        if n not in hash: 
+            hash[n] = 1
+        else: 
+            hash[n] += 1
+        
+    while len(result) < k:
+        biggest = max(hash, key=hash.get)
+        result.append(biggest)
+
+        del hash[biggest]
+    
+    return result
+    
+
 
 
 def valid_sudoku(table):
@@ -25,5 +62,70 @@ def valid_sudoku(table):
         Time Complexity: ?
         Space Complexity: ?
     """
-    pass
+    hash = {}
+    for n in range(1, 10):
+        hash[str(n)] = 0
+
+    #check rows first
+    for row in table:
+        for sq in row:
+            if sq != ".":
+                if hash[sq] == 0:
+                    hash[sq] = 1
+                elif hash[sq] != 0:
+                    return False
+        #wipe clean 
+        for n in range(1, 10):
+            hash[str(n)] = 0
+    
+    #wipe clean
+    for n in range(1, 10):
+        hash[str(n)] = 0
+
+    #check columns
+    row = 0 
+    col = 0
+    for col in range(9):
+        for row in range(9):
+            sq = table[row][col]
+            if sq != ".":
+                if hash[sq] == 0:
+                    hash[sq] = 1
+                elif hash[sq] != 0:
+                    return False
+        #wipe clean
+        for n in range(1, 10):
+            hash[str(n)] = 0
+
+    #wipe clean
+    for n in range(1, 10):
+        hash[str(n)] = 0
+
+    #check 3x3 tables
+    r = 0
+    c = 0
+
+    while (r < 9 and c < 9): 
+        for row in range(r, r+3):
+            for col in range(c, c+3):
+                sq = table[row][col]
+
+                if sq != ".":
+                    if hash[sq] == 0:
+                        hash[sq] = 1
+                    elif hash[sq] != 0:
+                        return False
+            
+        #go to next block
+        # reset r, c
+        r += 3
+        c += 3
+        # wipe hash clean
+        for n in range(1, 10):
+            hash[str(n)] = 0
+
+    return True
+
+
+
 

From 9af86cbefb85867aa54f4bb15b0cb07c578c30ad Mon Sep 17 00:00:00 2001
From: saebaebae <73720393+saebaebae@users.noreply.github.com>
Date: Thu, 27 Jan 2022 17:51:55 -0800
Subject: [PATCH 2/2] hast table practice with space/time complexity

---
 hash_practice/exercises.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/hash_practice/exercises.py b/hash_practice/exercises.py
index 1d57d39..aef35ec 100644
--- a/hash_practice/exercises.py
+++ b/hash_practice/exercises.py
@@ -2,8 +2,8 @@
 def grouped_anagrams(strings):
     """ This method will return an array of arrays.
         Each subarray will have strings which are anagrams of each other
-        Time Complexity: ?
-        Space Complexity: ?
+        Time Complexity: On
+        Space Complexity: On
     """
 
     result = []
@@ -27,8 +27,8 @@ def grouped_anagrams(strings):
 def top_k_frequent_elements(nums, k):
     """ This method will return the k most common elements
         In the case of a tie it will select the first occuring element.
-        Time Complexity: ?
-        Space Complexity: ?
+        Time Complexity: Onk
+        Space Complexity: On
     """
     if not nums or k <= 0: 
         return []
@@ -59,8 +59,8 @@ def valid_sudoku(table):
         Each element can either be a ".", or a digit 1-9
         The same digit cannot appear twice or more in the same 
         row, column or 3x3 subgrid
-        Time Complexity: ?
-        Space Complexity: ?
+        Time Complexity: O1 bc it's always 9x9?
+        Space Complexity: O1 bc the hash is always #1-9?
     """
     hash = {}
     for n in range(1, 10):