update solutions

Author: SYSU-TomJx

11.container-with-most-water.py

@@ -0,0 +1,59 @@
+#
+# @lc app=leetcode id=11 lang=python
+#
+# [11] Container With Most Water
+#
+# https://leetcode.com/problems/container-with-most-water/description/
+#
+# algorithms
+# Medium (42.47%)
+# Total Accepted:    320.1K
+# Total Submissions: 751.3K
+# Testcase Example:  '[1,8,6,2,5,4,8,3,7]'
+#
+# Given n non-negative integers a1, a2, ..., an , where each represents a point
+# at coordinate (i, ai). n vertical lines are drawn such that the two endpoints
+# of line i is at (i, ai) and (i, 0). Find two lines, which together with
+# x-axis forms a container, such that the container contains the most water.
+#
+# Note: You may not slant the container and n is at least 2.
+#
+#
+#
+#
+#
+# The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In
+# this case, the max area of water (blue section) the container can contain is
+# 49.
+#
+#
+#
+# Example:
+#
+#
+# Input: [1,8,6,2,5,4,8,3,7]
+# Output: 49
+#
+#
+class Solution(object):
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        max_area = 0
+        head = 0
+        tail = len(height) - 1
+        # Calculating the area by moving two pointers in bi-direction.
+        while (tail > head):
+            area = min([height[head], height[tail]])*(tail-head)
+            if area > max_area:
+                max_area = area
+            if height[head] > height[tail]:
+                tail = tail - 1
+            else:
+                head = head + 1
+
+        return max_area
+
+

12.integer-to-roman.py

@@ -0,0 +1,127 @@
+#
+# @lc app=leetcode id=12 lang=python
+#
+# [12] Integer to Roman
+#
+# https://leetcode.com/problems/integer-to-roman/description/
+#
+# algorithms
+# Medium (49.70%)
+# Total Accepted:    204.4K
+# Total Submissions: 410.8K
+# Testcase Example:  '3'
+#
+# Roman numerals are represented by seven different symbols: I, V, X, L, C, D
+# and M.
+#
+#
+# Symbol       Value
+# I             1
+# V             5
+# X             10
+# L             50
+# C             100
+# D             500
+# M             1000
+#
+# For example, two is written as II in Roman numeral, just two one's added
+# together. Twelve is written as, XII, which is simply X + II. The number
+# twenty seven is written as XXVII, which is XX + V + II.
+#
+# Roman numerals are usually written largest to smallest from left to right.
+# However, the numeral for four is not IIII. Instead, the number four is
+# written as IV. Because the one is before the five we subtract it making four.
+# The same principle applies to the number nine, which is written as IX. There
+# are six instances where subtraction is used:
+#
+#
+# I can be placed before V (5) and X (10) to make 4 and 9.
+# X can be placed before L (50) and C (100) to make 40 and 90.
+# C can be placed before D (500) and M (1000) to make 400 and 900.
+#
+#
+# Given an integer, convert it to a roman numeral. Input is guaranteed to be
+# within the range from 1 to 3999.
+#
+# Example 1:
+#
+#
+# Input: 3
+# Output: "III"
+#
+# Example 2:
+#
+#
+# Input: 4
+# Output: "IV"
+#
+# Example 3:
+#
+#
+# Input: 9
+# Output: "IX"
+#
+# Example 4:
+#
+#
+# Input: 58
+# Output: "LVIII"
+# Explanation: L = 50, V = 5, III = 3.
+#
+#
+# Example 5:
+#
+#
+# Input: 1994
+# Output: "MCMXCIV"
+# Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+#
+#
+class Solution(object):
+    def intToRoman(self, num):
+        """
+        :type num: int
+        :rtype: str
+        """
+        tbl = {1:'I', 5:'V', 10:'X', 50:'L', 100:'C', 500:'D', 1000:'M'}
+        num_lst = []
+        while num != 0:
+            tmp = num % 10
+            num_lst.append(tmp)
+            num = num / 10
+        x = 1
+        res = []
+        for num in num_lst:
+            if num >3 and num <9:
+                key_1 = 5
+            else:
+                key_1 = 1
+            prim_key = key_1 * x
+            prim_val = tbl[prim_key]
+            minor_val = tbl[x] # I, X, C, M
+            tmp_str = ''
+            cmp_key = num
+            if cmp_key==4 or cmp_key==9:
+                if cmp_key == 9:
+                    prim_val = tbl[prim_key*10]
+                tmp_str = minor_val + prim_val # minor, primal
+            elif cmp_key<=3:
+                for i in range(cmp_key):
+                    tmp_str = tmp_str + minor_val # primal, primal, primal
+
+            elif cmp_key>5 and cmp_key<=8:
+                # primal, minor,...
+                tmp_str =  prim_val
+                for i in range(cmp_key-5):
+                    tmp_str = tmp_str + minor_val
+            elif cmp_key == 5:
+                tmp_str = prim_val
+            res.append(tmp_str)
+            x = x * 10
+        res = res[::-1]
+        res = ''.join(res)
+        return res
+
+
+
+

