week 2

Author: selfboot

1.py

@@ -0,0 +1,17 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        nums_dict = {}
+        for index1, number1 in enumerate(nums):
+            number2 = target - number1
+            if number2 in nums_dict:
+                return nums_dict[number2] + 1, index1 + 1
+            nums_dict[number1] = index1

11.py

@@ -0,0 +1,31 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        length = len(height)
+        left = 0
+        right = length - 1
+        max_area = 0
+        while left < right:
+            area = (right - left) * min(height[left], height[right])
+            max_area = max(max_area, area)
+
+            if height[left] < height[right]:
+                min_height = height[left]
+                left += 1
+                while height[left] < min_height:
+                    left += 1
+
+            else:
+                min_height = height[right]
+                right -= 1
+                while height[right] < min_height:
+                    right -= 1
+
+        return max_area

12.py

@@ -0,0 +1,41 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def intToRoman(self, num):
+        """
+        :type num: int
+        :rtype: str
+        """
+        integer_symbols = [["I", "IV", "V", "IX"],
+                           ["X", "XL", "L", "XC"],
+                           ["C", "CD", "D", "CM"],
+                           ["M"]
+                           ]
+        roman_str = ""
+        counter = 0
+
+        while num != 0:
+            single = num % 10
+
+            if single in [1, 2, 3]:
+                roman_str = single * integer_symbols[counter][0] + roman_str
+            elif single == 4:
+                roman_str = integer_symbols[counter][1] + roman_str
+            elif single == 5:
+                roman_str = integer_symbols[counter][2] + roman_str
+            elif single in [6, 7, 8]:
+                roman_str = integer_symbols[counter][2] +\
+                    (single - 5) * integer_symbols[counter][0] +\
+                    roman_str
+            elif single == 9:
+                roman_str = integer_symbols[counter][3] + roman_str
+            else:
+                num = num / 10
+                counter += 1
+                continue
+            num = num / 10
+            counter += 1
+
+        return roman_str

13.py

