devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

leetcode部分简单题题解

作者：小小林熬夜学编程 | 2024-06-07 10:34:35

赞

踩

leetcode部分简单题题解

背景：

        今天翻看了之前练习的一些题。发现还是不够简洁。原来“温故而知新，可以为师矣”是真的。索性直接贴出源码来露个像，当个现眼包。

        以前注重先实现，后优化。现在来看。确实有不少可以采用更简单的策略来实现。这也是编码能力的进阶了。在一些复杂场景下，只有优化代码策略才能满足。

        letcode后面的一些题，开始有二叉树了，那种题，本地还调试不了。慢慢记录就停了。

desc: 145. 二叉树的后序遍历
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 

  1. ""
  2.  
  3.  
  4. # Definition for a binary tree node.
  5. # class TreeNode:
  6. #     def __init__(self, val=0, left=None, right=None):
  7. #         self.val = val
  8. #         self.left = left
  9. #         self.right = right
  10. class Solution:
  11.  
  12.     def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
  13.         listt=[]
  14.         def rankt(root: Optional[TreeNode], listt:List[int]) -> List[int]:
  15.             if not root:
  16.                 return 
  17.             if root.left:
  18.                 rankt(root.left,listt)
  19.             if root.right:
  20.                 rankt(root.right,listt)
  21.  
  22.             listt.append(root.val)
  23.         rankt(root,listt)
  24.         return listt
  25. """
  26.

desc: 121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

  1. #2023-9-9 23:44:13 there is no better answer for this problem。 must be out of time including official answer
  2. def max_profit(prices=[]):
  3.     lenth = len(prices)
  4.     mark = 0
  5.     for i in range(1, lenth):
  6.         maxt = max(list(set(prices[i::])))
  7.         mint = min(list(set(prices[0:i])))
  8.         if maxt < mint:
  9.             continue
  10.         tmp = maxt - mint
  11.         mark = tmp if tmp > mark else mark
  12.     return mark
  13.  
  14. def max_profit2(prices=[]):
  15.     lenth = len(prices)
  16.     mark = 0
  17.     for i in range(1, lenth):
  18.         maxt = max(list(set(prices[i::])))
  19.         mint = min(list(set(prices[0:i])))
  20.         if maxt < mint:
  21.             continue
  22.         tmp = maxt - mint
  23.         mark = tmp if tmp > mark else mark
  24.     return mark
  25.  
  26. print(max_profit([1,2,4,11,7]))
  27. """

 没记录题目

  1. """
  3. start_time:
  4. end_time:
  5. desc: 模版
  7. def singleNumber(nums):
  8.     nums.sort()
  9.     lent = len(nums)-1
  10.     t=[nums[k] for k in range(lent) if k % 2 == 0 and nums[k] != nums[k + 1]]
  11.     return t[0] if t else nums[-1]
  13. def singleNumber2(nums):
  14.     nums.sort()
  15.     lent = len(nums)-1
  16.     #result = [nums[k] for k,_ in enumerate(nums) if nums[k]!=nums[k+1]]
  17.     for k in range(lent):
  18.         if k%2 ==0 and nums[k]!=nums[k+1]:
  19.             return nums[k]
  20.     return nums[-1]
  23. print(singleNumber([1,3,2,2,1,3,4]))
  24. """

desc: 验证回文串

  1. """
  3. desc: 验证回文串
  6. def isPalindrome(s):
  7.     s = [x.lower() for x in s if x.isalnum()]
  8.     return s==s[::-1]
  10. print(isPalindrome("A man, a plan, a canal: Panama"))
  11. print(isPalindrome("raceacar"))
  12. """

desc: 94：二叉树的中序遍历

  1. """
  3. end_time:
  4. desc: 94：二叉树的中序遍历
  7. def iteration(root,res):
  8.     if not root:
  9.         return
  10.     iteration(root.left,res)
  11.     res.append(root)
  12.     iteration(root.right,res):
  14. def vsxu(root):
  15.     res=[]
  16.     iteration(root,res)
  17.     return res
  18. """

