LeetCode 答案（python）1-17

1.给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution:
     def twoSum(self, nums, target):
        """
         :type nums: List[int]
         :type target: int
        :rtype: List[int]
        """
         for i in nums:
             for j in range(nums.index(i) + 1, len(nums)):
                if i + nums[j] == target:
                     return (nums.index(i),j)

2.给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
#
# class Solution:
#     # @return a ListNode
#     def addTwoNumbers(self, l1, l2):
#         if l1 is None:
#             return l2
#         elif l2 is None:
#             return l1
#         else:
#             carry = 0
#             ret = ListNode(0)
#             ret_Last = ret
#
#             while (l1 or l2):
#                 sum = 0
#                 if (l1):
#                     sum = l1.val
#                     l1 = l1.next
#                 if (l2):
#                     sum += l2.val
#                     l2 = l2.next
#                 sum += carry
#                 ret_Last.next = ListNode(sum % 10)
#                 ret_Last = ret_Last.next
#                 carry = (sum >= 10)
#             if (carry):
#                 ret_Last.next = ListNode(1)
#             ret_Last = ret.next
#             del ret
#             return ret_Last

3.给定一个字符串，找出不含有重复字符的最长子串的长度。

示例：

给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。

给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。

给定 "pwwkew" ，最长子串是 "wke" ，长度是3。请注意答案必须是一个子串，"pwke" 是 子序列  而不是子串。

# class Solution:
#     def lengthOfLongestSubstring(self, s):
#         """
#         :type s: str
#         :rtype: int
#         """
#         Num = 0
#         for j in range(0, len(s)):
#             ns = ''
#             for i in s[j:]:
#                 if i not in ns:
#                     ns = ns + i
#                     num = len(ns)
#                 else:
#                     break
#
#             if num > Num:
#                 Num = num
#
#         return Num

　

4.给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。

请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。

示例 1:

nums1 = [1, 3]
nums2 = [2]

中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

中位数是 (2 + 3)/2 = 2.5

# class Solution:
#     def findMedianSortedArrays(self, nums1, nums2):
#         """
#         :type nums1: List[int]
#         :type nums2: List[int]
#         :rtype: float
#         """
#         length1 = len(nums1)
#         length2 = len(nums2)
#         total = length1 + length2
#         print(total)
#
#         alist = []
#         while len(nums1) and len(nums2):
#             if nums1[0] < nums2[0]:
#                 alist.append(nums1.pop(0))
#             else:
#                 alist.append(nums2.pop(0))
#         if nums1:
#             alist += nums1
#         else:
#             alist += nums2
#         print(alist)
#         if total % 2 == 0:
#             half = int(total / 2)
#             return (alist[half] + alist[half-1])/2
#         else:
#             half = int(total // 2)
#             return  alist[half]

　

5.给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

class Solution:
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        s='#'+'#'.join(s)+'#'
        ff = 0
        RL=[0]*len(s)
        MaxRight=0
        pos=0
        MaxLen=0
        for i in range(len(s)):
            if i<MaxRight:
                RL[i]=min(RL[2*pos-i], MaxRight-i)
            else:
                RL[i]=1
            #尝试扩展，注意处理边界
            while i-RL[i]>=0 and i+RL[i]<len(s) and s[i-RL[i]]==s[i+RL[i]]:
                RL[i]+=1
            #更新MaxRight,pos
            if RL[i]+i-1>MaxRight:
                MaxRight=RL[i]+i-1
                pos=i
            #更新最长回文串的长度
            # MaxLen=max(MaxLen, RL[i])
            ss = s[i - RL[i] + 1:i + RL[i]]
            ff = max(len(ss), ff)
            if len(ss) >= ff:
                a = ss

        a = a.replace('#','')
        return a

6.　将字符串 "PAYPALISHIRING" 以Z字形排列成给定的行数：

P   A   H   N
A P L S I I G
Y   I   R

之后从左往右，逐行读取字符："PAHNAPLSIIGYIR"

实现一个将字符串进行指定行数变换的函数:

string convert(string s, int numRows);

示例 1:

输入: s = "PAYPALISHIRING", numRows = 3
输出: "PAHNAPLSIIGYIR"

示例 2:

输入: s = "PAYPALISHIRING", numRows = 4
输出: "PINALSIGYAHRPI"
解释:

P     I    N
A   L S  I G
Y A   H R
P     I

class Solution:
    def convert(self, s, numRows):
        """
        :type s: str
        :type numRows: int
        :rtype: str
        """
        if numRows == 1:
            return s
        ff = []
        j = -1
        s = list(s)
        for i in range(numRows):
            ff.append([])

        while s!=[]:
            while j < numRows-1 and s!=[]:
                j += 1
                ff[j].append(s.pop(0))

            while j > 0 and s!=[]:
                j -= 1
                ff[j].append(s.pop(0))

        s = ''
        for i in range(numRows):
            s = s + ''.join(ff[i])
        return s

　7.给定一个 32 位有符号整数，将整数中的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231,  231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        if x < -pow(2,31) or x > pow(2,31)-1:
            return 0
        s = str(x)
        if len(s) == 1:
            return x
        s = s[::-1]
        if s.startswith('0'):
            s = s.lstrip('0')
        if s.endswith('-'):
            s = '-' + s.rstrip('-')
        i = int(s)
        if i < -pow(2,31) or i > pow(2,31)-1:
            return 0
        return i

　

