style: refactor to func

Author: adhocore

containermaxwater.py

@@ -1,15 +1,13 @@
-class Solution:
-    def containerWithMaxWater(self, height):
-        mx, l = height[0], len(height)
-        for i in range(1, l - 2):
-            j = l - i
-            w = j - i
-            h = min(height[i], height[j])
-            mx = max(w * h, mx)
-        return mx
+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)
+    return ans
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.containerWithMaxWater([1, 8, 6, 2, 5, 4, 8, 3, 7]))
+    print(container_with_max_water([1, 8, 6, 2, 5, 4, 8, 3, 7]))
     # => 49

evalrpn.py

@@ -1,29 +1,27 @@
-class Solution(object):
-    def evalRPN(self, tokens):
-        stak = []
-        for i in range(len(tokens)):
-            if not tokens[i] in "+-*/":
-                stak.append(int(tokens[i]))
-                continue
-            a, b = stak.pop(), stak.pop()
-            if tokens[i] == "+":
-                stak.append(b + a)
-            elif tokens[i] == "-":
-                stak.append(b - a)
-            elif tokens[i] == "*":
-                stak.append(b * a)
-            elif tokens[i] == "/":
-                stak.append(int(b / a))
-        return stak.pop()
+def eval_rpn(tokens):
+    stack = []
+    for i in range(len(tokens)):
+        if tokens[i] not in "+-*/":
+            stack.append(int(tokens[i]))
+            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))
+    return stack.pop()
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.evalRPN(["2", "1", "+", "3", "*"]))
+    print(eval_rpn(["2", "1", "+", "3", "*"]))
     # => 9 => (2+1)*3
     print(
-        s.evalRPN(["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"])
+        eval_rpn(["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"])
     )
     # => 22
-    print(s.evalRPN(["4", "-2", "/", "2", "-3", "-", "-"]))
+    print(eval_rpn(["4", "-2", "/", "2", "-3", "-", "-"]))
     # => -7

groupanagrams.py

@@ -1,15 +1,13 @@
-class Solution:
-    def groupAnagrams(self, strs):
-        groups = {}
-        for s in strs:
-            s1 = "".join(sorted(s))
-            if not s1 in groups:
-                groups[s1] = []
-            groups[s1].append(s)
-        return groups.values()
+def group_anagrams(strings):
+    groups = {}
+    for s in strings:
+        s1 = "".join(sorted(s))
+        if s1 not in groups:
+            groups[s1] = []
+        groups[s1].append(s)
+    return groups.values()
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.groupAnagrams(["abc", "bac", "def", "fed", "efd", "ghi"]))
+    print(group_anagrams(["abc", "bac", "def", "fed", "efd", "ghi"]))
     # => [['abc', 'bac'], ['def', 'fed', 'efd'], ['ghi']]

isanagram.py

@@ -1,24 +1,23 @@
-class Solution:
-    def isAnagram(self, s, t):
-        if len(s) != len(t):
+def is_anagram(s, t):
+    if len(s) != len(t):
+        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:
             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:
-                return False
-            cc[c] -= 1
-            if cc[c] == 0:
-                del cc[c]
-        return True
+        cc[c] -= 1
+        if cc[c] == 0:
+            del cc[c]
+    return True
 
-    # one line solution:
-    def isAnagram2(self, s, t):
-        return len(s) == len(t) and sorted(s) == sorted(t)
+
+# one line solution:
+def is_anagram2(s, t):
+    return len(s) == len(t) and sorted(s) == sorted(t)
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.isAnagram("anagram", "nagaram"))
+    print(is_anagram("anagram", "nagaram"))
     # => True

longestconsecutiveseq.py

@@ -1,16 +1,14 @@
-class Solution:
-    def longestConsecutive(self, nums):
-        l, nums = len(nums), sorted(nums)
-        c, mx = 1, 1
-        for i, n in enumerate(nums):
-            if i < l - 1 and n + 1 == nums[i + 1]:
-                c += 1
-            else:
-                c, mx = 1, max(c, mx)
-        return mx
+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
+        else:
+            c, mx = 1, max(c, mx)
+    return mx
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]))
+    print(longest_consecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]))
     # => 9 => [0-8]

longestsubstrlen.py

