Merge pull request #118 from bhyun-kim/main

[bhyun-kim, 김병현] Week 6 solutions

Author: bhyun-kim

container-with-most-water/bhyun-kim.py

@@ -0,0 +1,37 @@
+"""
+11. Container With Most Water
+https://leetcode.com/problems/container-with-most-water
+
+Solution: Two Pointers
+    - Use two pointers to traverse the list
+    - Calculate the area between the two pointers
+    - Update the maximum area
+    - Move the pointer with the shorter height
+    - Return the maximum area
+
+Time complexity: O(n)
+    - The two pointers traverse the list only once
+Space complexity: O(1)
+    - No extra space is used
+"""
+
+from typing import List
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left, right = 0, len(height) - 1
+        max_area = 0
+
+        while left < right:
+            shorter_height = min(height[left], height[right])
+            distance = right - left
+            area = shorter_height * distance
+            max_area = max(area, max_area)
+
+            if height[left] <= height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return max_area

counting-bits/bhyun-kim.py

@@ -55,11 +55,12 @@ def countBits(self, n: int) -> List[int]:
 
 from typing import List
 
+
 class Solution:
     def countBits(self, n: int) -> List[int]:
-        output = [0] * (n+1)
+        output = [0] * (n + 1)
 
-        for i in range(1, n+1):
+        for i in range(1, n + 1):
             output[i] = output[i >> 1] + (i & 1)
 
         return output

find-minimum-in-rotated-sorted-array/bhyun-kim.py

@@ -0,0 +1,44 @@
+"""
+153. Find Minimum in Rotated Sorted Array
+https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/
+
+Solution: Binary Search
+    - Find the center of the array
+    - Divide the array into two parts
+    - Compare the left and right values of each part
+    - If these values are in increasing order, return the left value of the first part
+    - Otherwise, find the minimum value of the left and right values of each part
+    - If the minimum value is the left value of the first part, recursively call the function with the first part
+    - Otherwise, recursively call the function with the second part
+
+Time complexity: O(log n)
+Space complexity: O(n)
+
+"""
+
+
+from typing import List
+
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        center = len(nums) // 2
+        arr1, arr2 = nums[:center], nums[center:]
+
+        arr1_left, arr1_right = arr1[0], arr1[-1]
+        arr2_left, arr2_right = arr2[0], arr2[-1]
+
+        if arr1_left < arr1_right < arr2_left < arr2_right:
+            return arr1_left
+
+        min_val = min(arr1_left, arr1_right)
+        min_val = min(min_val, arr2_left)
+        min_val = min(min_val, arr2_right)
+
+        if min_val in [arr1_left, arr1_right]:
+            return self.findMin(arr1)
+        else:
+            return self.findMin(arr2)

group-anagrams/bhyun-kim.py

@@ -29,18 +29,16 @@
 
 class Solution:
     def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
-        
         hash_table = dict()
         output = []
 
         for s in strs:
-            count_s = ''.join(sorted(s))
+            count_s = "".join(sorted(s))
             if count_s in hash_table:
                 idx = hash_table[count_s]
                 output[idx].append(s)
             else:
                 hash_table[count_s] = len(output)
                 output.append([s])
-                 
-        return output
 
+        return output

longest-repeating-character-replacement/bhyun-kim.py

@@ -0,0 +1,54 @@
+"""
+424. Longest Repeating Character Replacement
+https://leetcode.com/problems/longest-repeating-character-replacement/
+
+Solution: Sliding Window
+    - Use a dictionary to store the number of occurrences of each character
+    - Use two pointers to traverse the string
+    - Increment the right pointer until the substring contains no repeating characters
+    - Increment the left pointer until the substring contains repeating characters
+        To do this, 
+            - Find the maximum frequency of the characters in the substring
+            - If the length of the substring minus the maximum frequency is greater than k, increment the left pointer
+    - Update the maximum length of the substring
+    - Return the maximum length of the substring
+
+Time complexity: O(n)
+    - The time complexity is O(n) because the two pointers traverse the string only once
+
+Space complexity: O(n)
+    - Store the number of occurrences of each character in a dictionary
+"""
+
+
+from collections import defaultdict
+
+
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        char_freq = defaultdict(int)
+        left, right = 0, 0
+        max_seq = 1
+        max_freq = 0
+
+        while right < len(s):
+            r = s[right]
+            char_freq[r] += 1
+
+            max_freq = 0
+            for v in char_freq.values():
+                max_freq = max(v, max_freq)
+
+            while right - left + 1 - max_freq > k and left < right:
+                l = s[left]
+                char_freq[l] -= 1
+                left += 1
+
+                max_freq = 0
+                for v in char_freq.values():
+                    max_freq = max(v, max_freq)
+
+            max_seq = max(right - left + 1, max_seq)
+            right += 1
+
+        return max_seq

longest-substring-without-repeating-characters/bhyun-kim.py

@@ -0,0 +1,39 @@
+"""
+3. Longest Substring Without Repeating Characters
+https://leetcode.com/problems/longest-substring-without-repeating-characters/
+
+Solution: Sliding Window
+    - Use a dictionary to store the number of occurrences of each character
+    - Use two pointers to traverse the string
+    - Increment the right pointer until the substring contains no repeating characters
+    - Increment the left pointer until the substring contains repeating characters
+    - Update the maximum length of the substring
+    - Return the maximum length of the substring
+
+Time complexity: O(n)
+    - The time complexity is O(n) because the two pointers traverse the string only once
+Space complexity: O(n)
+    - Store the number of occurrences of each character in a dictionary
+"""
+
+from collections import defaultdict
+
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        char_count = defaultdict(int)
+        right, left = 0, 0
+        max_seq = 0
+        while right < len(s):
+            r = s[right]
+            char_count[r] += 1
+
+            while char_count[r] > 1:
+                l = s[left]
+                char_count[l] -= 1
+                left += 1
+
+            max_seq = max(max_seq, right - left + 1)
+            right += 1
+
+        return max_seq

search-in-rotated-sorted-array/bhyun-kim.py

@@ -0,0 +1,54 @@
+"""
+33. Search in Rotated Sorted Array
+https://leetcode.com/problems/search-in-rotated-sorted-array
+
+Solution: Binary Search
+    - Find the center of the array
+    - Divide the array into two parts
+    - Compare the left and right values of each part
+    - If the target value is in the range of the left and right values of the first part, recursively call the function with the first part
+    - If the target value is in the range of the left and right values of the second part, recursively call the function with the second part
+    - If the first part is rotated, recursively call the function with the first part
+    - Otherwise, recursively call the function with the second part
+    - If the output is not -1, add the length of the first part to the output
+
+Time complexity: O(log n)
+    - The time complexity is the same as the time complexity of the binary search algorithm
+Space complexity: O(n)
+    - Store the divided array in two variables
+"""
+
+from typing import List
+
+
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        if len(nums) == 1:
+            if target == nums[0]:
+                return 0
+            else:
+                return -1
+
+        center = len(nums) // 2
+        arr1, arr2 = nums[:center], nums[center:]
+
+        arr1_left, arr1_right = arr1[0], arr1[-1]
+        arr2_left, arr2_right = arr2[0], arr2[-1]
+
+        if arr1_left <= target <= arr1_right:
+            output = self.search(arr1, target)
+
+        elif arr2_left <= target <= arr2_right:
+            output = self.search(arr2, target)
+
+            if output != -1:
+                output += len(arr1)
+
+        elif arr1_right < arr1_left:
+            output = self.search(arr1, target)
+        else:
+            output = self.search(arr2, target)
+
+            if output != -1:
+                output += len(arr1)
+        return output