[bhyun-kim, 김병현] Week 4 solutions

Author: sbk1014

counting-bits/bhyun-kim.py

@@ -0,0 +1,31 @@
+"""
+338. Counting Bits
+https://leetcode.com/problems/counting-bits/description/
+
+Solution:
+    - Convert the number to binary string
+    - Sum the number of 1s in the binary string
+    - Append the sum to the output list
+    - Return the output list
+
+Time complexity: O(nlogn)
+    - The for loop runs n times
+    - The sum function runs O(logn) times
+
+Space complexity: O(n)
+    - The output list has n elements
+"""
+
+
+from typing import List
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        
+        output = []
+        for i in range(n+1):
+            _str = str(bin(i))[2:]
+            _sum = sum(map(int, _str.strip()))
+            output.append(_sum)
+
+        return output

group-anagrams/bhyun-kim.py

@@ -0,0 +1,44 @@
+"""
+49. Group Anagrams
+https://leetcode.com/problems/group-anagrams/description/
+
+Solution:
+    - Create a hash table and a list of counters
+    - For each string in the input list:
+        - Sort the string
+        - If the sorted string is in the hash table:
+            - Append the string to the corresponding counter list
+        - Else:
+            - Add the sorted string to the hash table
+            - Create a new counter list and append the string
+    - Return the list of counters
+
+Time complexity: O(nmlogm)
+    - The for loop runs n times
+    - The sorted function runs O(mlogm) times
+    - m is the length of the longest string in the input list
+
+Space complexity: O(n)
+    - The output list has n elements
+    - The hash table has n elements
+    - The list of counters has n elements    
+"""
+
+from typing import List
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        
+        hash_table = []
+        counters = []
+        for s in strs:
+
+            count_s = ''.join(sorted(s))
+            if count_s in hash_table:
+                idx = hash_table.index(count_s)
+                counters[idx].append(s)
+            else:
+                hash_table.append(count_s)
+                counters.append([s])
+        
+        return counters

missing-number/bhyun-kim.py

@@ -0,0 +1,30 @@
+"""
+268. Missing Number
+https://leetcode.com/problems/missing-number/description/
+
+Solution:
+    - Sort the input list
+    - For each index in the input list:
+        - If the index is not equal to the element:
+            - Return the index
+    - Return the length of the input list
+
+Time complexity: O(nlogn+n)
+    - The sort function runs O(nlogn) times
+    - The for loop runs n times
+
+Space complexity: O(1)
+    - No extra space is used
+"""
+from typing import List
+
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+
+        nums.sort()
+        for i in range(len(nums)):
+            if i != nums[i]:
+                return i
+
+        return len(nums)
+        

number-of-1-bits/bhyun-kim.py

@@ -0,0 +1,31 @@
+"""
+191. Number of 1 Bits
+https://leetcode.com/problems/number-of-1-bits/
+
+Solution:
+    - Create a counter
+    - For each bit in the input number:
+        - If the bit is 1:
+            - Increment the counter
+    - Return the counter
+
+Time complexity: O(1)
+    - The while loop runs 32 times
+
+Space complexity: O(1)
+    - No extra space is used
+"""
+
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        output = 0
+
+        i = 1 << 31
+        while(i > 0) :
+        
+            if((n & i) != 0) :
+                output += 1
+                
+            i = i // 2
+
+        return output

reverse-bits/bhyun-kim.py

@@ -0,0 +1,25 @@
+"""
+190. Reverse Bits
+https://leetcode.com/problems/reverse-bits/description/
+
+Solution:
+    - Convert the number to binary string
+    - Reverse the binary string
+    - Convert the reversed binary string to integer
+    - Return the integer
+
+Time complexity: O(1)
+    - The bin function runs once
+    - The reversed function runs once
+    - The int function runs once
+
+Space complexity: O(1)
+    - No extra space is used
+
+"""
+
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        n_bin = bin(n)[2:].zfill(32)
+        n_bin = ''.join(reversed(n_bin))
+        return int(n_bin, base=2)