add a few questions

Author: LEUNGUU

src/besttime_sell_buy_stocks.py

@@ -0,0 +1,16 @@
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        left, right = 0, 1
+        maxP = 0
+
+        while right < len(prices):
+            if prices[left] < prices[right]:
+                maxP = max(maxP, (prices[right] - prices[left]))
+            else:
+                left = right
+            right += 1
+
+        return maxP

src/longest_repeating_char_replacement.py

@@ -0,0 +1,15 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        count = {}
+        left, maxf, res = 0, 0, 0
+
+        for right in range(len(s)):
+            count[s[right]] = 1 + count.get(s[right], 0)
+            maxf = max(maxf, count[s[right]])
+
+            while (right - left + 1) - maxf > k:
+                count[s[left]] -= 1
+                left += 1
+
+            res = max(res, right - left + 1)
+        return res

src/longest_substring_without_repeating.py

@@ -0,0 +1,13 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        left = 0
+        charSet = set()
+        res = 0
+
+        for right in range(len(s)):
+            while s[right] in charSet:
+                charSet.remove(s[left])
+                left += 1
+            charSet.add(s[right])
+            res = max(res, right - left + 1)
+        return res

src/permutation_in_string.py

@@ -0,0 +1,34 @@
+class Solution:
+    def checkInclusion(self, s1: str, s2: str) -> bool:
+        if len(s1) > len(s2):
+            return False
+
+        s1Count, s2Count = [0] * 26, [0] * 26
+        for i in range(len(s1)):
+            s1Count[ord(s1[i]) - ord("a")] += 1
+            s2Count[ord(s2[i]) - ord("a")] += 1
+
+        matches = 0
+        for i in range(26):
+            matches += 1 if s1Count[i] == s2Count[i] else 0
+
+        left = 0
+        for right in range(len(s1), len(s2)):
+            if matches == 26:
+                return True
+
+            index = ord(s2[right]) - ord("a")
+            s2Count[index] += 1
+            if s1Count[index] == s2Count[index]:
+                matches += 1
+            elif s1Count[index] + 1 == s2Count[index]:
+                matches -= 1
+
+            index = ord(s2[left]) - ord("a")
+            s2Count[index] -= 1
+            if s1Count[index] == s2Count[index]:
+                matches += 1
+            elif s1Count[index] - 1 == s2Count[index]:
+                matches -= 1
+            left += 1
+        return matches == 26

src/trap_rain_water.py

@@ -0,0 +1,22 @@
+from typing import List
+
+
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        if not height:
+            return 0
+
+        left, right = 0, len(height) - 1
+        leftMax, rightMax = height[left], height[right]
+        res = 0
+
+        while left < right:
+            if leftMax < rightMax:
+                left += 1
+                leftMax = max(leftMax, height[left])
+                res += leftMax - height[left]
+            else:
+                right -= 1
+                rightMax = max(rightMax, height[right])
+                res += rightMax - height[right]
+        return res

tests/test_besttime_sell_buy_stocks.py

@@ -0,0 +1,11 @@
+from besttime_sell_buy_stocks import Solution
+
+
+testcase = [{"testcase": [7, 1, 5, 3, 6, 4], "result": 5}]
+
+
+def test_besttime_sell_buy_stock():
+    for tc in testcase:
+        prices = tc["testcase"]
+        ans = Solution().maxProfit(prices)
+        assert ans == tc["result"]

tests/test_longeest_substring_without_repeating.py

@@ -0,0 +1,10 @@
+from longest_substring_without_repeating import Solution
+
+testcase = [{"testcase": "abcabcbb", "result": 3}]
+
+
+def test_longest_substring_without_repeating():
+    for tc in testcase:
+        s = tc["testcase"]
+        ans = Solution().lengthOfLongestSubstring(s)
+        assert ans == tc["result"]

tests/test_longest_repeating_char_replacement.py

@@ -0,0 +1,11 @@
+from longest_repeating_char_replacement import Solution
+
+testcase = [{"testcase": "AABABBA", "k": 1, "result": 4}]
+
+
+def test_longest_repeating_char_replacement():
+    for tc in testcase:
+        s = tc["testcase"]
+        k = tc["k"]
+        ans = Solution().characterReplacement(s, k)
+        assert ans == tc["result"]

tests/test_permutation_in_string.py

@@ -0,0 +1,11 @@
+from permutation_in_string import Solution
+
+testcase = [{"testcase": ("ab", "eidbaooo"), "result": True}]
+
+
+def test_permutation_in_string():
+    for tc in testcase:
+        s1 = tc["testcase"][0]
+        s2 = tc["testcase"][1]
+        ans = Solution().checkInclusion(s1, s2)
+        assert ans == tc["result"]

tests/test_trap_rain_water.py

@@ -0,0 +1,10 @@
+from trap_rain_water import Solution
+
+testcase = [{"testcase": [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1], "result": 6}]
+
+
+def test_trap_rain_water():
+    for tc in testcase:
+        height = tc["testcase"]
+        ans = Solution().trap(height)
+        assert ans == tc["result"]