desc: 88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

  1. #pass
  2. def combine_two_list(nums1, nums2, m, n):
  3.     i = 0
  4.     j = 0
  5.     while (i < m+n and j < n):
  6.         if nums1[i]< nums2[j]:
  7.             if i< m+j:
  8.                 i+=1
  9.             else:
  10.                 nums1[i] = nums2[j]
  11.                 j+=1
  12.         else:
  13.             nums1.insert(i,nums2[j])
  14.             nums1.pop(-1)
  15.             i+=1
  16.             j+=1
  17.  
  18.  
  19. def combine_two_list3(nums1, nums2, m, n):
  20.     i = 0
  21.     j = 0
  22.     while (i < m+n and j < n):
  23.         if nums1[i] != 0 and nums2[j] < nums1[i]:
  24.             nums1[i], nums2[j] = nums2[j], nums1[i]
  25.             i += 1
  26.         elif nums1[i] == 0 and nums2[j]:
  27.             nums1[i], nums2[j] = nums2[j], nums1[i]
  28.             j += 1
  29.         else:
  30.             i += 1
  31.  
  32.  
  33.  
  34. # 用了空间换时间。使用了切片。默认会copy一份nums来赋值。
  35. def combine_two_list2(nums1, nums2, m, n):
  36.     nums1 = nums1[:m-n ] + nums2
  37.     nums1.sort(reverse=False)
  38.  
  39.  
  40.  
  41. nums1 = [1,2,3,0,0,0]
  42. nums2 = [2,5,6]
  43. combine_two_list(nums1, nums2, 3, 3)
  44. print(nums1)
  45. """

desc: 83. 删除排序链表中的重复元素
给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

  1. """ 麻烦
  3. 二刷
  5. end_time: 
  6. desc: 83. 删除排序链表中的重复元素
  7. 给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
  8. val ,next
  10. class ListNode:
  11.     def __init__(self, val=0, next=None):
  12.         self.val = val
  13.         self.next = next
  15. def del_repeat(head:ListNode,tmp=[]):
  16.     if head is None:
  17.         return None
  18.     cur = head
  19.     while cur.next:
  20.         if cur.next.val == cur.val:
  21.             cur.next = cur.next.next
  22.         else:
  23.             cur = cur.next
  24.     return head
  26. print(del_repeat({"val":1,"next":{"val":1,"next":{"val":2,"next":{}}}}))
  27. """

desc: 70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例 1：
输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

  1. """
  3. desc: 70. 爬楼梯
  4. 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
  5. 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
  6. 示例 1：
  7. 输入：n = 2
  8. 输出：2
  9. 解释：有两种方法可以爬到楼顶。
  10. 1. 1 阶 + 1 阶
  11. 2. 2 阶
  12. 示例 2：
  13. 输入：n = 3
  14. 输出：3
  15. 解释：有三种方法可以爬到楼顶。
  16. 1. 1 阶 + 1 阶 + 1 阶
  17. 2. 1 阶 + 2 阶
  18. 3. 2 阶 + 1 阶
  20. def n_n(N):
  21.     if N<=1:
  22.         return 1
  23.     else:
  24.         return N*n_n(N-1)
  25. def climb_stairs(stairs=0):
  26.     num_method=0
  27.     for i in range(stairs+1):
  28.         if (stairs-i) % 2==0:
  29.             if stairs-i !=0:
  30.                 tmp1= n_n(i+(stairs-i)//2)
  31.                 tmp2=(n_n((stairs-i)//2)*n_n(i))
  32.                 tmp = tmp1/tmp2
  33.                 print("tmp=",tmp,"i=",i)
  34.                 num_method+=tmp
  35.             else:
  36.                 num_method+=1
  38.     return int(num_method)
  39. print(climb_stairs(stairs=2))
  40. """

desc: 快速排序。

如题，快速排序是很牛的一种排序方式。

  1. """
  3. end_time:
  4. desc: 快速排序。
  6. def quick_sort(alist,left=None,right=None):
  7.     left=0 if not left else left
  8.     right=len(alist)-1 if not right else right
  9.     if left>=right or left<0 or right<=0:
  10.         return
  11.     pivot = alist[left]
  12.     index=left+1
  13.     while(index<=right):
  14.         if alist[index]<pivot:
  15.             alist[index],alist[left] = alist[left],alist[index]
  16.             left+=1
  17.         else:
  18.             #index+=1
  19.             pass
  20.         index+=1
  21.     quick_sort(alist,0,left-1)
  22.     quick_sort(alist,left,right)
  23.     pass
  25. a_list = [random.randint(1, 100) for x in range(10)]
  26. b_list= [5,1,3,4,8,1,7,2,5,9,6,1]
  27. quick_sort(b_list, None, None)
  28. print(b_list)
  30. #用空间换遍历，使用了额外的内存空间。
  31. def quick_sort2(alist, left=None, right=None):
  32.     left = 0 if not left else left
  33.     right = len(alist) - 1 if not right else right
  34.     if left >= right:
  35.         return alist
  36.     index = left + 1
  37.     slist = []
  38.     llist = []
  39.     while (index <= right):
  40.         if alist[left] < alist[index]:
  41.             llist.append(alist[index])
  42.         else:
  43.             slist.append(alist[index])
  44.         index += 1
  45.     left_list = quick_sort(slist, left=0, right=len(slist) - 1)
  46.     right_list = quick_sort(llist, left=0, right=len(llist) - 1)
  47.     return left_list+[alist[left]]+right_list
  48.     pass
  50. def quick_sort2_x(a_list, left=None, right=None):
  51.     if left > right:
  52.         return
  53.     left = 0 if not left else left
  54.     right = len(a_list) - 1 if not right else right
  55.     pivot = left
  56.     left = left + 1
  57.     while (left <= right):
  58.         if a_list[left] > a_list[pivot]:
  59.             while (a_list(right) < a_list(pivot) and right > left):
  60.                 right -= 1
  61.             a_list[left], a_list[right] = a_list[right], a_list[left]
  62.             left += 1
  63.             right -= 1
  64.         left += 1
  65.     a_list[pivot], a_list[left] = a_list[left], a_list[pivot]
  66.     quick_sort(a_list, None, left)
  67.     quick_sort(a_list, left + 1, None)
  68.     pass
  69. """

desc: 69. x 的平方根
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例 1：
输入：x = 4
输出：2
示例 2：
输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

  1. """
  3. end_time:
  4. desc: 69. x 的平方根
  5. 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
  6. 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
  7. 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
  8. 示例 1：
  9. 输入：x = 4
  10. 输出：2
  11. 示例 2：
  12. 输入：x = 8
  13. 输出：2
  14. 解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
  18. def squre_root(x):
  19.     pass
  22. # 法1：遍历。x越大，耗时越久。
  23. def squre_root1(x):
  24.     if x in [0, 1]:
  25.         return x
  26.     for y in range(2, 2 + x // 2):
  27.         if y * y > x:
  28.             return y - 1
  29.     return -1
  30.     pass
  33. print(squre_root(1))
  34. print(squre_root(2))
  35. print(squre_root(4))
  36. print(squre_root(8))
  37. """

两种解法。28min分钟。内存消耗都比较大。24%胜率在内存。
desc: 66. 加一
 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：

输入：digits = [0]
输出：[1]

  1. """
  3. 两种解法。28min分钟。内存消耗都比较大。24%胜率在内存。
  4. desc: 66. 加一
  5.  给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
  6. 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
  7. 你可以假设除了整数 0 之外，这个整数不会以零开头。
  8. 示例 1：
  9. 输入：digits = [1,2,3]
  10. 输出：[1,2,4]
  11. 解释：输入数组表示数字 123。
  12. 示例 2：
  13. 输入：digits = [4,3,2,1]
  14. 输出：[4,3,2,2]
  15. 解释：输入数组表示数字 4321。
  16. 示例 3：
  18. 输入：digits = [0]
  19. 输出：[1]
  20. def devide_number(int_d):
  21.     if int_d // 10 == 0:
  22.         return [int_d]
  23.     return devide_number(int_d // 10) + [int_d % 10]
  24.     # if int_d//10 !=0:
  25.     #     return devide_number(int_d)+ list[int_d//10]
  26.     # return list[int_d]
  28. def add_one(digits=[]):
  29.     len_d = len(digits)  # 123,3
  30.     origin_d = 0
  31.     for k, x in enumerate(digits):
  32.         origin_d += x * 10 ** (len_d - 1 - k)
  33.     arm_d = origin_d + 1
  34.     return devide_number(arm_d)
  36. def plusOne(digits=[]):
  37.     len_d = len(digits)  # 123,3
  38.     origin_d = 0
  39.     for k, x in enumerate(digits):
  40.         origin_d += x * 10 ** (len_d - 1 - k)
  41.     arm_d = origin_d + 1
  42.     return [int(x) for x in str(arm_d)]
  43. print(add_one([1, 2, 3]))
  44. print(add_one([4, 3, 2, 1]))
  45. print(add_one([0]))
  46. """


desc: 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 1：
输入：s = "Hello World"
输出：5
解释：最后一个单词是“World”，长度为5。
示例 2：
输入：s = "   fly me   to   the moon  "
输出：4
解释：最后一个单词是“moon”，长度为4。
示例 3：
输入：s = "luffy is still joyboy"
输出：6
解释：最后一个单词是长度为6的“joyboy”。
提示：

1 <= s.length <= 104
s 仅有英文字母和空格 ' ' 组成
s 中至少存在一个单词
 

  1. """
  3. desc: 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
  4. 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
  5. 示例 1：
  6. 输入：s = "Hello World"
  7. 输出：5
  8. 解释：最后一个单词是“World”，长度为5。
  9. 示例 2：
  10. 输入：s = "   fly me   to   the moon  "
  11. 输出：4
  12. 解释：最后一个单词是“moon”，长度为4。
  13. 示例 3：
  14. 输入：s = "luffy is still joyboy"
  15. 输出：6
  16. 解释：最后一个单词是长度为6的“joyboy”。
  17. 提示：
  19. 1 <= s.length <= 104
  20. s 仅有英文字母和空格 ' ' 组成
  21. s 中至少存在一个单词
  24. def length_of_last_word(s):
  25.     return len(s.strip().split(" ")[-1])
  27. print(length_of_last_word("Hello World"))
  28. print(length_of_last_word("   fly me   to   the moon  "))
  29. print(length_of_last_word("luffy is still joyboy"))
  30. """

number:35. 搜索插入位置
desc: 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。

  1.  
  2. """
  4. number:35. 搜索插入位置
  5. desc: 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
  6. 请必须使用时间复杂度为 O(log n) 的算法。
  10. def search_insert_position2(nums=[], target=None):
  11.     for k, x in enumerate(nums):
  12.         if x == target:
  13.             return k
  14.         elif x > target:
  15.             return k
  16.         else:
  17.             continue
  18.     return len(nums)
  19.     pass
  22. def search_insert_position(nums=[], target=None):
  23.     # 内存使用
  24.     k = len(nums)
  26.     for x in range(k):
  27.         if nums[x] == target:
  28.             return x
  29.         elif nums[x] > target:
  30.             return x
  31.     return k
  34. def search_insert_position3(nums=[], target=None):
  35.     # 内存使用最小,击败92.61%的内存python3用户。
  36.     tmp = [k for k, v in enumerate(nums) if v >= target]
  37.     if not tmp:
  38.         return len(nums)
  39.     else:
  40.         return tmp[0]
  41. """

desc: 有效的括号,g给定一个只包括（），{}，[]的字符串 s ,判断字符串是否有效
有效字符串需满足：
1、左括号必须用相同类型的右括号闭合
2、左括号必须以正确的顺序闭合
3、每个右括号都有一个对应的相同类型的左括号。
test= （），（）[]{}, （], ([)], )]([

评价：第一批次处理很快，时间少于20分钟。但是处理两个较复杂的场景时调试耗时较多。超过40分钟

  1. """
  3. desc: 有效的括号,g给定一个只包括（），{}，[]的字符串 s ,判断字符串是否有效
  4. 有效字符串需满足：
  5. 1、左括号必须用相同类型的右括号闭合
  6. 2、左括号必须以正确的顺序闭合
  7. 3、每个右括号都有一个对应的相同类型的左括号。
  8. test= （），（）[]{}, （], ([)], )]([
  10. 评价：第一批次处理很快，时间少于20分钟。但是处理两个较复杂的场景时调试耗时较多。超过40分钟
  12. def enable_bracket(strs):
  13.     # 通过偶数判断是否成对，快速判断有效
  14.     if len(strs) % 2 != 0:
  15.         return False
  16.     # 符合区分判断 周期特长X
  17.     # 通过3个计数来判断，+1，-1。小于0时则false 正解
  18.     count_s_bra = 0
  19.     count_m_bra = 0
  20.     count_l_bra = 0
  21.     # 需要将记录最后一个add 或者reduce的符号改为 顺序存所有的符号
  22.     add_sign_list = []
  23.     reduce_sign_list = []
  24.     for x in strs:
  25.         if count_l_bra < 0 or count_m_bra < 0 or count_s_bra < 0:
  26.             return False
  27.         if reduce_sign_list != []:
  28.             if add_sign_list == []:
  29.                 return False
  30.             rs = reduce_sign_list.pop(-1)
  31.             if rs == add_sign_list[-1]:
  32.                 add_sign_list = add_sign_list[:-1]
  33.             else:
  34.                 return False
  35.         if x == "(":
  36.             count_s_bra += 1
  37.             add_sign_list.append(1)
  38.         elif x == ")":
  39.             count_s_bra -= 1
  40.             reduce_sign_list.append(1)
  41.         elif x == "[":
  42.             count_m_bra += 1
  43.             add_sign_list.append(2)
  44.         elif x == "]":
  45.             count_m_bra -= 1
  46.             reduce_sign_list.append(2)
  47.         elif x == "{":
  48.             count_l_bra += 1
  49.             add_sign_list.append(3)
  50.         elif x == "}":
  51.             count_l_bra -= 1
  52.             reduce_sign_list.append(3)
  53.         else:
  54.             print("字符串内部存在非法字符")
  55.             return False
  56.     if count_l_bra != 0 or count_m_bra != 0 or count_s_bra != 0:
  57.         return False
  58.     else:
  59.         return True
  60. print(enable_bracket("()"))
  61. print(enable_bracket("()[]{}"))
  62. print(enable_bracket("(]"))
  63. print(enable_bracket("([)]"))
  64. print(enable_bracket(")](["))
  65. print(enable_bracket("(([]){})"))
  66. print(enable_bracket("[([]])"))
  67. """

 desc: 14 最长公共前缀，查找字符串最长公共前缀
strs=["flower","flow","flight"]
输出："f1"

  1. """
  3. desc: 14 最长公共前缀，查找字符串最长公共前缀
  4. strs=["flower","flow","flight"]
  5. 输出："f1"
  7. def common_str(strs):
  8.     # 判空：
  9.     if not strs:
  10.         return ""
  11.     # 以最短字符串长度进行遍历，相似则计数+1
  12.     min_len = len(strs[0])
  13.     for x in strs:
  14.         if len(x) < min_len:
  15.             min_len = len(x)
  16.     times = -1
  17.     end_flag=0
  18.     for i in range(0, min_len):
  19.         value = strs[0][i]
  20.         if end_flag == 1:
  21.             i-=1
  22.             times=i- 1
  23.             break
  24.         times = i
  25.         for x in strs:
  26.             if x[i] != value:
  27.                 end_flag = 1
  28.                 times = times-1
  29.                 break
  31.     if times == -1:
  32.         return ""
  33.     else:
  34.         # 以结果计数，进行切片返回
  35.         return strs[0][:times+1]
  36. strs = ["fltoweradfadf", "fltoweadfad", "fltoweiwght"]
  37. print(common_str(strs))
  38. """

 desc: 一个字符串，求第一个不重复值的下标

  1. """
  3. desc: 一个字符串，求第一个不重复值的下标
  5. def mt_test(test:str):
  6.     #test:待测字符串
  7.     #第一步：判断为空
  8.     if len(test)<1:
  9.         return -1
  10.     #转换类型
  11.     list_test = list(test)
  12.     result ={}
  13.     #第二步：统计字段个数
  14.     for i in list_test:
  15.         if i not in result.keys():
  16.             result[i] = 1
  17.         else:
  18.             result[i] += 1
  19.     #第三步：
  20.     aim = [x for x in result.keys() if result[x] == 1]
  21.     tmp_k = -1
  22.     for k, v in enumerate(test):
  23.         if v == aim[0]:
  24.             tmp_k = k
  25.     return tmp_k
  26. test = "abcabcdeefg"
  27. print(mt_test(test))
  28. print(mt_test(""))
  29. print(mt_test("adjfklacasnihcuwejccjawoeuirsbncjnajksd"))
  30. print(mt_test([]))
  31. print(mt_test(123))
  32. """

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/685022
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号