给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

nums = [2,7,11,15]
target = 9

for i in range(len(nums)):
    for j in range(i+1,len(nums)):
            if nums[i] + nums[j] == target:
                print([i,j])

2.三数之和（超时了311/313)

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

nums = [-1, 0, 1, 2, -1, -4]
target = 0
lis1=[]
lis2=[]
for i in range(len(nums)):
    for j in range(i+1,len(nums)-2):
        for k in range(j + 1, len(nums)-1):
            if nums[i] + nums[j] + nums[k] == target:
                lis = [nums[i],nums[j],nums[k]]
                lis1.append(lis)
                break
for l in range(len(lis1)):
    lis1[l].sort()
for m in lis1:
    if m not in lis2:
        lis2.append(m)
print(lis2)

3.无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串的长度。

    maxm = 0
    for i in range(len(s)):
        if s[i] in l:
            p = l.index(s[i])
            l = l[p+1:]
        l.append(s[i])
        maxm = max(len(l),maxm)
    return maxm

4.寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和 nums2 不会同时为空

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

nums1.extend(nums2)
nums1.sort()
n = len(nums1)
if n%2 == 0:
   x = (nums1[int(n/2-1)]+nums1[int(n/2)])/2
   print(float(x))
else:
   y = nums1[int((n-1)/2)]
   print(float(y))

5.整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。（假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0）

x = -12345

int_a = abs(x)
str_b = str(int_a)[::-1]
int_c = int(str_b)
if x > 0 and int_c < 2 ** 31 - 1:
    print(int_c)
elif -int_c > -2 ** 31 and x <= 0:
    print(-int_c)
else:
    print(0)

6.回文数

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

x = -121
y = int(str(abs(x))[::-1])
print(y==x)

7.有效括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

s = '()'

while '()' in s or '[]' in s or '{}' in s:
            s = s.replace('()','')
            s = s.replace('[]', '')
            s = s.replace('{}', '')
print( not s)

8.两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

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

lis = []
for i in nums1:
    for j in nums2:
        if i == j:
            lis.append(i)
new_lis = []
for i in lis:
    if i not in new_lis:
        new_lis.append(i)
return (new_lis)

9.实现strStr()

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

haystack = "hello"
needle = "ll"
print(haystack.find(needle))

10.收索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。

nums = [1,3,4,6]
target =5

if target in nums:
    print(nums.index(target))
else:
    nums.append(target)
    nums.sort()
    print(nums.index(target))

11.只出现一次数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

nums=[2,2,1]

if len(nums) == 1:
    return (nums[0])
else:
    nums.sort()
    if nums[0] != nums[1]:
        return (nums[0])
    elif nums[-1] != nums[-2]:
        return (nums[-1])
    else:
        for i in range(1, len(nums) - 1):
            if nums[i] != nums[i - 1] and nums[i] != nums[i + 1]:
                return (nums[i])

12.存在重复元素

给定一个整数数组，判断是否存在重复元素。如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

nums = [1,2,3,1]
return (len(set(nums)) != len(nums))

13.买卖股票最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。

prices = [7,1,5,3,6,4]

lis = []
for i in range(len(prices)-1):
    if prices[i+1]<prices[i]:
        continue
    else :
        l = max(prices[(i + 1):])
        m = l - prices[i]
        lis.append(m)
if lis != [] and max(lis)>0:
    s = max(lis)
    return(s)
else:
    return(0)

14.找不同

给定两个字符串 s 和 t，它们只包含小写字母。字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。请找出在 t 中被添加的字母。

s = "abcd"
t = "abcde"

if not s:
    return(t[0])
else:
    lis_s=list(s)
    lis_t=list(t)
    lis_s.sort()
    lis_t.sort()
    if lis_s[0]==lis_t[0]:
        for i in range(len(t)):
            if lis_t[0:i]+lis_t[i+1:len(t)+1] == lis_s:
                return(lis_t[i])
    else:
        return(lis_t[0])

15.按奇偶排序数组

给定一个非负整数数组 A，返回一个由 A 的所有偶数元素组成的数组，后面跟 A 的所有奇数元素。你可以返回满足此条件的任何数组作为答案。

