Merge pull request DaleStudy#116 from sounmind/main

Evan: Week 6

Author: sounmind

container-with-most-water/evan.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+var maxArea = function (heights) {
+  let maxAmount = 0;
+  let [leftEnd, rightEnd] = [0, heights.length - 1];
+
+  while (leftEnd < rightEnd) {
+    const minHeight = Math.min(heights[leftEnd], heights[rightEnd]);
+    const horizontalLength = rightEnd - leftEnd;
+
+    maxAmount = Math.max(maxAmount, minHeight * horizontalLength);
+
+    if (heights[leftEnd] > heights[rightEnd]) {
+      rightEnd -= 1;
+    } else {
+      leftEnd += 1;
+    }
+  }
+
+  return maxAmount;
+};

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

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function (nums) {
+  let [left, right] = [0, nums.length - 1];
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] > nums[right]) {
+      // the smallest element is in the right half
+      left = mid + 1;
+    } else {
+      //  the smallest element is in the left half or at mid
+      right = mid;
+    }
+  }
+
+  return nums[left];
+};
+
+/**
+ * The time complexity of this approach is O(log n), where n is the number of elements in the array.
+ * This is because we are effectively halving the search space in each step of the binary search.
+ */

longest-repeating-character-replacement/evan.js

@@ -0,0 +1,45 @@
+/**
+ * @param {string} str
+ * @param {number} maxConvertCount
+ * @return {number}
+ */
+var characterReplacement = function (str, maxConvertCount) {
+  const freqInWindow = {};
+  let maxLength = 0;
+  let maxCharFreqInWindow = 0;
+  let leftIndex = 0;
+
+  for (let rightIndex = 0; rightIndex < str.length; rightIndex++) {
+    const slidingWindow = [str[leftIndex], str[rightIndex]];
+    const [leftChar, rightChar] = slidingWindow;
+
+    freqInWindow[rightChar] = (freqInWindow[rightChar] || 0) + 1;
+    maxCharFreqInWindow = Math.max(
+      maxCharFreqInWindow,
+      freqInWindow[rightChar]
+    );
+
+    // while (currentWindowLength > maxConvertCount + maxCharFreqInWindow) {
+    // while (cannot convert all characters in the window to the same character) {
+    while (rightIndex - leftIndex + 1 > maxConvertCount + maxCharFreqInWindow) {
+      leftIndex += 1;
+      freqInWindow[leftChar] -= 1;
+    }
+
+    maxLength = Math.max(maxLength, rightIndex - leftIndex + 1);
+  }
+
+  return maxLength;
+};
+
+/**
+ * Time Complexity: O(n)
+ * - The right pointer iterates through the string once, making it O(n).
+ * - The left pointer only moves when necessary, also contributing to O(n) overall.
+ * - Thus, the total time complexity is O(n).
+ *
+ * Space Complexity: O(1)
+ * - The frequency object stores counts for at most 26 letters in the English alphabet.
+ * - Since the space used by the frequency object is constant and does not scale with input size,
+ *   the space complexity is O(1).
+ */

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

@@ -0,0 +1,36 @@
+/**
+ * @param {string} str
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (str) {
+  let maxLength = 0;
+  let left = 0;
+  const lastSeenCharIndexMap = {};
+
+  for (let right = 0; right < str.length; right++) {
+    const currentChar = str[right];
+
+    // If the current character was seen before, update the left pointer
+    if (lastSeenCharIndexMap[currentChar] >= left) {
+      left = lastSeenCharIndexMap[currentChar] + 1;
+    }
+
+    lastSeenCharIndexMap[currentChar] = right;
+
+    maxLength = Math.max(maxLength, right - left + 1);
+  }
+
+  return maxLength;
+};
+
+/**
+ * Time Complexity: O(n)
+ * - The right pointer iterates through the string once, making it O(n).
+ * - The left pointer only moves when a duplicate character is found, ensuring each character is processed at most twice.
+ * - Thus, the total time complexity is O(n).
+ *
+ * Space Complexity: O(min(n, m))
+ * - The space complexity is determined by the size of the character map, which stores the indices of characters in the current window.
+ * - In the worst case, the map could store all unique characters in the string.
+ * - Thus, the space complexity is O(min(n, m)), where n is the length of the string and m is the character set size.
+ */

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

@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function (nums, target) {
+  let leftIndex = 0;
+  let rightIndex = nums.length - 1;
+
+  while (leftIndex <= rightIndex) {
+    const midIndex = Math.floor((rightIndex + leftIndex) / 2);
+    const [leftValue, midValue, rightValue] = [
+      nums[leftIndex],
+      nums[midIndex],
+      nums[rightIndex],
+    ];
+
+    if (midValue === target) {
+      return midIndex;
+    }
+
+    if (leftValue <= midValue) {
+      if (leftValue <= target && target < midValue) {
+        rightIndex = midIndex - 1;
+      } else {
+        leftIndex = midIndex + 1;
+      }
+    } else {
+      if (midValue < target && target <= rightValue) {
+        leftIndex = midIndex + 1;
+      } else {
+        rightIndex = midIndex - 1;
+      }
+    }
+  }
+
+  return -1;
+};