9.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

class Solution:
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        s = list(str(x))

        s1 =list(str(x))
        s1.reverse()

        if  s1 == s:
            return True
        else:
            return False

　

10.给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符。
'*' 匹配零个或多个前面的元素。

匹配应该覆盖整个字符串 (s) ，而不是部分字符串。

说明:

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: '*' 代表可匹配零个或多个前面的元素, 即可以匹配 'a' 。因此, 重复 'a' 一次, 字符串可变为 "aa"。

示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。

示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 'c' 可以不被重复, 'a' 可以被重复一次。因此可以匹配字符串 "aab"。

示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

　

class Solution:
    def isMatch(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: bool
        """
        sLen = len(s)
        pLen = len(p)
        if (pLen == 0):
            return sLen == 0
        if (pLen == 1):
            if (p == s) or ((p == '.') and (len(s) == 1)):
                return True
            else:
                return False
        #p的最后一个字符不是'*'也不是'.'且不出现在s里，p跟s肯定不匹配
        if (p[-1] != '*') and (p[-1] != '.') and (p[-1] not in s):
            return False
        if (p[1] != '*'):
            if (len(s) > 0) and ((p[0]==s[0]) or (p[0]=='.')):
                return self.isMatch(s[1:],p[1:])
            return False
        else:
            while (len(s) > 0) and ((p[0]==s[0]) or (p[0]=='.')):
                if (self.isMatch(s,p[2:])):
                    return True
                s = s[1:]
            return self.isMatch(s,p[2:])

　

11.给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。画 n 条垂直线，使得垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

注意：你不能倾斜容器，n 至少是2。

class Solution:
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        head = 0
        tail = len(height) - 1
        max_water = 0
        while head < tail:
            max_water = max(max_water, min(height[head], height[tail]) * (tail - head))
            if height[head] < height[tail]:
                head += 1
            else:
                tail -= 1
        return max_water

　

14.编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。

说明:

所有输入只包含小写字母 a-z 。

class Solution:
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if len(strs)==0:
            return ""
        str=strs[0]
        Min=len(str)
        for i in range(1,len(strs)):
            j=0
            p=strs[i]
            while j<Min and j<len(p) and p[j]==str[j]:
                j+=1
            Min = Min if Min<j else j
        return str[:Min]

　

15.给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

# class Solution:
#     def threeSum(self, nums):
#         """
#         :type nums: List[int]
#         :rtype: List[List[int]]
#         """
#         diction = {}
#         for num in nums:
#             if num in diction:
#                 diction[num] += 1
#             else:
#                 diction[num] = 1
#
#         dictkey = diction.keys()
#         pos, neg = [], []
#         for p in dictkey:
#             if p >= 0:
#                 pos.append(p)
#             else:
#                 neg.append(p)
#
#         sorted(pos)
#         sorted(neg)
#
#         rsts = []
#         rst = []
#         if 0 in dictkey and diction[0] > 2:
#             rsts.append([0, 0, 0])
#         pos.reverse()
#         for p in pos:
#             for n in neg:
#                 inverse = -(p + n)
#                 if inverse in dictkey:
#                     if (inverse == p or inverse == n) and diction[inverse] > 1:
#                         rst = [inverse, p, n]
#                         rsts.append(sorted(rst))
#                     if inverse > p or inverse < n:
#                         rst = [inverse, p, n]
#                         rsts.append(sorted(rst))
#
#         return rsts

　

16.给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.

与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

class Solution:
    def threeSumClosest(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if len(nums) <= 3:
            return sum(nums)

        nums.sort()
        maxSum = sum(nums[-3:])
        minSum = sum(nums[:3])

        if target <= minSum:
            return minSum
        if target >= maxSum:
            return maxSum

        if target - minSum > maxSum - target:
            closet = maxSum
            distance = maxSum - target
        else:
            closet = minSum
            distance = target - minSum

        for i in range(len(nums) - 2):
            left = i + 1
            right = len(nums) - 1

            while left < right:

                s = nums[i] + nums[left] + nums[right]

                if abs(s - target) < distance:
                    closet = s
                    distance = abs(s - target)

                if s > target:
                    if nums[i] + 2 * nums[left] > target:
                        break

                    right -= 1

                else:
                    if nums[i] + 2 * nums[right] < target:
                        break

                    left += 1

        return closet

17.给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

class Solution:
    def __init__(self):
        self.dt = {'1':'',
                 '2':'abc',
                 '3':'def',
                 '4':'ghi',
                 '5':'jkl',
                 '6':'mno',
                 '7':'pqrs',
                 '8':'tuv',
                 '9':'wxyz',
                 '0':''}

    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        if len(digits) == 0: return []
        elif len(digits) == 1: return [s for s in self.dt[digits[0]]]

        elif len(digits) == 2:
            return [a+b for a in self.dt[digits[0]] for b in self.dt[digits[1]]]

        else:
            str_list = self.letterCombinations(digits[1:])
            return [a+b for a in self.dt[digits[0]] for b in str_list]