checkin leetcode practice

Author: beck chen

leetcode practice/array and strings/longestPalindronicSubstring.js

@@ -0,0 +1,49 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var longestPalindrome = function (s) {
+    const charsArr = s.split('');
+    let result = [];
+    let longestLength = 0;
+
+    // handle odd cases
+    for (let ii = 0; ii < charsArr.length; ii++) {
+        let offset = 0;
+        while (isValidIndex(charsArr, ii - offset - 1)
+            && isValidIndex(charsArr, ii + offset + 1)
+            && charsArr[ii - offset - 1] === charsArr[ii + offset + 1]) {
+            offset++;
+        }
+
+        const currentLength = offset * 2 + 1;
+        if (currentLength > longestLength) {
+            longestLength = currentLength;
+            result = [ii - offset, ii + offset];
+        }
+    }
+
+    console.log(result);
+
+    // handle even cases
+    for (let ii = 0; ii < charsArr.length; ii++) {
+        let offset = 0;
+        while (isValidIndex(charsArr, ii - offset)
+            && isValidIndex(charsArr, ii + offset + 1)
+            && charsArr[ii - offset] === charsArr[ii + offset + 1]) {
+            offset++;
+        }
+
+        const currentLength = offset * 2;
+        if (currentLength > longestLength) {
+            longestLength = currentLength;
+            result = [ii - offset + 1, ii + offset];
+        }
+    }
+
+    return s.substring(result[0], result[1] + 1);
+};
+
+function isValidIndex(charsArr, index) {
+    return index >= 0 && index < charsArr.length;
+}

leetcode practice/array and strings/reverseString.js

@@ -0,0 +1,12 @@
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+var reverseString = function (s) {
+    const originalLength = s.length;
+    for (let ii = s.length - 2; ii >= 0; ii--) {
+        s.push(s[ii]);
+    }
+
+    s.splice(0, originalLength - 1);
+};

leetcode practice/array and strings/reverseWordsInAString.js

@@ -0,0 +1,67 @@
+/*
+** Given an input string s, reverse the order of the words.
+** A word is defined as a sequence of non-space characters.
+** The words in s will be separated by at least one space.
+** Return a string of the words in reverse order concatenated by a single space.
+** Note that s may contain leading or trailing spaces or multiple spaces between two words.
+** The returned string should only have a single space separating the words. Do not include any extra spaces.
+*/
+
+// Input: s = "the sky is blue"
+// Output: "blue is sky the"
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseWords = function (s) {
+    const stringAsArr = trimSpacesAndReverse(s);
+
+    // loop through characters array
+    let startIndex = 0, endIndex = 0;
+    while (endIndex <= stringAsArr.length) {
+        if (stringAsArr[endIndex + 1] === ' ') {
+            reverseChars(stringAsArr, startIndex, endIndex);
+            endIndex += 2;
+            startIndex = endIndex;
+        } else {
+            endIndex++;
+        }
+    }
+
+    reverseChars(stringAsArr, startIndex, stringAsArr.length - 1);
+    return stringAsArr.join('');
+};
+
+function trimSpacesAndReverse(str) {
+    let startIndex = 0, endIndex = str.length - 1;
+    while (str[startIndex] === ' ') {
+        startIndex++;
+    }
+
+    while (str[endIndex] === ' ') {
+        endIndex--;
+    }
+
+    // remove extra spaces in between
+    const trimmedArr = [];
+    for (let ii = endIndex; ii >= startIndex; ii--) {
+        if (str[ii] !== ' ') {
+            trimmedArr.push(str[ii]);
+        }
+
+        if (str[ii] === ' ' && str[ii - 1] !== ' ') {
+            trimmedArr.push(str[ii]);
+        }
+    }
+
+    return trimmedArr;
+}
+
+function reverseChars(charArr, startIndex, endIndex) {
+    while (startIndex < endIndex) {
+        [charArr[startIndex], charArr[endIndex]] = [charArr[endIndex], charArr[startIndex]];
+        startIndex++;
+        endIndex--;
+    }
+}

leetcode practice/array and strings/reverseWordsInAString2.js

@@ -0,0 +1,39 @@
+/* 
+** Given a character array s, reverse the order of the words.
+** A word is defined as a sequence of non-space characters. 
+** The words in s will be separated by a single space.
+** Your code must solve the problem in-place, i.e. without allocating extra space.
+*/
+
+
+/**
+ * @param {character[]} str
+ * @return {void} Do not return anything, modify str in-place instead.
+ */
+var reverseWords = function (str) {
+    reverseChars(str, 0, str.length - 1);
+
+    // loop from beginning of arr to second to last character,
+    // look for start of string, and look for space, and 
+    // reverse the characters in between 
+    let wordStartIndex = 0;
+    for (let ii = 0; ii < str.length - 1; ii++) {
+        if (str[ii + 1] === ' ') {
+            reverseChars(str, wordStartIndex, ii);
+            wordStartIndex = ii + 2;
+        }
+    }
+
+    // reverse the last word
+    reverseChars(str, wordStartIndex, str.length - 1);
+    return str;
+};
+
+function reverseChars(wordsToReverseArr, firstIndex, lastIndex) {
+    while (firstIndex < lastIndex) {
+        [wordsToReverseArr[firstIndex], wordsToReverseArr[lastIndex]]
+            = [wordsToReverseArr[lastIndex], wordsToReverseArr[firstIndex]];
+        firstIndex++;
+        lastIndex--;
+    }
+}

leetcode practice/array and strings/twoSum.js

@@ -0,0 +1,15 @@
+var twoSum = function (nums, target) {
+    // use hash table
+    if (target === undefined || !nums || nums.length === 0) { return []; }
+    const map = {};
+
+    for (let ii = 0; ii < nums.length; ii++) {
+        if (map[target - nums[ii]] !== undefined) {
+            return [map[target - nums[ii]], ii];
+        }
+
+        map[nums[ii]] = ii;
+    }
+
+    return [];
+};

leetcode practice/array and strings/validPalindrome.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function (s) {
+    s = s.toLowerCase().replace(/[^a-z0-9]/g, "");
+    // use two pointer solution
+    let startIndex = 0, endIndex = s.length - 1;
+    while (startIndex <= endIndex) {
+        if (s[startIndex] !== s[endIndex]) { return false; }
+        startIndex++;
+        endIndex--;
+    }
+
+    return true
+};

leetcode practice/array and strings/validParenthesis.js

@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function (s) {
+    if (!s || s.length === 0) { return false; }
+    const map = {
+        ']': '[',
+        '}': '{',
+        ')': '('
+    };
+
+    const stack = [];
+    for (let ii = 0; ii < s.length; ii++) {
+        if (!map[s[ii]]) {
+            stack.push(s[ii]);
+        } else {
+            if (map[s[ii]] !== stack.pop()) {
+                return false;
+            }
+        }
+    }
+
+    return stack.length === 0;
+};