update(leetcode-js): add JS solution in leetcode.com

Author: loatheb

001-two-sum/two-sum.js

@@ -0,0 +1,37 @@
+// Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+//
+// You may assume that each input would have exactly one solution.
+//
+//
+// Example:
+//
+// Given nums = [2, 7, 11, 15], target = 9,
+//
+// Because nums[0] + nums[1] = 2 + 7 = 9,
+// return [0, 1].
+//
+//
+//
+//
+// UPDATE (2016/2/13):
+// The return format had been changed to zero-based indices. Please read the above updated description carefully.
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    const hmap = {}
+    for (var idx=0; idx<nums.length; idx++) {
+        var val = nums[idx]
+        var delta = target - val
+        var deltaIdx = hmap[delta]
+        if (deltaIdx !== undefined && deltaIdx !== idx) {
+            return [deltaIdx, idx]
+        }
+        hmap[val] = idx
+    }
+    return []
+};

001-two-sum/two-sum.py

@@ -0,0 +1,35 @@
+# -*- coding:utf-8 -*-
+
+
+# Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+#
+# You may assume that each input would have exactly one solution.
+#
+#
+# Example:
+#
+# Given nums = [2, 7, 11, 15], target = 9,
+#
+# Because nums[0] + nums[1] = 2 + 7 = 9,
+# return [0, 1].
+#
+#
+#
+#
+# UPDATE (2016/2/13):
+# The return format had been changed to zero-based indices. Please read the above updated description carefully.
+
+
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        d = {}
+        for i, v in enumerate(nums):
+            if v in d:
+                return [d[v],i]
+            d[target-v] = i
+

002-add-two-numbers/add-two-numbers.js

@@ -0,0 +1,30 @@
+// 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) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2) {
+    if (!l1) return l2;
+    if (!l2) return l1;
+    var l3 = new ListNode(0), fakeHead = l3, carry = 0, sum = 0;
+    while (l1 || l2 || carry) {
+        sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + carry;
+        l3.next = new ListNode(sum % 10);
+        carry = Math.floor(sum / 10);
+        l3 = l3.next; l1 = l1 && l1.next; l2 = l2 && l2.next;
+    }
+    return fakeHead.next;
+};

002-add-two-numbers/add-two-numbers.py

@@ -0,0 +1,59 @@
+# -*- coding:utf-8 -*-
+
+
+# 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.
+
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """       
+        if(l1 is None and l2 is None):
+            return None
+
+        head = ListNode(0)
+        point = head
+        carry = 0
+        while l1 is not None and l2 is not None:
+            s = carry + l1.val + l2.val
+            point.next = ListNode(s % 10)
+            carry = s / 10
+            l1 = l1.next
+            l2 = l2.next
+            point = point.next
+            
+        while l1 is not None:
+            s = carry + l1.val
+            point.next = ListNode(s % 10)
+            carry = s / 10
+            l1 = l1.next
+            point = point.next
+        
+        while l2 is not None:
+            s = carry + l2.val
+            point.next = ListNode(s % 10)
+            carry = s / 10
+            l2 = l2.next
+            point = point.next
+    
+        if carry != 0:
+            point.next = ListNode(carry)
+
+        return head.next
+
+        
+        
+        

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

@@ -0,0 +1,30 @@
+// Given a string, find the length of the longest substring without repeating characters.
+//
+// Examples:
+//
+// Given "abcabcbb", the answer is "abc", which the length is 3.
+//
+// Given "bbbbb", the answer is "b", with the length of 1.
+//
+// Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s) {
+    var hashMap = {};
+    var i = j = 0;
+    var n = s.length;
+    var len = 0;
+    while (i < n && j < n) {
+        if (!hashMap[s[i]]) {
+            hashMap[s[i++]] = true;
+            len = Math.max(len, i - j);
+        } else {
+            hashMap[s[j++]] = false;
+        }
+    }
+    return len;
+};

003-longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.py

@@ -0,0 +1,33 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a string, find the length of the longest substring without repeating characters.
+#
+# Examples:
+#
+# Given "abcabcbb", the answer is "abc", which the length is 3.
+#
+# Given "bbbbb", the answer is "b", with the length of 1.
+#
+# Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+
+
+class Solution(object):
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+
+        longest, start, visited = 0, 0, [False for _ in range(256)]
+        for ind, val in enumerate(s):
+            if not visited[ord(val)]:
+                visited[ord(val)] = True
+            else:
+                while val != s[start]:
+                    visited[ord(s[start])] = False
+                    start += 1
+                start += 1
+            longest = max(longest, ind - start + 1)
+        return longest
+        

004-median-of-two-sorted-arrays/median-of-two-sorted-arrays.py

@@ -0,0 +1,40 @@
+# -*- coding:utf-8 -*-
+
+
+# There are two sorted arrays nums1 and nums2 of size m and n respectively.
+#
+# Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
+#
+# Example 1:
+#
+# nums1 = [1, 3]
+# nums2 = [2]
+#
+# The median is 2.0
+#
+#
+#
+# Example 2:
+#
+# nums1 = [1, 2]
+# nums2 = [3, 4]
+#
+# The median is (2 + 3)/2 = 2.5
+
+
+class Solution(object):
+    def findMedianSortedArrays(self, nums1, nums2):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :rtype: float
+        """
+        nums = sorted(nums1 + nums2)
+        t_len = len(nums)
+        if t_len == 1:
+            return nums[0]
+            
+        if t_len % 2:
+            return nums[t_len/2]
+        else:
+            return (nums[t_len/2] + nums[t_len/2 -1]) /2.0

005-longest-palindromic-substring/longest-palindromic-substring.js

@@ -0,0 +1,46 @@
+// Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+//
+// Example:
+//
+// Input: "babad"
+//
+// Output: "bab"
+//
+// Note: "aba" is also a valid answer.
+//
+//
+//
+// Example:
+//
+// Input: "cbbd"
+//
+// Output: "bb"
+
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var longestPalindrome = function(s) {
+    var a = s.split(''),left, right,
+        size = a.length,
+        max = Number.MIN_VALUE,
+        start = 0;
+
+    for(var i = 0; i < size; i = i + 0.5){
+        left = Math.ceil(i - 1);
+        right = Math.floor(i + 1);
+        while(left >=0 && right < size) {
+            if (a[left] === a[right]){
+                left--;
+                right++;
+            } else { break;}
+        }
+        if (right - left - 1 > max){
+            max = right - left - 1;
+            start = left + 1;
+        }
+    }
+
+    return s.slice(start, start + max);
+};

005-longest-palindromic-substring/longest-palindromic-substring.py

@@ -0,0 +1,47 @@
+# -*- coding:utf-8 -*-
+
+
+# Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+#
+# Example:
+#
+# Input: "babad"
+#
+# Output: "bab"
+#
+# Note: "aba" is also a valid answer.
+#
+#
+#
+# Example:
+#
+# Input: "cbbd"
+#
+# Output: "bb"
+
+
+class Solution(object):
+    def longestPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        longest, mid = "", (len(s) - 1) / 2
+        i, j = mid, mid
+        while i >= 0 and j < len(s):
+            args = [(s, i, i), (s, i, i + 1), (s, j, j), (s, j, j + 1)]
+            for arg in args:
+                tmp = self.longestPalindromeByAxis(*arg)
+                if len(tmp) > len(longest):
+                    longest = tmp
+            if len(longest) >= i * 2:
+                if len(longest) == 1:
+                    return s[0]
+                return longest
+            i, j = i - 1, j + 1
+        return longest
+
+    def longestPalindromeByAxis(self, s, left, right):
+        while left >= 0 and right < len(s) and s[left] == s[right]:
+            left, right = left - 1, right + 1
+        return s[left + 1: right]