@@ -0,0 +1,35 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def romanToInt(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        symbols_integer = {"I": 1, "V": 5, "X": 10, "L": 50,
+                           "C": 100, "D": 500, "M": 1000,
+                           "IV": 4, "IX": 9, "XL": 40, "XC": 90,
+                           "CD": 400, "CM": 900
+                           }
+        length = len(s)
+        integer = 0
+        isPass = False
+        for i in range(length):
+            # Subtractive notation use this symbol
+            if isPass:
+                isPass = False
+                continue
+            # Just add the integer
+            if s[i] in symbols_integer and s[i:i + 2] not in symbols_integer:
+                integer = integer + symbols_integer[s[i]]
+                isPass = False
+                continue
+
+            # Subtractive notation is used as follows.
+            if s[i:i + 2] in symbols_integer:
+                integer = integer + symbols_integer[s[i:i + 2]]
+                isPass = True
+
+        return integer

14.py

@@ -0,0 +1,28 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def longestCommonPrefix(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
+        if not strs:
+            return ""
+        common_prefix = strs[0]
+        for string in strs:
+            min_len = min(len(string), len(common_prefix))
+            mark = 0
+            for i in range(min_len):
+                mark = i
+                if string[i] == common_prefix[i]:
+                    i += 1
+                    mark = i
+                else:
+                    if i == 0:
+                        return ""
+                    break
+            common_prefix = common_prefix[:mark]
+
+        return common_prefix

15.py

@@ -0,0 +1,33 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def threeSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        solution = []
+        sorted_nums = sorted(nums)
+        length = len(sorted_nums)
+        for i in range(length):
+            cur_num = sorted_nums[i]
+            left = i + 1
+            right = length - 1
+            while left < right:
+                if sorted_nums[left] + sorted_nums[right] + cur_num < 0:
+                    left += 1
+                elif sorted_nums[left] + sorted_nums[right] + cur_num > 0:
+                    right -= 1
+                else:
+                    triplet = [sorted_nums[left], cur_num, sorted_nums[right]]
+                    solution.append(sorted(triplet))
+                    left += 1
+                    right -= 1
+
+        solution_unique = []
+        for sol in solution:
+            if sol not in solution_unique:
+                solution_unique.append(sol)
+        return solution_unique

16.py

@@ -0,0 +1,40 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def threeSumClosest(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        nums.sort()
+        min_distance = 2 ** 31 - 1
+        length = len(nums)
+        solution = 0                    # keep the sum of three nums
+        for i in range(length):
+            cur_num = nums[i]
+            left = i + 1
+            right = length - 1
+            while left < right:
+                left_num = nums[left]
+                right_num = nums[right]
+                three_sum = cur_num + left_num + right_num
+
+                # the right point go back
+                if three_sum > target:
+                    right -= 1
+                    if min_distance > three_sum - target:
+                        solution = three_sum
+                        min_distance = three_sum - target
+                # the left point go forward
+                elif three_sum < target:
+                    if min_distance > target - three_sum:
+                        solution = three_sum
+                        min_distance = target - three_sum
+                    left += 1
+                else:
+                    return three_sum
+
+        return solution

17.py

@@ -0,0 +1,40 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def letterCombinations(self, digits):
+        """
+        :type digits: str
+        :rtype: List[str]
+        """
+
+        phone_letters = {0: [" "],
+                         1: ["*"],
+                         2: ["a", "b", "c"],
+                         3: ["d", "e", "f"],
+                         4: ["g", "h", "i"],
+                         5: ["j", "k", "l"],
+                         6: ["m", "n", "o"],
+                         7: ["p", "q", "r", "s"],
+                         8: ["t", "u", "v"],
+                         9: ["w", "x", "y", "z"],
+                         }
+        if digits:
+            all_str = phone_letters[ord(digits[0]) - ord("0")]
+        else:
+            return []
+
+        for i in range(1, len(digits)):
+            all_str = self.combination(all_str, phone_letters[ord(digits[i]) - ord("0")])
+
+        return all_str
+
+    # return string which combines a in str_a with b in str_b
+    def combination(self, str_a, str_b):
+        combine_str = []
+        for a in str_a:
+            for b in str_b:
+                combine_str.append(a + b)
+
+        return combine_str

2.py

@@ -0,0 +1,47 @@
+#! /usr/bin/env python
+# -*- coding: utf-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
+        """
+        carry_in = 0
+        head = ListNode(0)
+        l_sum = head
+
+        while l1 and l2:
+            l_sum.next = ListNode((l1.val + l2.val + carry_in) % 10)
+            carry_in = (l1.val + l2.val + carry_in) / 10
+            l1 = l1.next
+            l2 = l2.next
+            l_sum = l_sum.next
+
+        if l1:
+            while l1:
+                l_sum.next = ListNode((l1.val + carry_in) % 10)
+                carry_in = (l1.val + carry_in) / 10
+                l1 = l1.next
+                l_sum = l_sum.next
+
+        if l2:
+            while l2:
+                l_sum.next = ListNode((l2.val + carry_in) % 10)
+                carry_in = (l2.val + carry_in) / 10
+                l2 = l2.next
+                l_sum = l_sum.next
+
+        if carry_in != 0:
+            l_sum.next = ListNode(carry_in)
+
+        return head.next

3.py

@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+
+        max_length = 0
+        start = 1
+        end = 1
+        index = 1
+        char_dict = {}
+
+        for char in s:
+            if char in char_dict and start <= char_dict[char] < end:
+                start = char_dict[char] + 1
+                end = index + 1
+            else:
+                end = index + 1
+                if end - start > max_length:
+                    max_length = end - start
+
+            char_dict[char] = index
+            index = index + 1
+
+        return max_length

5.py

@@ -0,0 +1,38 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+def longestPalindrome(s):
+    """
+    :type s: str
+    :rtype: str
+    """
+
+    length = len(s)
+    palindrome_record = [[0 for col in range(length)] for row in range(length)]
+
+    start = 0
+    end = 0
+    # length of the palindrome is less than 2
+    for i in range(length):
+        palindrome_record[i][i] = 1
+
+        if i + 1 < length and s[i] == s[i + 1]:
+            palindrome_record[i][i + 1] = 1
+            start = i
+            end = i + 1
+
+    # length of the palindrome is growing to len(s)
+    for len_of_palidrome in range(3, length + 1):
+        for i in range(length - len_of_palidrome + 1):
+            j = i + len_of_palidrome - 1
+            if palindrome_record[i + 1][j - 1] and s[i] == s[j]:
+                palindrome_record[i][j] = 1
+                start = i
+                end = i + len_of_palidrome
+
+    return s[start: end + 1]
+
+
+if __name__ == "__main__":
+    print longestPalindrome("abacdcaba")