[Leo] 6th Week solutions

Author: leokim0922

find-minimum-in-rotated-sorted-array/Leo.py

@@ -0,0 +1,16 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+
+        l = 0
+        r = len(nums) - 1
+
+        while l <= r:
+            mid = (l + r) // 2
+            if nums[mid] < nums[r]:
+                r = mid
+            else:
+                l = mid + 1
+
+        return nums[r]
+
+        # TC: O(logn), SC: O(1)

longest-repeating-character-replacement/Leo.py

@@ -0,0 +1,24 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        l = 0
+        c_frequency = {}
+        longest_str_len = 0
+
+        for r in range(len(s)):
+            if not s[r] in c_frequency:
+                c_frequency[s[r]] = 0
+            c_frequency[s[r]] += 1
+
+            cells_count = r - l + 1
+            if cells_count - max(c_frequency.values()) <= k:
+                longest_str_len = max(longest_str_len, cells_count)
+
+            else:
+                c_frequency[s[l]] -= 1
+                if not c_frequency[s[l]]:
+                    c_frequency.pop(s[l])
+                l += 1
+
+        return longest_str_len
+
+        ## TC: O(n), SC: O(1)

search-in-rotated-sorted-array/Leo.py

@@ -0,0 +1,33 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        left, right = 0, len(nums) - 1
+
+        while left <= right:
+            mid = (left + right) // 2
+
+            if nums[mid] == target:
+                return mid
+
+            if nums[left] <= nums[mid]:
+                if nums[left] <= target < nums[mid]:
+                    right = mid - 1
+                else:
+                    left = mid + 1
+
+            else:
+                if nums[mid] < target <= nums[right]:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+
+        return -1
+
+        ## TC: O(n), SC: O(1)
+
+        # if target in nums:
+        #     return nums.index(target)
+        # else:
+        #     return -1
+
+        ## TC: O(n), this may fater than bintree way if gvien nums are longer
+        ## SC: O(n)