add more solution

Author: lukeluluke

021_merge_two_sorted_lists.js

@@ -0,0 +1,3 @@
+const mergeLists = function (attr1, attr2) {
+
+};

026_remove_duplicate_from_array.js

@@ -0,0 +1,14 @@
+const removeDuplicates = function(nums) {
+    let len = 0;
+    for (let i = 0; i<nums.length; i++) {
+        if (nums[i] !== nums[i-1]) {
+            nums[len++] = nums[i]
+        }
+    }
+    return len;
+};
+
+
+const nums = [1,1,2];
+
+console.log(removeDuplicates(nums));

027_remove_element.js

@@ -0,0 +1,13 @@
+const removeElement = function(nums, val) {
+    for (var i = 0; i < nums.length; i += 1) {
+        if (nums[i] === val) {
+            nums.splice(i, 1);
+            i--;
+        }
+    }
+        return nums
+};
+
+const nums = [3,2,2,3];
+
+console.log(removeElement(nums, 3));

028_implement_strStr.js

@@ -0,0 +1,37 @@
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+var strStr = function(haystack, needle) {
+    const needleLen = needle.length;
+    const stringLen = haystack.length;
+    for (let i =0; i<stringLen; i++) {
+        let sub = haystack[i];
+        for (let j=1; j<needleLen; j++) {
+            sub += haystack[i+j];
+        }
+
+        if (sub === needle) {
+            return i;
+        }
+    }
+
+    return needle ? -1 : 0;
+};
+
+
+/**
+ * This solution is much more faster
+ * @param haystack
+ * @param needle
+ * @returns {number}
+ */
+const strStr2 = function (haystack, needle) {
+    if(needle) {
+        var match = new RegExp(needle).exec(haystack);
+        return match ? match.index : -1;
+    } else {
+        return 0;
+    }
+};

035_search_insert_position.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const searchInsert = function(nums, target) {
+    for (let i = 0; i<nums.length; i++) {
+        if (nums[i]>=target) {
+            return  i;
+        }
+    }
+
+    return  nums.length;
+};
+
+
+const nums = [1,3,5,6];
+
+console.log(searchInsert(nums, 7));

038_count_and_say.js

@@ -0,0 +1,22 @@
+const countAndSay = function (n) {
+    let str = '1';
+    while (n > 1) {
+        let num = 1;
+        let temp = '';
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === str[i+1]) {
+                num ++;
+            } else{
+                temp += (num + '' + str[i]);
+                num = 1;
+            }
+        }
+
+        str = temp;
+        n--;
+    }
+
+    return str;
+};
+
+console.log(countAndSay(10));

053_maximum_subarray.js

@@ -0,0 +1,31 @@
+/**
+ * //todo Hard
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSubArray = function(nums) {
+    let max = nums[0];
+    let total = nums[0];
+    for (let i = 1; i<nums.length; i ++) {
+        total = Math.max(nums[i],  total + nums[i]);
+        max = Math.max(max, total);
+        console.log(total + ' | ' + max);
+    }
+
+    return max;
+};
+
+const maxSubArray2 = function(nums) {
+    let max = nums[0];
+    let total = nums[0];
+    const result = [nums[0]];
+
+    for (let i = 1; i<nums.length; i ++) {
+    }
+
+    return max;
+};
+
+const nums = [-2,1,-3,4,-1,2,1,-5,4];
+
+console.log(maxSubArray(nums));

058_length_of_last_word.js

@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLastWord = function(s) {
+    const arr = s.trim().split(' ');
+    return arr[arr.length-1].length;
+};
+
+const str = "a ";
+
+console.log(lengthOfLastWord(str));

066_plus_one.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+const plusOne = function(digits) {
+
+    for (let i = (digits.length-1); i>=0; i--) {
+        const lastDigit = digits[i];
+        if (lastDigit !==9) {
+            digits[i]++;
+            return digits;
+        } else {
+            digits[i] = 0
+        }
+    }
+    return  [1,...digits];
+}
+
+
+const num = [0];
+
+console.log(plusOne(num));

088_merge_sorted_array.js

@@ -0,0 +1,22 @@
+/**
+ * a = b--, assign b'value to a, and b minutes 1
+ * a = --b, b minutes 1 firstly, and then assign value to a
+ */
+
+const merge = function(nums1, m, nums2, n) {
+    let len = (m--) + (n--);
+    while (n >= 0) {
+        nums1[--len] = nums1[m] >= nums2[n] ? nums1[m--] : nums2[n--];
+    }
+};
+
+
+
+const nums1 = [1,2,3];
+const nums2 = [2,5,6];
+
+const m = 3;
+const n = 3;
+merge(nums1, m,  nums2, n);
+
+console.log(nums1);