lis1 = []
lis2 = []
for i in range(len(A)):
    if A[i]%2 == 0:
        lis1.append(A[i])
    else :    
        lis2.append(A[i])
lis1.extend(lis2)
return(lis1)

16.有序数组的平方

给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

A = [-4,-1,0,3,10]

lis = []
for i in A:
    lis.append(i**2)
lis.sort()
return(lis)

17.删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成

for i in range(len(nums)-1, 0,1):
    if nums[i] == nums[i-1]: 
       del nums[i]
return len(nums)

18.最小差值

给定一个整数数组 A，对于每个整数 A[i]，我们可以选择任意 x 满足 -K <= x <= K，并将 x 加到 A[i] 中。在此过程之后，我们得到一些数组 B。返回 B 的最大值和 B 的最小值之间可能存在的最小差值。

A = [1,3,6], K = 3

a=min(A)
b=max(A)
m=a-b
t=2*K
if m>=-t and m<=t:
   return(0)
else :
   return(abs(m)-t)

19.重复 N 次的元素

在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。返回重复了 N 次的那个元素。

A=[5,1,5,2,5,3,5,4]
l = len(A)
for i in range(l):
    for j in range(i+1,l):
        if A[i] == A[j]:
            return(A[i])

20.求众数

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在众数。

nums.sort()
s=nums[len(nums)//2]
return(s) 

21.最大间距

给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。如果数组元素个数小于 2，则返回 0。

nums.sort()
lis=[]
if len(nums)<=1:
    return(0)
else:
    for i in range(len(nums)-1,0,-1):
        s=nums[i]-nums[i-1]
        lis.append(s)
return(max(lis))

22.宝石与石头

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。J 中的字母不重复，J和S中的所有字符都是字母。字母区分大小写，因此"a"和"A"`是不同类型的石头。

J = "aA" 
S = "aAAbbbb"

m=0
for i in S:
    if i not in J:
        m+=1
n=len(S)-m
return(n)

23.盛最多水的容器

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。说明：**你不能倾斜容器，且 n 的值至少为 2。

l = 0
r = len(height) - 1
contain = 0
while l < r:
    contain = max(contain, (r-l)*min(height[l],height[r]))
    if height[l] > height[r]:
        r -= 1
    else:
        l += 1

return contain

24.翻转图像

给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。

A=[[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]

lis = []
for i in range(len(A)):
    A[i].reverse()
    for j in range(len(A[i])):
        A[i][j]=1-A[i][j]
    lis.append(A[i])
return(lis)#  25.[唯一摩尔斯密码词](https://leetcode-cn.com/problems/unique-morse-code-words/)

25.唯一的莫尔斯密码词

国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: "a" 对应 ".-", "b" 对应 "-...", "c" 对应 "-.-.", 等等。为了方便，所有26个英文字母对应摩尔斯密码表如下：

[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]

给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，"cab" 可以写成 "-.-..--..."，(即 "-.-." + "-..." + ".-"字符串的结合)。我们将这样一个连接过程称作单词翻译。返回我们可以获得所有词不同单词翻译的数量。

dic = {"a": ".-", "b": "-...", "c": "-.-.", "d": "-..", "e": ".", "f": "..-.", "g": "--.", "h": "....", "i": "..",
       "j": ".---", "k": "-.-", "l": ".-..", "m": "--", "n": "-.", "o": "---", "p": ".--.", "q": "--.-", "r": ".-.",
       "s": "...", "t": "-", "u": "..-", "v": "...-", "w": ".--", "x": "-..-", "y": "-.--", "z": "--.."}            
lis=[]
for i in range(len(words)):
    s = ''
    for j in range(len(words[i])):
        s += dic[words[i][j]]
    lis.append(s)
# print(lis)
s_set=set(lis)
return(len(s_set))

26.机器人能否返回原点

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束.移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。

a=0
b=0
c=0
d=0
for i in moves:
    if i=='R':
        a+=1
    if i=='L':
        b+=1
    if i=='U':
        c+=1
    if i=='D':
        d+=1
return(a==b and c==d)

27.自除数

自除数 是指可以被它包含的每一位数除尽的数。例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。还有，自除数不允许包含 0 。给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。

上边界left = 1, 下边界right = 22

lis=[]
for i in range(left,right+1):
    a = str(i)
    b = int(a)
    x = ''
    if '0' not in a:
        for j in a:
            if b%int(j)==0:
                x+=j
            else:
                break
        if len(x) == len(a):
            lis.append(int(x))
return(lis)

28.增减字符串匹配

给定只含 "I"（增大）或 "D"（减小）的字符串 S ，令 N = S.length。返回 [0, 1, ..., N] 的任意排列 A 使得对于所有 i = 0, ..., N-1，都有：

• 如果 S[i] == "I"，那么 A[i] < A[i+1]
• 如果 S[i] == "D"，那么 A[i] > A[i+1]

S="IDID"

a=0
b=len(S)
A=[]
for i in S:
    if i=='I':                
        A.append(a)
        a+=1
    if i=='D':
        A.append(b)
        b-=1
A.append(a)
return(A)

29.斐波那契数

斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0,   F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

给定 N，计算 F(N)。

class Solution:
    def fib(self, N: int) -> int:
        if N==0:
            return(0)
        if N==1:
            return(1)
        else:
            return(self.fib(N-1)+self.fib(N-2))

30.按奇偶排序数组 II

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。你可以返回任何满足上述条件的数组作为答案。

lis1=[]
lis2=[]
lis=[]
for i in A:
    if i%2==0:
        lis1.append(i)
    else:
        lis2.append(i)
for j in range(len(A)/2):
    lis.append(lis1[j])
    lis.append(lis2[j])
return(lis)

31.数组拆分 I

给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        n=len(nums)/2
        s=0
        for i in range(int(n)):
            s+=nums[2*i]
        return(s)

32.反转字符串中的单词 III

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

s ="Let's take LeetCode contest"

class Solution:
    def reverseWords(self, s: str) -> str:
        m=s.split(' ')
        t=''
        for i in m:
            n=i[::-1]+' '
            t+=n
            rev_s=t.strip()
        return(rev_s)

33.只出现一次的数字 III

给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。

nums=[1,2,1,3,2,5]

class Solution:
    def singleNumber(self, nums: List[int]) -> List[int]:
        if len(nums)<3:
            return(nums)
        nums.sort()
        lis=[]
        if nums[0]!=nums[1]:
            lis.append(nums[0])
        if nums[-2]!=nums[-1]:
            lis.append(nums[-1])
        for i in range(len(nums)-2):
            if nums[i]!=nums[i+1] and nums[i+1]!=nums[i+2]:
                lis.append(nums[i+1])
                if len(lis)>2:
                    break            
        return(lis)

34.各位相加

给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。

class Solution:
    def addDigits(self, num: int) -> int:
        if  num<10:
            return(num)
        else:
            num_s=str(num)
            s=0
            for i in num_s:
                s+=int(i)
                num=s
            return(self.addDigits(num))

35.除数博弈

爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：

• 选出任一 x，满足 0 < x < N 且 N % x == 0 。
• 用 N - x 替换黑板上的数字 N 。

如果玩家无法执行这些操作，就会输掉游戏。只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。(逻辑：偶数必赢，奇数必输)

class Solution:
    def divisorGame(self, N: int) -> bool:
        return(N%2==0)

36.棒球比赛

你现在是棒球比赛记录员。
给定一个字符串列表，每个字符串可以是以下四种类型之一：
1.整数（一轮的得分）：直接表示您在本轮中获得的积分数。
2. "+"（一轮的得分）：表示本轮获得的得分是前两轮有效 回合得分的总和。
3. "D"（一轮的得分）：表示本轮获得的得分是前一轮有效 回合得分的两倍。
4. "C"（一个操作，这不是一个回合的分数）：表示您获得的最后一个有效 回合的分数是无效的，应该被移除。

每一轮的操作都是永久性的，可能会对前一轮和后一轮产生影响。你需要返回你在所有回合中得分的总和。

class Solution:
   def calPoints(self, ops: List[str]) -> int:
       stack = []
       for op in ops:
           if op == '+':
               stack.append(stack[-1] + stack[-2])
           elif op == 'C':
               stack.pop()
           elif op == 'D':
               stack.append(2 * stack[-1])
           else:
               stack.append(int(op))
       return(sum(stack))

37.汉明距离

两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。给出两个整数 x 和 y，计算它们之间的汉明距离。

注意：0 ≤ x, y < 231.

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        k=0
        lis1=[]
        lis2=[]
        if x <= y:
            x, y = y, x
    while x:
        lis1.append(int(x%2))
        x=x//2
    for i in range(len(lis1)):
        if int(y%2)!=lis1[i]:
            k+=1
        y=y//2
    return k

38.数字的补数

给定一个正整数，输出它的补数。补数是对该数的二进制表示取反。

注意:

1. 给定的整数保证在32位带符号整数的范围内。
2. 你可以假定二进制数不包含前导零位。

class Solution:
    def findComplement(self, num: int) -> int:
        lis=[]
        s=0
        while num:
            lis.append(int(num%2))
            num=num//2
        for i in range(len(lis)):
            if lis[i]==0:
                s+=2**i
        return s

39.字符的最短距离

给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。

示例 1:

输入: S = "loveleetcode", C = 'e'
输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]

class Solution:
    def shortestToChar(self, S: str, C: str) -> List[int]:
        L=S.split(C)
        lis = []
        if S[0]!=C:
            for m in range(len(L[0]),0,-1):
                lis.append(m)
            lis.append(0)
        else:
            lis.append(0)
        for i in L[1:-1]:
            if i:
                for j in range(1,len(i)+1):
                    if j<=len(i)//2:
                        lis.append(j)
                    else:
                        lis.append(len(i)+1-j)
            lis.append(0)
        if S[-1]!=C:
            for n in range(1,len(L[-1])+1):
                lis.append(n)
        return(lis)

40.有序数组中的单一元素

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        if len(nums)==1:
            return(nums[0])
        else:
            nums.sort()
            if nums[0]!=nums[1]:
                return(nums[0])
            else:
                for i in range(len(nums)-2):
                    if nums[i]!=nums[i+1] and nums[i+1]!=nums[i+2]:
                        return(nums[i+1])
                else:
                    return(nums[-1])

41.杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5
输出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        ans = [[1], [1, 1]]
        if numRows == 0:
            return []
        elif numRows == 1:
            return ans[:-1]
        elif numRows == 2:
            return ans
        else:  # numRows >= 3
            for row in range(2, numRows):  # 执行几次生成列表的过程
                lis = [1]
                for i in range(0, len(ans[-1])-1):  # 推导中间的数，添加到列表lst
                    num = ans[-1][i] + ans[-1][i + 1]
                    lis.append(num)
                lis.append(1)
                ans.append(lis)
            return ans

42.分糖果

给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

class Solution:
    def distributeCandies(self, candies: List[int]) -> int:
        m=len(set(candies))
        n=len(candies)
        if m>=n/2:
            return(int(n/2))
        else:
            return m

43.Fizz Buzz

写一个程序，输出从 1 到 n 数字的字符串表示。

1. 如果 n 是3的倍数，输出“Fizz”；

2. 如果 n 是5的倍数，输出“Buzz”；

3. 3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。

示例：

n = 15,

返回:
[
    "1",
    "2",
    "Fizz",
    "4",
    "Buzz",
    "Fizz",
    "7",
    "8",
    "Fizz",
    "Buzz",
    "11",
    "Fizz",
    "13",
    "14",
    "FizzBuzz"
]

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        lis=[]
        for i in range(1,n+1):
            if i%3==0 and i%5!=0:
                lis.append('Fizz')
            elif i%3!=0 and i%5==0:
                lis.append('Buzz')
            elif i%3==0 and i%5==0:
                lis.append('FizzBuzz')
            else:
                lis.append(str(i))
        return lis

44.下一个更大元素I

给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        lis=[]
        for n1 in nums1:
            l1=nums2.index(n1)
            for l2 in range(l1,len(nums2)):
                if nums2[l2]>n1:
                    lis.append(nums2[l2])
                    break
            else:
                lis.append(-1)
        return(lis)