add some modification and new problem

Author: chihungyu1116

2 Add Two Numbers.js

@@ -1,3 +1,9 @@
+// You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+
+// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+// Output: 7 -> 0 -> 8
+
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {
@@ -10,6 +16,11 @@
  * @param {ListNode} l2
  * @return {ListNode}
  */
+
+
+
+// value reverse helps to asslign the first digit or both linklist
+
 var addTwoNumbers = function(l1, l2) {
     if(l1 === null || l2 === null){
         return l1 || l2;

3 Longest Substring Without Repeating Characters.js

@@ -2,6 +2,8 @@
  * @param {string} s
  * @return {number}
  */
+
+
 var lengthOfLongestSubstring = function(s) {
     if(s === null || s.length === 0){
         return 0;
@@ -11,16 +13,17 @@ var lengthOfLongestSubstring = function(s) {
     var len = 0;
     var maxLen = len;
     var start = 0;
-    
+
+    // scan from left to right.    
     for(var i = start; i < s.length; i++){
         c = s[i];
 
         if(map[c] !== undefined && map[c] >= start) {
-            start = map[c] + 1;
-            len = i - start;
+            start = map[c] + 1; // start new search with repeated word's last location + 1
+            len = i - start; // real length -> from for example 3 to 5 is 3, so it's 5-3+1 and + 1 happens later
         }
 
-        len++;
+        len++; // real length -> from for example 3 to 5 is 3, so it's 5-3+1 and + 1 happens later
 
         if(len > maxLen){
             maxLen = len;

5 Longest Palindromic Substring.js

@@ -1,23 +1,34 @@
+// Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.
+
 /**
  * @param {string} s
  * @return {string}
  */
 
+
+
 var longestPalindrome = function(s) {
     if(s === null || s.length === 0){
         return "";
     }    
 
     var result = "";
+
+    // The reason to multiply by 2 is because 
+    // Palindrome can be in two forms
+    // 1. abba There will be case which center has two idenitical charachter,
+    //   And there will be maximum 2*n - 1 such case
+    // 2. aba There will be case which center has only one character
+    var len = 2*s.length - 1;
+    var left, right;
 
-    for(var i = (2*s.length) - 1; i--;){
-        var left = parseInt(i/2);
-        var right = parseInt(i/2);
+    for(var i = 0; i < len; i++){
+        left = right = parseInt(i/2);
         if(i%2 === 1){
             right++;
         }
 
-        var str = lengthOfPalindrome(s,left,right);
+        var str = expandFromCenterAndCheckForPalindrome(s,left,right);
 
         if(str.length > result.length){
             result = str;
@@ -27,7 +38,49 @@ var longestPalindrome = function(s) {
 };
 
 
-var lengthOfPalindrome = function(s, left, right){
+// other implementation
+
+var longestPalindrome = function(s) {
+    if(s === null || s.length === 0){
+        return "";
+    }    
+    
+    var result = "";
+
+    // The reason to multiply by 2 is because 
+    // Palindrome can be in two forms
+    // 1. abba There will be case which center has two idenitical charachter,
+    //   And there will be maximum 2*n - 1 such case
+    // 2. aba There will be case which center has only one character
+    var len = s.length;
+    var left, right;
+    
+    for(var i = 0; i < len; i++){
+        left = right = i;
+
+        var str = expandFromCenterAndCheckForPalindrome(s,left,right);
+        if(str.length > result.length){
+            result = str;
+        }
+        var str = expandFromCenterAndCheckForPalindrome(s,left,right + 1);
+        if(str.length > result.length){
+            result = str;
+        }
+    }
+    return result;
+};
+
+
+
+var expandFromCenterAndCheckForPalindrome = function(s, left, right){
+    // in the case where left !== right
+    // that's the case "abba"
+    // which it checks for if b === b then a === a
+
+    // in the case where left === right
+    // that's the case "aba"
+    // which it check if b === b as left === right
+    // then a === a 
     while(left >= 0 && right < s.length && s[left] === s[right]){
         left--;
         right++;

9 Palindrome Number.js

@@ -2,35 +2,44 @@
 // Language: Javascript
 // Problem: https://leetcode.com/problems/palindrome-number/
 // Author: Chihung Yu
-/**
- * Leetcode Question 
+
+// Determine whether an integer is a palindrome. Do this without extra space.
+
+ /**
  * @param {number} x
  * @return {boolean}
  */
- 
 var isPalindrome = function(x) {
-    if(x < 0){
+    if(x < 0) {
         return false;
     }
 
     var div = 1;
 
-    while(parseInt(x/div) >= 10){
-        div *= 10;
+    // it means that the div is still a valid divider
+    // e.g 600 the divider should be 100 at maximum
+    // e.g. 90 the divider should be 10 at maximum
+    // e.g. 1 the divider should be a 1 at maximum
+    while(parseInt(x/div) >= 10) {
+        div *= 10;   
     }
 
-    while(x !== 0){
-        var l = parseInt(x/div);
-        var r = x%10;
-        
-        if(l !== r){
+    var left, right;
+    
+    // when div === 1 it means the digit only has one value to examine
+    // e.g. 121 -> only 2 is left for examine which can be ignore
+    // e.g. 1 -> 1
+    // e.g. 43234 -> 2
+    while(div > 1) {
+        left = parseInt(x/div);
+        right = x%10;
+        if(left !== right) {
             return false;
         }
 
-        x = x % div;
-        x = parseInt(x/10);
-        
-        div = parseInt(div/100);
+        x = x%div; // remove the left most digit
+        x = parseInt(x/10); // remove the right most digit
+        div /= 100;
     }
 
     return true;

Jump Game II.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var jump = function(nums) {
+    var curMax = 0;
+    var nJumps = 0;
+    var i = 0;
+    var n = nums.length;
+    
+    while(curMax < n - 1) {
+        var lastMax = curMax;
+        // go through covered area
+        for(; i <= lastMax; i++) {
+            curMax = Math.max(curMax, i+nums[i]);
+        }
+        nJumps++;
+        // if cannot make progress in the covered area, give up
+        if(lastMax === curMax) {
+            return -1;
+        }
+    }
+    
+    return nJumps;
+};

Reverse Integer.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function(x) {
+    var isNeg = x < 0;
+    var result = 0;
+    
+    x = Math.abs(x);
+    
+    while(x) {
+        var lastDigit = x%10;
+        result *= 10;
+        result += lastDigit;
+        x = parseInt(x/10);
+    }
+
+    result = isNeg ? -result : result;
+    
+    if(result > Math.pow(2,31) - 1 || result < -Math.pow(2,31)) {
+        return 0;
+    }
+    
+    return result;
+};

find kth element in two arrays.js

@@ -0,0 +1,59 @@
+var findKth = (a1, a2, kth) => {
+  var alen1 = a1.length;
+  var alen2 = a2.length;
+  
+  if(alen1 > alen2) {
+    return findKth(a2, a1, kth);
+  }
+  
+  if(alen1 === 0) {
+    return a2[kth -1];
+  }
+  
+  if(kth === 1) {
+    return Math.min(a1[0], a2[0]);
+  }
+  
+//   need to make sure that kth is not 1 as kth/2 = 0 
+  var p1 = Math.min(parseInt(kth/2), alen1);
+  var p2 = kth - p1;
+  
+  if(a1[p1 - 1] < a2[p2 - 1]) {
+     return findKth(a1.slice(p1), a2, kth - p1);
+  } else if(a1[p1 - 1] > a2[p2 - 1]) {
+    return findKth(a1, a2.slice(p2), kth - p2);
+  } else {
+    return a1[p1 - 1]; 
+  }
+}
+
+
+// function findKth(a, aStart, aEnd, b, bStart, bEnd, kth) {
+//     // use array position rather than use slice to get array
+//     // always assume that m is equal or smaller than n
+//     var aLen = aEnd - aStart + 1; // same as a.length as index 3 - 3 = 0 but still it has one element compared to a.length === 0 has notthing
+//     var bLen = bEnd - bStart + 1;
+//     var mid;
+//     if(aLen > bLen) {
+//         return findKth(b, bStart, bEnd, a, aStart, aEnd, kth);
+//     }
+    
+//     if(aLen <= 0) {
+//         return b[kth - 1];
+//     }
+    
+//     if(kth === 1) {
+//         return Math.min(a[aStart], b[bStart]);
+//     }
+    
+//     var k1 = Math.min(parseInt(kth/2), aLen); 
+//     var k2 = kth - k1;
+    
+//     if(a[aStart + k1 - 1] < b[bStart + k2 - 1]) {
+//         return findKth(a, aStart + k1, aEnd, b, bStart, bEnd, kth -k1);
+//     } else if(a[aStart + k1 - 1] > b[bStart + k2 - 1]) {
+//         return findKth(a, aStart, aEnd, b, bStart + k2, bEnd, kth -k2);
+//     } else {
+//         return a[aStart + k1 -1];
+//     }
+// }