refactor

Author: adhocore

containermaxwater.py

@@ -1,10 +1,14 @@
+"""Container with maximum water
+"""
+
+
 def container_with_max_water(height):
     ans, count = height[0], len(height)
     for i in range(1, count - 2):
         j = count - i
-        w = j - i
-        h = min(height[i], height[j])
-        ans = max(w * h, ans)
+        wide = j - i
+        tall = min(height[i], height[j])
+        ans = max(wide * tall, ans)
     return ans
 
 

evalrpn.py

@@ -1,18 +1,22 @@
-def eval_rpn(tokens):
+"""Eval Reverse Polish Notation
+"""
+
+
+def eval_rpn(tokens: list[str]) -> int:
     stack = []
-    for i in range(len(tokens)):
-        if tokens[i] not in "+-*/":
-            stack.append(int(tokens[i]))
+    for i, token in enumerate(tokens):
+        if token not in "+-*/":
+            stack.append(int(token))
             continue
-        a, b = stack.pop(), stack.pop()
-        if tokens[i] == "+":
-            stack.append(b + a)
-        elif tokens[i] == "-":
-            stack.append(b - a)
-        elif tokens[i] == "*":
-            stack.append(b * a)
-        elif tokens[i] == "/":
-            stack.append(int(b / a))
+        right, left = stack.pop(), stack.pop()
+        if token == "+":
+            stack.append(left + right)
+        elif token == "-":
+            stack.append(left - right)
+        elif token == "*":
+            stack.append(left * right)
+        elif token == "/":
+            stack.append(int(left / right))
     return stack.pop()
 
 

groupanagrams.py

@@ -1,10 +1,14 @@
+"""Group Anagrams together
+"""
+
+
 def group_anagrams(strings):
     groups = {}
-    for s in strings:
-        s1 = "".join(sorted(s))
-        if s1 not in groups:
-            groups[s1] = []
-        groups[s1].append(s)
+    for string in strings:
+        sort = "".join(sorted(string))
+        if sort not in groups:
+            groups[sort] = []
+        groups[sort].append(string)
     return groups.values()
 
 

isanagram.py

@@ -1,15 +1,19 @@
-def is_anagram(s, t):
-    if len(s) != len(t):
+"""Is one string anagram of another
+"""
+
+
+def is_anagram(string, target):
+    if len(string) != len(target):
         return False
-    cc = {}
-    for c in s:
-        cc[c] = cc[c] + 1 if c in cc else 1
-    for c in t:
-        if c not in cc:
+    counts = {}
+    for char in string:
+        counts[char] = counts.get(char, 0) + 1
+    for char in target:
+        if char not in counts:
             return False
-        cc[c] -= 1
-        if cc[c] == 0:
-            del cc[c]
+        counts[char] -= 1
+        if counts[char] == 0:
+            del counts[char]
     return True
 
 

longestconsecutiveseq.py

@@ -1,12 +1,16 @@
+"""Longest consecutive sequence in a list
+"""
+
+
 def longest_consecutive(nums):
     count, nums = len(nums), sorted(nums)
-    c, mx = 1, 1
-    for i, n in enumerate(nums):
-        if i < count - 1 and n + 1 == nums[i + 1]:
-            c += 1
+    run, ans = 1, 1
+    for i, num in enumerate(nums):
+        if i < count - 1 and num + 1 == nums[i + 1]:
+            run += 1
         else:
-            c, mx = 1, max(c, mx)
-    return mx
+            run, ans = 1, max(run, ans)
+    return ans
 
 
 if __name__ == "__main__":

longestsubstrlen.py

@@ -1,12 +1,16 @@
-def length_of_longest_substring(s):
+"""Length of longest non-repeating substring
+"""
+
+
+def length_of_longest_substring(string):
     left, right, max_left, win = 0, 0, 0, {}
-    while right < len(s):
-        if not win.get(s[right]):
-            win[s[right]] = (True,)
+    while right < len(string):
+        if not win.get(string[right]):
+            win[string[right]] = (True,)
             max_left = max(right - left + 1, max_left)
         else:
-            while s[left] != s[right]:
-                win[s[left]], left = False, left + 1
+            while string[left] != string[right]:
+                win[string[left]], left = False, left + 1
             left += 1
         right += 1
     return max_left

productexceptself.py

@@ -1,3 +1,7 @@
+"""Product of all elements in list except itself
+"""
+
+
 def product_except_self(nums):
     count = len(nums)
     res = [1] * count

stockmaxprofit.py

@@ -1,3 +1,7 @@
+"""Max profit of a single transaction in stock sales
+"""
+
+
 def stock_max_profit(prices):
     profit, min_price = 0, prices[0]
     for i in range(1, len(prices) - 1):

substrpermute.py

@@ -1,14 +1,18 @@
-def check_str_permute_sub(s1, s2):
-    s1c, s2c = {}, {}
-    for c in s1:
-        s1c[c] = s1c.get(c, 0) + 1
-    for c in s2:
-        if c in s1c:
-            s2c[c] = s2c.get(c, 0) + 1
-            if s1c == s2c:
+"""Check if a string contains permutation of another string
+"""
+
+
+def check_str_permute_sub(string1, string2):
+    s1count, s2count = {}, {}
+    for char in string1:
+        s1count[char] = s1count.get(char, 0) + 1
+    for char in string2:
+        if char in s1count:
+            s2count[char] = s2count.get(char, 0) + 1
+            if s1count == s2count:
                 return True
         else:
-            s2c = {}
+            s2count = {}
     return False
 
 

threesumzero.py

@@ -1,14 +1,17 @@
+"""Three unique items in a list that sum to zero
+"""
+
+
 def three_sum_zero(nums: list[int]):
     res = set()  # a+b+c = 0 => c = -a-b
     count = len(nums)
-    for i, a in enumerate(nums):
+    for i in range(count):
         for j in range(i + 1, count):
-            b = nums[j]
             try:
-                k = nums.index(-a - b, j + 1)
-                pair = sorted([a, b, nums[k]])
+                k = nums.index(-nums[i] - nums[j], j + 1)
+                pair = sorted([nums[i], nums[j], nums[k]])
                 res.add(tuple(pair))
-            finally:
+            except ValueError:
                 pass
     return list(res)