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

RL[i]=min(RL[2*pos-i], MaxRight-i)

else:

RL[i]=1

#尝试扩展，注意处理边界

while i-RL[i]>=0 and 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

j+=1

Min = Min if Min

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]