15.3-sum.py

@@ -0,0 +1,90 @@
+#
+# @lc app=leetcode id=15 lang=python
+#
+# [15] 3Sum
+#
+# https://leetcode.com/problems/3sum/description/
+#
+# algorithms
+# Medium (23.34%)
+# Total Accepted:    485.6K
+# Total Submissions: 2.1M
+# Testcase Example:  '[-1,0,1,2,-1,-4]'
+#
+# Given an array nums of n integers, are there elements a, b, c in nums such
+# that a + b + c = 0? Find all unique triplets in the array which gives the sum
+# of zero.
+#
+# Note:
+#
+# The solution set must not contain duplicate triplets.
+#
+# Example:
+#
+#
+# Given array nums = [-1, 0, 1, 2, -1, -4],
+#
+# A solution set is:
+# [
+# ⁠ [-1, 0, 1],
+# ⁠ [-1, -1, 2]
+# ]
+#
+#
+#
+'''
+class Solution(object):
+    def threeSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        nums_len = len(nums)
+        visible_ids = []
+        for i in range(nums_len):
+
+            j = i + 1
+            while j < nums_len:
+                arr_col = nums[i] + nums[j]
+                if -arr_col in nums[j+1:]:
+                    ids_set = [nums[i], nums[j], -arr_col]
+                    ids_set.sort()
+                    if ids_set not in visible_ids:
+                        visible_ids.append(ids_set)
+                j = j + 1
+        return visible_ids
+'''
+class Solution(object):
+
+    def threeSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        nums_len = len(nums)
+        if nums_len < 3:
+            return []
+        nums.sort()
+        visible_ids = []
+        for i in range(nums_len-2):
+            if i >0 and nums[i] == nums[i-1]:
+                continue
+            head, tail = i+1, nums_len-1
+
+            while head < tail:
+                sum_res = nums[head] + nums[tail] + nums[i]
+                if sum_res < 0:
+                    head += 1
+                elif sum_res > 0:
+                    tail -= 1
+                else:
+                    visible_ids.append((nums[head], nums[tail], nums[i]))
+                    while head<tail and nums[head] == nums[head+1]:
+                        head += 1
+                    while tail>head and nums[tail] == nums[tail-1]:
+                        tail -= 1
+                    head += 1
+                    tail -= 1
+        return visible_ids
+
+

16.3-sum-closest.py

@@ -0,0 +1,60 @@
+#
+# @lc app=leetcode id=16 lang=python
+#
+# [16] 3Sum Closest
+#
+# https://leetcode.com/problems/3sum-closest/description/
+#
+# algorithms
+# Medium (38.77%)
+# Total Accepted:    286K
+# Total Submissions: 704.1K
+# Testcase Example:  '[-1,2,1,-4]\n1'
+#
+# Given an array nums of n integers and an integer target, find three integers
+# in nums such that the sum is closest to target. Return the sum of the three
+# integers. You may assume that each input would have exactly one solution.
+#
+# Example:
+#
+#
+# Given array nums = [-1, 2, 1, -4], and target = 1.
+#
+# The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+#
+#
+#
+class Solution(object):
+    def threeSumClosest(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        nums_len = len(nums)
+        if nums_len < 3:
+            return []
+        nums.sort()
+        visible_ids = []
+        closest = target
+        margin = 9999
+        sum_res = 0
+        for i in range(nums_len-2):
+            if i >0 and nums[i] == nums[i-1]:
+                continue
+            head, tail = i+1, nums_len-1
+
+            while head < tail:
+                sum_res = nums[head] + nums[tail] + nums[i]
+                tmp_margin = max(sum_res, target) - min(sum_res, target)
+                if tmp_margin < margin:
+                    margin = tmp_margin
+                    closest = sum_res
+                if sum_res < target:
+                    head += 1
+                elif sum_res > target:
+                    tail -= 1
+                else:
+                    return sum_res
+        return closest
+

17.letter-combinations-of-a-phone-number.py

@@ -0,0 +1,42 @@
+#
+# @lc app=leetcode id=17 lang=python
+#
+# [17] Letter Combinations of a Phone Number
+#
+# https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/
+#
+# algorithms
+# Medium (40.29%)
+# Total Accepted:    348.2K
+# Total Submissions: 862K
+# Testcase Example:  '"23"'
+#
+# Given a string containing digits from 2-9 inclusive, return all possible
+# letter combinations that the number could represent.
+# 
+# A mapping of digit to letters (just like on the telephone buttons) is given
+# below. Note that 1 does not map to any letters.
+# 
+# 
+# 
+# Example:
+# 
+# 
+# Input: "23"
+# Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+# 
+# 
+# Note:
+# 
+# Although the above answer is in lexicographical order, your answer could be
+# in any order you want.
+# 
+#
+class Solution(object):
+    def letterCombinations(self, digits):
+        """
+        :type digits: str
+        :rtype: List[str]
+        """
+        
+