Merge pull request #121 from bky373/main

[bky373] Week 6 Solutions

Author: DaleSeo

container-with-most-water/bky373.java

@@ -0,0 +1,26 @@
+/**
+ * https://leetcode.com/problems/container-with-most-water/solution/
+ *
+ * time: O(N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+        int max = 0;
+        while (left < right) {
+            int area = (right - left) * Math.min(height[left], height[right]);
+            if (area > max) {
+                max = area;
+            }
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return max;
+    }
+}

find-minimum-in-rotated-sorted-array/bky373.java

@@ -0,0 +1,22 @@
+/**
+ * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+ *
+ * time: O(log N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int findMin(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (nums[left] > nums[right]) {
+            int mid = (left + right) / 2;
+            if (nums[mid] < nums[right]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return nums[left];
+    }
+}

longest-repeating-character-replacement/bky373.java

@@ -0,0 +1,24 @@
+/**
+ * https://leetcode.com/problems/longest-substring-without-repeating-characters/
+ *
+ * time: O(N)
+ * space: O(1)
+ */
+class Solution {
+
+    public int characterReplacement(String s, int k) {
+        int[] alp = new int[26];
+        int start = 0;
+        int maxCnt = 0;
+        int maxLen = 0;
+        for (int end = 0; end < s.length(); end++) {
+            maxCnt = Math.max(maxCnt, ++alp[s.charAt(end) - 'A']);
+            while (end - start + 1 - maxCnt > k) {
+                alp[s.charAt(start) - 'A']--;
+                start++;
+            }
+            maxLen = Math.max(maxLen, end - start + 1);
+        }
+        return maxLen;
+    }
+}

longest-substring-without-repeating-characters/bky373.java

@@ -0,0 +1,31 @@
+/**
+ * https://leetcode.com/problems/longest-substring-without-repeating-characters/
+ *
+ * time: O(N)
+ * space: O(N)
+ */
+class Solution {
+
+    public int lengthOfLongestSubstring(String s) {
+        int start = 0;
+        int k = 0;
+        int longest = 0;
+        int mapVersion = 0;
+        Map<Character, Integer> charMap = new HashMap<>();
+        while (start + k < s.length()) {
+            char cur = s.charAt(start + k);
+            int curVersion = charMap.getOrDefault(cur, 0);
+            if (curVersion > mapVersion) {
+                longest = Math.max(longest, k);
+                start++;
+                k = 0;
+                mapVersion = curVersion;
+            } else {
+                charMap.put(cur, mapVersion + 1);
+                k++;
+            }
+        }
+        longest = Math.max(longest, k);
+        return longest;
+    }
+}

search-in-rotated-sorted-array/bky373.java

@@ -0,0 +1,49 @@
+/**
+ * https://leetcode.com/problems/search-in-rotated-sorted-array/
+ *
+ * time: O(log n)
+ * space: O(1)
+ */
+class Solution {
+
+    public int search(int[] nums, int target) {
+        int res = -1;
+        if (nums.length == 1 && nums[0] == target) {
+            return 0;
+        }
+        int minIndex = findMinIndex(nums);
+        int leftResult = binarySearch(nums, 0, minIndex - 1, target);
+        if (leftResult > -1) {
+            return leftResult;
+        }
+        return binarySearch(nums, minIndex, nums.length - 1, target);
+    }
+
+    private int findMinIndex(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (nums[left] > nums[right]) {
+            int mid = (left + right) / 2;
+            if (nums[mid] < nums[right]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private int binarySearch(int[] nums, int left, int right, int target) {
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return -1;
+    }
+}