@@ -1,19 +1,17 @@
-class Solution:
-    def lengthOfLongestSubstring(self, s):
-        left, right, maxl, win = 0, 0, 0, {}
-        while right < len(s):
-            if not win.get(s[right]):
-                win[s[right]] = (True,)
-                maxl = max(right - left + 1, maxl)
-            else:
-                while s[left] != s[right]:
-                    win[s[left]], left = False, left + 1
-                left += 1
-            right += 1
-        return maxl
+def length_of_longest_substring(s):
+    left, right, max_left, win = 0, 0, 0, {}
+    while right < len(s):
+        if not win.get(s[right]):
+            win[s[right]] = (True,)
+            max_left = max(right - left + 1, max_left)
+        else:
+            while s[left] != s[right]:
+                win[s[left]], left = False, left + 1
+            left += 1
+        right += 1
+    return max_left
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.lengthOfLongestSubstring("abcdabecbb"))
+    print(length_of_longest_substring("abcdabecbb"))
     # => 5 => cdabe

productexceptself.py

@@ -1,22 +1,20 @@
-class Solution:
-    def productExceptSelf(self, nums):
-        l = len(nums)
-        res = [1] * l
-        pre, post, zero = 1, 1, 0
-        for i in range(l):
-            if nums[i] == 0:
-                zero += 1
-                if zero == 2:
-                    return [0] * l
-            res[i], pre = pre, pre * nums[i]
-        for i in range(l - 1, -1, -1):
-            res[i], post = res[i] * post, post * nums[i]
-        return res
+def product_except_self(nums):
+    count = len(nums)
+    res = [1] * count
+    pre, post, zero = 1, 1, 0
+    for i in range(count):
+        if nums[i] == 0:
+            zero += 1
+            if zero == 2:
+                return [0] * count
+        res[i], pre = pre, pre * nums[i]
+    for i in range(count - 1, -1, -1):
+        res[i], post = res[i] * post, post * nums[i]
+    return res
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.productExceptSelf([1, 2, 3]))
+    print(product_except_self([1, 2, 3]))
     # => [6, 3, 2]
-    print(s.productExceptSelf([1, 2, 3, 0, 0]))
+    print(product_except_self([1, 2, 3, 0, 0]))
     # => [0, 0, 0, 0, 0]

stockmaxprofit.py

@@ -1,15 +1,13 @@
-class Solution:
-    def stockMaxProfit(self, prices):
-        l, profit, minp = len(prices), 0, prices[0]
-        for i in range(1, l - 1):
-            if prices[i] < minp:
-                minp = prices[i]
-            else:
-                profit = max(prices[i] - minp, profit)
-        return profit
+def stock_max_profit(prices):
+    profit, min_price = 0, prices[0]
+    for i in range(1, len(prices) - 1):
+        if prices[i] < min_price:
+            min_price = prices[i]
+        else:
+            profit = max(prices[i] - min_price, profit)
+    return profit
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.stockMaxProfit([7, 1, 5, 3, 6, 4]))
+    print(stock_max_profit([7, 1, 5, 3, 6, 4]))
     # => 5 (1->6)

substrpermute.py

@@ -1,19 +1,17 @@
-class Solution:
-    def checkStrPermuteSub(self, 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:
-                    return True
-            else:
-                s2c = {}
-        return False
+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:
+                return True
+        else:
+            s2c = {}
+    return False
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.checkStrPermuteSub("abcd", "zdcbax"))
+    print(check_str_permute_sub("abcd", "zdcbax"))
     # => True

threesumzero.py

@@ -1,20 +1,18 @@
-class Solution:
-    def threeSumZero(self, nums: list[int]):
-        res = set()  # a+b+c = 0 => c = -a-b
-        l = len(nums)
-        for i, a in enumerate(nums):
-            for j in range(i + 1, l):
-                b = nums[j]
-                try:
-                    k = nums.index(-a - b, j + 1)
-                    ll = sorted([a, b, nums[k]])
-                    res.add(tuple(ll))
-                except:
-                    pass
-        return list(res)
+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 j in range(i + 1, count):
+            b = nums[j]
+            try:
+                k = nums.index(-a - b, j + 1)
+                pair = sorted([a, b, nums[k]])
+                res.add(tuple(pair))
+            finally:
+                pass
+    return list(res)
 
 
 if __name__ == "__main__":
-    s = Solution()
-    print(s.threeSumZero([0, 0, 0, -1, 1]))
+    print(three_sum_zero([0, 0, 0, -1, 1]))
     # => [(0, 0, 0), (-1, 0, 1)]