给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：
同样的元素不能重复使用（也就是不能自己加自己）
给定的数组中可能有相同的元素（比如 [3, 3, 4, 4, 5]）
class Solution:
"""
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：
同样的元素不能重复使用（也就是不能自己加自己）
给定的数组中可能有相同的元素（比如 [3, 3, 4, 4, 5]）
"""
def twoSum(self, nums, target):
i = 0
while i < len(nums):
if i == len(nums) - 1:
return "No solution here!"
r = target - nums[i]
# Can't use a num twice
num_follow = nums[i + 1:]
if r in num_follow:
return [i, num_follow.index(r) + i + 1]
i = i + 1
if __name__ == '__main__':
s = Solution()
print(s.twoSum([3, 3, 4, 4, 5], 9))
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [1，2, 7, 8，11, 15], target = 9
因为 nums[0] + nums[3] = 2 + 7 = 9
所以返回 [[0, 3],[1,2]]
这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：
b_index=[]
for i in mylist:
r=4-i
if r in mylist :
b_index.append([mylist.index(i),mylist.index(r)])
a.append((i,r))
mylist.remove(i)
print(b_index)
最大字符串长度
给定一个字符串，找出不含有重复字符的最长子串的长度。
示例：
给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。
给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。
给定 "himhbgghc" ，最长子串是 "imhbg" ，长度是5。请注意答案必须是一个子串，"pwke" 是 子序列 而不是子串。
class Solution:
"""
#最大字串长度
给定一个字符串，找出不含有重复字符的最长子串的长度。
示例：
给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。
给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。
给定 "himhbgghc" ，最长子串是 "imhbg" ，长度是5。请注意答案必须是一个子串，"pwke" 是 子序列 而不是子串。
"""
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int
"""
len_s = len(s)
if len_s == 0:
return 0
set_s = set(s)
# get the max_size of sild window
max_len = len(set_s)
max_sub_str = ""
while max_len:
if max_len == 1:
return 1
i = 0
while i + max_len <= len_s:
sub_s = s[i:i + max_len]
set_sub = set(sub_s)
# if there is no repeat in sub string
if len(set_sub) == len(sub_s):
max_sub_str = sub_s
return(len(list(max_sub_str)))
i = i + 1
# adjust the size of window
max_len = max_len - 1
if __name__ == '__main__':
s=Solution()
s.lengthOfLongestSubstring('himhbgghc') # 5 最长字串imhbg 不重复
中位数是一个可将数值集合划分为相等的上下两部分的一个数值。
如果列表数据的个数是奇数，则列表中间那个数据就是列表数据的中位数；
如果列表数据的个数是偶数，则列表中间那2个数据的算术平均值就是列表数据的中位数。
输入: 一个作为数组的整数(int)列表(list)的。
输出: 数组的中位数(int, float).
class Solution:
"""
中位数是一个可将数值集合划分为相等的上下两部分的一个数值。
如果列表数据的个数是奇数，则列表中间那个数据就是列表数据的中位数；
如果列表数据的个数是偶数，则列表中间那2个数据的算术平均值就是列表数据的中位数。
输入: 一个作为数组的整数(int)列表(list)的。
输出: 数组的中位数(int, float).
第一种
"""
def findMedianSortedArraysOne(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: float
"""
self.nums = nums1 + nums2
self.nums.sort() #[1,2,3,4]
size = len(self.nums)
if size % 2 == 1:
return self.nums[size // 2]
if size % 2 == 0:
return (self.nums[size // 2] + self.nums[size // 2 - 1]) / 2
"""
利用了取反数和为1的特性，通过列表负索引来获得列表中位数。
# 解析：
if len = 6, half = 3, -half = -4, 此时 ，对中间2个数 data[~half] 和 data[half] 求和，再取平均值
if len = 5， half = 2， ~half = -3, 此时 data[half] = data[~half] ，求和取平均，等于 data[half]
all: half + ~half = -1
第二种
"""
def findMedianSortedArraysTwo(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: float
"""
self.nums = nums1 + nums2
self.nums.sort() #[1,2,3,4]
size = len(self.nums)
half = size // 2
if size % 2 == 1:
return self.nums[half]
if size % 2 == 0:
return (self.nums[half] + self.nums[~half]) / 2
if __name__ == '__main__':
s=Solution()
s.findMedianSortedArraysOne([1,2,4],[5,6])
s.findMedianSortedArraysTwo([1,2,4],[5,6])
最长回文子串
回文是指正着读和倒着读，结果一些样，比如abcba或abba。
题目是要在一个字符串中要到最长的回文子串。
最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。
求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。
class Solution:
"""
最长回文子串
回文是指正着读和倒着读，结果一些样，比如abcba或abba。
题目是要在一个字符串中要到最长的回文子串。
最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。
求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。
"""
def longestPalindrome(self, s):
"""
:type s: str
:rtype: str
"""
s = s
mlen = len(s)
while True:
i = 0
while i + mlen <= len(s):
sl = s[i:i + mlen]
sr = sl[::-1]
if sl == sr:
return sl
i = i + 1
mlen = mlen - 1
if mlen == 0:
return "No solution"
if __name__ == '__main__':
s=Solution()
s.longestPalindrome('himhbggbc')
第二种
class Solution(object):
def longestPalindrome(self, s):
"""
:type s: str
:rtype: str
"""
# 使用动态规划，用空间换时间，把问题拆分
# 获取字符串s的长度
str_length = len(s)
# 记录最大字符串长度
max_length = 0
# 记录位置
start = 0
# 循环遍历字符串的每一个字符
for i in range(str_length):
# 如果当前循环次数-当前最大长度大于等于1 并 字符串[当前循环次数-当前最大长度-1:当前循环次数+1] == 取反后字符串
if i - max_length >= 1 and s[i-max_length-1: i+1] == s[i-max_length-1: i+1][::-1]:
# 记录当前开始位置
start = i - max_length - 1
# 取字符串最小长度为2，所以+=2，s[i-max_length-1: i+1]
max_length += 2
continue
# 如果当前循环次数-当前最大长度大于等于0 并 字符串[当前循环次数-当前最大长度:当前循环次数+1] == 取反后字符串
if i - max_length >= 0 and s[i-max_length: i+1] == s[i-max_length: i+1][::-1]:
start = i - max_length
# 取字符串最小长度为1，所以+=1，s[i-max_length: i+1]
max_length += 1
# 返回最长回文子串
return s[start: start + max_length]
if __name__ == '__main__':
s = "babad"
# s = "cbbd"
sl = Solution()
print(sl.longestPalindrome(s))
第三种
根据回文串对称性，分为奇数长度回文串和偶数长度回文串
def match(s):
res=0
for i in range(len(s)-1):
if s[i]==s[i+1]:#奇数长度
first=i
end=i+1
while first>=0 and end<len(s) and s[first]==s[end]:
#满足条件就向两边扩展
first-=1
end+=1
res=max(res,end-first-1)
elif s[i-1]==s[i+1]:#偶数长度
first=i-1
end=i+1
while first>=0 and end<len(s) and s[first]==s[end]:
first-=1
end+=1
res=max(res,end-first-1)
return res
match('abba')