编程题（Python）

回文数

N = abs(int(input()))
str1 = str(N)
lenth = len(str1)
flag = 1
for i in range(lenth//2):
    if str1[i] != str1[lenth-i-1]:
        flag = 0
        break
if flag == 1:
    print('Yes')
else:
    print("No")

有符号整数反转

# 输入一个有符号整数，输出该整数的反转值。
n = int(input())
n1 = str(abs(n))
out = n1[::-1]    #字符串反转
out = int(out)    #取整，去掉0，如004变为4
if n>=0:
    print(out)
else:
    if out ==0:
        print('')
    else:
        print('-'+ str(out))

输出最长公共子串

s1 = input()
s2 = input()
maxlen = 0
p = 0
res =[[0 for i in range(len(s2)+1)] for j in range(len(s1)+1)]
for i in range(len(s1)):
    for j in range(len(s2)):
        if s1[i]==s2[j]:
            res[i+1][j+1]=res[i][j]+1
            maxlen = max(maxlen,res[i+1][j+1])
            p =i+1
print(maxlen)
print(s1[p-maxlen:p])

输出最长公共子序列

def LCS(s1, s2):
    res = [[0 for i in range(len(s2) + 1)] for j in range(len(s1) + 1)]
    for i in range(1, len(s1) + 1):
        for j in range(1, len(s2) + 1):
            if s1[i - 1] == s2[j - 1]:
                res[i][j] = res[i - 1][j - 1] + 1
            else:
                res[i][j] = max(res[i - 1][j], res[i][j - 1])
    return res
def GetLCS(i,j,res, s1, s2, s):
    while i > 0 and j > 0:
        if s1[i - 1] == s2[j - 1]:
            s += s1[i - 1]
            i -= 1
            j -= 1
        else:
            if res[i - 1][j] > res[i][j - 1]:
                i -= 1
            elif res[i - 1][j] < res[i][j - 1]:
                j -= 1
            else:
                GetLCS(i - 1, j, res, s1, s2, s)
                GetLCS(i, j - 1, res, s1, s2, s)
                return
    print(s[::-1])
if __name__ == '__main__':
    s1 = input()
    s2 = input()
    s = ''
    res = LCS(s1, s2)
    print(res[-1][-1])
    GetLCS(len(s1), len(s2), res, s1, s2, s)

字符串逆序

方法一：切片逆序

a='123456'
print(a[::-1])

方法二：遍历构造列表法:循环遍历字符串， 构造列表，从后往前添加元素, 最后把列表变为字符串

a= '12345'
def nixu(a):
    n = len(a)
    ll = []
    for i in range(n-1,-1,-1):
        ll.append(a[i])
    return ll
print(''.join(nixu(a)))

方法三：使用reverse函数:将字符串转换为列表使用reverse函数

a = '12345'
a = list(a)
a.reverse()
print(''.join(a))

方法四:递归实现，每次取最后一个字符

a = '12345'
def nixu(a):
    if len(a)<=1:
        return a
    else:
        return a[-1]+nixu(a[:-1])
print(nixu(a))

方法五:使用中间值不变,调换左右两边对应的值

a = '12345'
a = list(a)
n = len(a)
for i in range(n//2):
    a[i],a[n-i-1] = a[n-i-1],a[i]
print(''.join(a))

无重复字符最长连续子串

str = input()
def longest(s):
   start = 0  #无重复连续字符串开始位置
   end = 0 #指针遍历，先移动end，直到出现重复字符，start移到该重复字符上一次出现的位置
   same = {} #非重复字符及其出现位置，若遇到重复字符，则更新其出现的下标位置
   maxl = 0
   ss = ''  #未重复字符连续字串
   for i in range(len(s)):
      if s[i] in same.keys(): #出现重复字符，将start移到该重复字符上次出现的位置+1，将出现位置的值变为当前i
         start = same[s[i]]+1
         for k, v in list(same.items()):  #若出现重复，就将start之前出现的所有字符及其下标全部删除
               #因为若不删除，比如adda，出现重复字符d时，start已经到了2，但是从2开始a又会被当作重复字符，start就变成了1
               # 在第二个d出现之后，这个位置之前的所有字符都不能算为已经出现的字符。
            if v< start:
               del same[k]
         # same[s[i]] = i
      #如果未出现重复字符 ，无论是否为重复字符，都需要将该字符的位置下标 置为当前下标i
      same[s[i]] = i
      end = end +1
      maxl = max(maxl, end - start)
      ss =s[start:end]
      # print('i=%d,start=%d,end=%d,maxl=%d'%(i,start,end,maxl),same,ss)
   print(maxl)
longest(str)

斐波拉切记忆递归

n = int(input())
F = [-1]*(n+1)  #利用列表将前面的值进行存储，默认为-1，表示未计算过
def fib(n):
    if n == 0:
        return 0
    if n==1:
        return 1
    if F[n] == -1:  # 如果未计算过，即未存储，就递归继续前两位，如果是计算过的，就直接返回值，
        F[n] = fib(n-1)+fib(n-2)
    return F[n]     # （前面三个if都不满足，即是已经计算存储过的值，直接return），最后计算完执行return
a = fib(n)
print(a)

LeetCode编程题

来源：力扣（LeetCode）

删除排序数组中的重复项

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

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

示例 1:
给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        j = 0  #记录无重复元素的下标
        for i in range(len(nums)-1):
        #遇到不同的元素，就把j加1，因为从0开始，即第一个数肯定是不变的，所以从当前的下一个位置开始修改为不重复的元素。
            if nums[i+1] != nums[i]:  
                j = j + 1
                nums[j] = nums[i+1]
        return j+1

盛最多水的容器

链接：https://leetcode-cn.com/problems/container-with-most-water
给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例：
输入：[1,8,6,2,5,4,8,3,7]
输出：49

class Solution:
    def maxArea(self, height: List[int]) -> int:
        # 超出时间限制
        # maxV = 0
        # for i in range(len(height)-1):
        #     for j in range(i+1,len(height)):
        #         V = min(height[i],height[j]) * (j-i)
        #         maxV = max(maxV,V)
        # return maxV
        i = 0
        j = len(height)-1
        #使用快速选择的思想
        maxV = 0  
        while i < j:
            if height[i] <= height[j]:  #左边的比右边高度小，则左边的指针往右移
                v = height[i] * (j-i)
                i = i+1
            else:   #右边的比左边高度小，则右边的指针往左移
                v = height[j] * (j-i)
                j = j-1
            maxV = max(v,maxV)
        return maxV

验证二叉搜索树

链接：https://leetcode-cn.com/problems/validate-binary-search-tree/

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
 节点的左子树只包含小于当前节点的数。
 节点的右子树只包含大于当前节点的数。
 所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/
1 3
输出: true

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/validate-binary-search-tree

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        #每个二叉树的根，
        def bianli(root,lower,upper):
            if root :
                num = root.val  
                #判断每个二叉树的根，是否在（最大值，最小值）区间内。
                if num <= lower or num >= upper:   
                    return False
                if not bianli(root.left,lower,num):   #左子树，最小值是无穷小，最大值是根
                    return False
                if not bianli(root.right,num,upper):   #右子树，最小值是根，最大值是无穷大
                    return False
            return True  
        return bianli(root,lower = float("-inf"),upper = float("inf"))

二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
  # BFS
        if root is None:
            return 0
        queue = [(1, root)]
        while queue:
            depth, node = queue.pop(0)
            if node.left:
                queue.append((depth+1,node.left))
            if node.right:
                queue.append((depth+1,node.right))
        return depth