Update 003

Update 003

Author: nature1995

Python3/001_Two_Sum.py

@@ -1,3 +1,5 @@
+#!usr/bin/env python
+# -*- coding:utf-8 -*-
 '''
 Given an array of integers, find two numbers such that they add up to a specific target number.
 

Python3/002_Add_Two_Numbers.py

@@ -1,3 +1,5 @@
+#!usr/bin/env python
+# -*- 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.
 
@@ -11,11 +13,10 @@ def __init__(self, x):
         self.val = x
         self.next = None
 
-    # Define this to check if it works well
-    def myPrint(self):
+    def my_test(self):
         print(self.val)
         if self.next:
-            self.next.myPrint()
+            self.next.my_test()
 
 
 class Solution(object):
@@ -25,15 +26,14 @@ def addTwoNumbers(self, l1, l2):
         :type l2: ListNode
         :rtype: ListNode
         """
-        result = ListNode(0);
-        cur = result;
+        result = ListNode(0)
+        cur = result
         while l1 or l2:
-            cur.val += self.addTwoNodes(l1, l2)
+            cur.val += self.AddTwoNodes(l1, l2)
             if cur.val >= 10:
                 cur.val -= 10
                 cur.next = ListNode(1)
             else:
-                # Check if there is need to make the next node
                 if l1 and l1.next or l2 and l2.next:
                     cur.next = ListNode(0)
             cur = cur.next
@@ -43,9 +43,9 @@ def addTwoNumbers(self, l1, l2):
                 l2 = l2.next
         return result
 
-    def addTwoNodes(self, n1, n2):
+
+    def AddTwoNodes(self, n1, n2):
         if not n1 and not n2:
-            # This cannot happen, ignore it
             None
         if not n1:
             return n2.val
@@ -54,12 +54,16 @@ def addTwoNodes(self, n1, n2):
         return n1.val + n2.val
 
 
+
+
+
+
 if __name__ == "__main__":
     list = ListNode(2)
     list.next = ListNode(4)
     list.next.next = ListNode(3)
-    list1= ListNode(5)
+    list1 = ListNode(5)
     list1.next = ListNode(6)
     list1.next.next = ListNode(4)
 
-    print(Solution().addTwoNumbers(list, list1).myPrint())
+    print(Solution().addTwoNumbers(list, list1).my_test())

Python3/003_Longest_Substring_Without_Repeating_Characters.py

@@ -0,0 +1,35 @@
+#!usr/bin/env python
+# -*- coding:utf-8 -*-
+'''
+Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.
+'''
+
+
+class Solution(object):
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        if not s:
+            return 0
+        if len(s) <= 1:
+            return len(s)
+        locations = [-1 for i in range(256)]
+        print(locations)
+        index = -1
+        m = 0
+        for i, v in enumerate(s):
+            #如果出现的字符就需要更新index为当前字符的位置
+            if (locations[ord(v)] > index):
+                index = locations[ord(v)]
+            m = max(m, i - index)
+            #确定字符的位置，相同字符的位置一样
+            locations[ord(v)] = i
+        return m
+
+
+if __name__ == "__main__":
+    print(Solution().lengthOfLongestSubstring("bccab"))
+
+

Python3/004_Median_of_Two_Sorted_Arrays.py

@@ -0,0 +1,54 @@
+#!usr/bin/env python
+# -*- 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)).
+'''
+
+class Solution(object):
+    def findMedianSortedArrays(self, nums1, nums2):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :rtype: float
+        """
+        length1 = len(nums1)
+        length2 = len(nums2)
+        k = (length1 + length2) // 2
+        if (length1 + length2) % 2 == 0:
+            return (self.findK(nums1, nums2, k) + self.findK(nums1, nums2, k - 1)) / 2.0;   # 2 is enough in python3
+        else:
+            return self.findK(nums1, nums2, k)
+
+    def findK(self, num1, num2, k):
+        # Recursive ends here
+        if not num1:
+            return num2[k]
+        if not num2:
+            return num1[k]
+        if k == 0:
+            return min(num1[0], num2[0])
+
+        length1 = len(num1)
+        length2 = len(num2)
+        if num1[length1 // 2] > num2[length2 // 2]:
+            if k > length1 // 2 + length2 // 2:
+                return self.findK(num1, num2[length2 // 2 + 1:], k - length2 // 2 - 1)
+            else:
+                return self.findK(num1[:length1 // 2], num2, k)
+        else:
+            if k > length1 // 2 + length2 // 2:
+                return self.findK(num1[length1 // 2 + 1:], num2, k - length1 // 2 - 1)
+            else:
+                return self.findK(num1, num2[:length2 // 2], k)
+
+
+if __name__ == "__main__":
+    assert Solution().findMedianSortedArrays([1, 2], [1, 2, 3]) == 2
+    assert Solution().findMedianSortedArrays([], [2, 3]) == 2.5
+
+
+
+
+