more array and stirngs

Author: beck chen

leetcode practice/array and strings/3Sum.js

@@ -0,0 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+
+var threeSum = function (nums) {
+    if (!nums) { return []; }
+    nums.sort((num1, num2) => num1 - num2);
+    const combinations = [];
+    for (let pointerIndex = 0; pointerIndex < nums.length - 2; pointerIndex++) {
+        if (nums[pointerIndex] > 0 || nums[pointerIndex - 1] === nums[pointerIndex]) {
+            continue;
+        }
+
+        twoSum(nums, pointerIndex, combinations);
+    }
+
+    return combinations;
+};
+
+function twoSum(nums, threeSumIndex, combinations) {
+    let startIndex = threeSumIndex + 1, endIndex = nums.length - 1;
+    while (endIndex > startIndex) {
+        const sum = nums[startIndex] + nums[endIndex] + nums[threeSumIndex];
+        if (sum < 0) {
+            startIndex++;
+        } else if (sum > 0) {
+            endIndex--;
+        } else {
+            combinations.push([nums[threeSumIndex], nums[startIndex], nums[endIndex]]);
+            startIndex++;
+            endIndex--;
+
+            while (startIndex < endIndex && nums[startIndex] === nums[startIndex - 1]) {
+                startIndex++;
+            }
+
+            while (startIndex < endIndex && nums[endIndex] === nums[endIndex + 1]) {
+                endIndex--;
+            }
+        }
+    }
+};

leetcode practice/array and strings/3SumClosest.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var threeSumClosest = function (nums, target) {
+    let closestDiff = Number.MAX_SAFE_INTEGER;
+    nums.sort((num1, num2) => num1 - num2);
+
+    for (let ii = 0; ii < nums.length; ii++) {
+        let startIndex = ii + 1, endIndex = nums.length - 1;
+        while (startIndex < endIndex) {
+            const currentSum = nums[ii] + nums[startIndex] + nums[endIndex];
+            const currentDiff = target - currentSum;
+
+            if (currentDiff === 0) {
+                return currentSum;
+            }
+
+            if (Math.abs(currentDiff) < Math.abs(closestDiff)) {
+                closestDiff = currentDiff;
+            }
+
+            if (currentSum > target) {
+                endIndex--;
+            } else {
+                startIndex++;
+            }
+        }
+    }
+
+    return target - closestDiff;
+};

leetcode practice/array and strings/minWindowSubstring.js

@@ -0,0 +1,56 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function (str, target) {
+    if (str.length === 0 || target.length === 0) { return ''; }
+
+    const targetCharMap = {};
+    for (let char of target) {
+        targetCharMap[char] = targetCharMap[char] === undefined ? 1 : targetCharMap[char] + 1;
+    }
+
+    const currentCharMap = {};
+    let requiredCharNum = Object.keys(targetCharMap).length;
+    let satisfiedCharNum = 0;
+    let startIndex = 0, endIndex = 0;
+    let globalMinWindowLength = Number.MAX_SAFE_INTEGER;
+    let globalMinWindow = [];
+
+    while (endIndex < str.length) {
+        const endIndexChar = str[endIndex];
+        currentCharMap[endIndexChar] = currentCharMap[endIndexChar] === undefined ? 1 : currentCharMap[endIndexChar] + 1;
+
+        if (currentCharMap[endIndexChar] === targetCharMap[endIndexChar]) {
+            satisfiedCharNum++;
+        }
+
+        while (satisfiedCharNum === requiredCharNum) {
+            const currentWindowLength = endIndex - startIndex + 1;
+            if (currentWindowLength < globalMinWindowLength) {
+                globalMinWindowLength = currentWindowLength;
+                globalMinWindow = [startIndex, endIndex]
+            }
+
+            // before moving startIndex to the right, we
+            // need to reduce the current char count of 
+            // the character that startIndex is at, since
+            // we're moving our window away from it
+            const startIndexChar = str[startIndex];
+            currentCharMap[startIndexChar]--;
+
+            // if startIndex's character is one of the target
+            // characters, we check to see if 
+            if (currentCharMap[startIndexChar] < targetCharMap[startIndexChar]) {
+                satisfiedCharNum--;
+            }
+
+            startIndex++;
+        }
+
+        endIndex++;
+    }
+
+    return str.slice(globalMinWindow[0], globalMinWindow[1] + 1)
+};

leetcode practice/array and strings/strStr.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+var strStr = function (haystack, needle) {
+    if (needle.length === 0) { return 0; }
+
+    for (let ii = 0; ii < haystack.length; ii++) {
+        if (needle[0] === haystack[ii]) {
+            const haystackSubstr = haystack.slice(ii, ii + needle.length);
+            if (needle === haystackSubstr) {
+                return ii;
+            }
+        }
+    }
+
+    return -1;
+};