[Sehwan] Week6 solutions with javascript

container-with-most-water/nhistory.js

@@ -0,0 +1,23 @@
+var maxArea = function (height) {
+  // Two pointer: left and right
+  // Amount of water: math.Min(height[left], height[right]) * (right-left)
+
+  // Exception case
+  if (height.length === 0) return 0;
+
+  let left = 0;
+  let right = height.length - 1;
+  let result = 0;
+
+  // Iterate to find maxiume amount of water
+  while (left < right) {
+    const amount = Math.min(height[left], height[right]) * (right - left);
+    result = Math.max(result, amount);
+    height[left] <= height[right] ? left++ : right--;
+  }
+
+  return result;
+};
+
+// TC: O(n)
+// SC: O(1)

find-minimum-in-rotated-sorted-array/nhistory.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function (nums) {
+  // Make two pointer to find out mid index point and compare values
+  let left = 0,
+    right = nums.length - 1;
+
+  // If left value of nums is smaller than right value, return left value
+  if (nums[left] < nums[right]) return nums[left];
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+
+    // If mid value is greater than last value, left pointer move into next index of mid
+    if (nums[mid] > nums[right]) left = mid + 1;
+    // Else change right pointer into mid index
+    else right = mid;
+  }
+  return nums[left];
+};
+
+// TC: O(log n)
+// SC: O(1)

longest-repeating-character-replacement/nhistory.js

@@ -0,0 +1,27 @@
+var characterReplacement = function (s, k) {
+  // Create two pointer to check repeating chracter (left, right)
+  let left = 0,
+    right = 0,
+    maxCount = 0,
+    map = new Map();
+
+  while (right < s.length) {
+    // Save each character into map and check how many time they have
+    map.set(s[right], map.get(s[right]) ? map.get(s[right]) + 1 : 1);
+    maxCount = Math.max(maxCount, map.get(s[right]));
+
+    // Count (right-left+1-k) and compare maximum value
+    if (right - left + 1 - k > maxCount) {
+      // Decrement value of map[s[left]] and move left pointer
+      map.set(s[left], map.get(s[left]) - 1);
+      left++;
+    }
+
+    right++;
+  }
+
+  return right - left;
+};
+
+// TC: O(n)
+// SC: O(1)

longest-substring-without-repeating-characters/nhistory.js

@@ -0,0 +1,19 @@
+var lengthOfLongestSubstring = function (s) {
+  // Create map to store character from string
+  let map = new Map();
+  let maxLen = 0;
+  let start = 0;
+
+  for (let end = 0; end < s.length; end++) {
+    if (map.has(s[end])) {
+      // Move the start pointer to the right of the previous position of current character
+      start = Math.max(map.get(s[end]) + 1, start);
+    }
+    map.set(s[end], end);
+    maxLen = Math.max(maxLen, end - start + 1);
+  }
+  return maxLen;
+};
+
+// TC: O(n)
+// SC: O(n)

search-in-rotated-sorted-array/nhistory.js

@@ -0,0 +1,39 @@
+var search = function (nums, target) {
+  // Exception case
+  if (nums.length === 0) return -1; // There is no element in nums
+  if (nums.length === 1) {
+    return nums[0] === target ? 0 : -1;
+  }
+
+  // Create two pointer: left,right and mid, left = 0, right = nums.length-1
+  let left = 0,
+    right = nums.length - 1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (nums[left] === target) return left;
+    if (nums[right] === target) return right;
+    if (nums[mid] === target) return mid;
+
+    // If left part is sorted, move pointer depends on target position
+    if (nums[left] <= nums[mid]) {
+      if (nums[left] <= target && target < nums[mid]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+      // If right part is sorted, move pointer depends on target position
+    } else {
+      if (nums[mid] < target && target <= nums[right]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+  }
+  return -1;
+};
+
+// TC: O(log n)
+// SC: O(1)