refactor: add types and complexity

Author: adhocore

containermaxwater.py

@@ -2,7 +2,11 @@
 """
 
 
-def container_with_max_water(height):
+def container_with_max_water(height: list[int]) -> int:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n)
+    """
     ans, count = height[0], len(height)
     for i in range(1, count - 2):
         j = count - i

evalrpn.py

@@ -3,6 +3,10 @@
 
 
 def eval_rpn(tokens: list[str]) -> int:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n)
+    """
     stack = []
     for i, token in enumerate(tokens):
         if token not in "+-*/":

generateparens.py

@@ -2,17 +2,21 @@
 """
 
 
-def generate_parenthesis(n: int) -> list:
-    ans = []
-    def generate(open: int, close: int, gen: str):
-        if open == n and close == n:
+def generate_parenthesis(n: int) -> list[str]:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n)
+    """
+    def generate(open_count: int, close_count: int, gen: str):
+        if open_count == n and close_count == n:
             ans.append(gen)
             return
-        if open < n:
-            generate(open + 1, close, gen + '(')
-        if open > close:
-            generate(open, close+1, gen + ')')
+        if open_count < n:
+            generate(open_count + 1, close_count, gen + '(')
+        if open_count > close_count:
+            generate(open_count, close_count + 1, gen + ')')
 
+    ans = []
     generate(0, 0, "")
     return ans
 

groupanagrams.py

@@ -2,16 +2,20 @@
 """
 
 
-def group_anagrams(strings):
+def group_anagrams(strings: list[str]) -> list[str]:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n)
+    """
     groups = {}
     for string in strings:
         sort = "".join(sorted(string))
         if sort not in groups:
             groups[sort] = []
         groups[sort].append(string)
-    return groups.values()
+    return list(groups.values())
 
 
 if __name__ == "__main__":
-    print(group_anagrams(["abc", "bac", "def", "fed", "efd", "ghi"]))
+    print(group_anagrams(["abc", "def", "bac", "fed", "ghi", "efd"]))
     # => [['abc', 'bac'], ['def', 'fed', 'efd'], ['ghi']]

isanagram.py

@@ -2,7 +2,11 @@
 """
 
 
-def is_anagram(string, target):
+def is_anagram(string: str, target: str) -> bool:
+    """
+    Space Complexity: O(m)
+    Time Complexity:  O(m+n)
+    """
     if len(string) != len(target):
         return False
     counts = {}

longestconsecutiveseq.py

@@ -2,7 +2,11 @@
 """
 
 
-def longest_consecutive(nums):
+def longest_consecutive(nums: list[int]) -> int:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n)
+    """
     count, nums = len(nums), sorted(nums)
     run, ans = 1, 1
     for i, num in enumerate(nums):

longestsubstrlen.py

@@ -2,11 +2,15 @@
 """
 
 
-def length_of_longest_substring(string):
+def length_of_longest_substring(string: str) -> int:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n)
+    """
     left, right, max_left, win = 0, 0, 0, {}
     while right < len(string):
         if not win.get(string[right]):
-            win[string[right]] = (True,)
+            win[string[right]] = True
             max_left = max(right - left + 1, max_left)
         else:
             while string[left] != string[right]:

productexceptself.py

@@ -2,7 +2,11 @@
 """
 
 
-def product_except_self(nums):
+def product_except_self(nums: list[int]) -> list[int]:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n+n) => O(n)
+    """
     count = len(nums)
     res = [1] * count
     pre, post, zero = 1, 1, 0

stockmaxprofit.py

@@ -2,7 +2,11 @@
 """
 
 
-def stock_max_profit(prices):
+def stock_max_profit(prices: list[int]) -> int:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n)
+    """
     profit, min_price = 0, prices[0]
     for i in range(1, len(prices) - 1):
         if prices[i] < min_price:

substrpermute.py

@@ -2,7 +2,11 @@
 """
 
 
-def check_str_permute_sub(string1, string2):
+def check_str_permute_sub(string1: str, string2: str) -> bool:
+    """
+    Space Complexity: O(m+n)
+    Time Complexity:  O(m+n)
+    """
     s1count, s2count = {}, {}
     for char in string1:
         s1count[char] = s1count.get(char, 0) + 1

threesumzero.py

@@ -2,7 +2,11 @@
 """
 
 
-def three_sum_zero(nums: list[int]):
+def three_sum_zero(nums: list[int]) -> list:
+    """
+    Space Complexity: O(n/3) => O(n)
+    Time Complexity:  O(n^2)
+    """
     res = set()  # a+b+c = 0 => c = -a-b
     count = len(nums)
     for i in range(count):

topkfrequent.py

@@ -2,7 +2,11 @@
 """
 
 
-def top_k_frequent(nums, k):
+def top_k_frequent(nums: list[int], k: int) -> list[int]:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n)
+    """
     cts = {}
     for num in nums:
         cts[num] = cts.get(num, 0) + 1

traprainwater.py

@@ -2,7 +2,11 @@
 """
 
 
-def trap_rain_water(height):
+def trap_rain_water(height: list[int]) -> int:
+    """
+    Space Complexity: O(1)
+    Time Complexity:  O(n^2)
+    """
     count = len(height)
     left, rain = height[0], 0
     for i in range(1, count):

twosum.py

@@ -2,12 +2,17 @@
 """
 
 
-def two_sum(nums, target):
+def two_sum(nums: list[int], target: int) -> list[int]:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n)
+    """
     sums = {}
     for i, num in enumerate(nums):
         if num in sums:
             return [sums[num], i + 1]
         sums[target - num] = i + 1
+    return [-1, -1]
 
 
 if __name__ == "__main__":

validparens.py

@@ -2,7 +2,11 @@
 """
 
 
-def is_valid_parens(string):
+def is_valid_parens(string: str) -> bool:
+    """
+    Space Complexity: O(n)
+    Time Complexity:  O(n)
+    """
     stack = []
     pair = {")": "(", "}": "{", "]": "["}
     for char in string: