[박종훈] 6주차 답안 제출

container-with-most-water/dev-jonghoonpark.md

@@ -0,0 +1,38 @@
+- 문제: https://leetcode.com/problems/container-with-most-water/
+- time complexity : O(n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/02/leetcode-11
+
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int start = 0;
+        int end = height.length - 1;
+
+        int max = getArea(height, start, end);
+
+        while(start < end) {
+            if(height[start] >= height[end]) {
+                end--;
+                max = Math.max(max, getArea(height, start, end));
+            } else {
+                start++;
+                max = Math.max(max, getArea(height, start, end));
+            }
+        }
+
+        return max;
+    }
+
+    public int getArea(int[] height, int start, int end) {
+        if (start == end) {
+            return 0;
+        }
+        return getMinHeight(height[end], height[start]) * (end - start);
+    }
+
+    public int getMinHeight(int height1, int height2) {
+        return Math.min(height1, height2);
+    }
+}
+```

find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md

@@ -0,0 +1,21 @@
+- 문제: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+- time complexity : O(log n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-153
+
+```java
+public int findMin(int[] nums) {
+    int left = 0, right = nums.length - 1;
+    while(left < right) {
+        int mid = left + (right - left) / 2;
+
+        if(nums[mid] < nums[right]) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return nums[left];
+}
+```

longest-repeating-character-replacement/dev-jonghoonpark.md

@@ -0,0 +1,36 @@
+- 문제: https://leetcode.com/problems/longest-repeating-character-replacement/
+- time complexity : O(n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/04/29/leetcode-424
+
+```java
+class Solution {
+    public int characterReplacement(String s, int k) {
+        int[] counter = new int[26];
+        int countOfMostFrequent = -1;
+
+        int headPointer = 0;
+        int tailPointer = 0;
+
+        int maxLength = 0;
+
+        while (headPointer < s.length()) {
+            char head = s.charAt(headPointer);
+            char tail = s.charAt(tailPointer);
+            counter[head - 'A']++;
+            headPointer++;
+
+            countOfMostFrequent = Math.max(counter[head - 'A'], countOfMostFrequent);
+            while (headPointer - tailPointer > countOfMostFrequent + k) {
+                counter[tail - 'A']--;
+                tailPointer++;
+                tail = s.charAt(tailPointer);
+            }
+
+            maxLength = Math.max(maxLength, headPointer - tailPointer);
+        }
+
+        return maxLength;
+    }
+}
+```

longest-substring-without-repeating-characters/dev-jonghoonpark.md

@@ -0,0 +1,34 @@
+- 문제: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+- time complexity : O(n)
+- space complexity : O(n)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/02/18/leetcode-3
+
+```java
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        if (s.isEmpty()) {
+            return 0;
+        }
+
+        Set<Character> set = new HashSet<>();
+        int pointer = 0;
+        int longest = 0;
+
+        while (pointer < s.length()) {
+            char _char = s.charAt(pointer);
+            while (set.contains(_char)) {
+                set.remove(s.charAt(pointer - set.size()));
+            }
+            set.add(_char);
+            longest = Math.max(longest, set.size());
+            pointer++;
+        }
+
+        return longest;
+    }
+}
+```
+
+## TC 추가 설명
+
+내부 while이 있지만 O(n)으로 적을 수 있는 이유는 hashset의 경우 search 하는데 드는 비용이 O(1) 이기 때문이다.

search-in-rotated-sorted-array/dev-jonghoonpark.md

@@ -0,0 +1,33 @@
+- 문제: https://leetcode.com/problems/search-in-rotated-sorted-array/
+- time complexity : O(log n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-33
+
+```java
+public int search(int[] nums, int target) {
+    int left = 0, right = nums.length - 1;
+    while(left <= right) {
+        int mid = left + (right - left) / 2;
+
+        if (nums[mid] == target) {
+            return mid;
+        }
+
+        if(nums[mid] < nums[right]) {
+            if (target < nums[mid] || target > nums[right]) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        } else {
+            if (target < nums[left] || target > nums[mid]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+    }
+
+    return -1;
+}
+```