SDUT—Python程序设计实验五(列表与元组)

如果你对python中的列表和元组的使用还不是很熟悉，这篇文章也许会提供一些帮助：
Python数据容器之列表(list)与元组(tuple)

7-1 sdut-ASCII码排序

输入N个字符后，按各字符的ASCII码从小到大的顺序输出这N个字符。

输入格式:
输入数据有多组，每组占一行，有N个字符组成。

输出格式:
对于每组输入数据，输出一行，字符中间用一个空格分开。

输入样例:

Input1231
qwe1321
asddsfadsfadsf
zxc1321132dsfa
abcABCDFdefgDEFGHIJhijakfdsadsf;dsa
1
2
3
4
5

输出样例:

1 1 2 3 I n p t u
1 1 2 3 e q w
a a a d d d d f f f s s s s
1 1 1 2 2 3 3 a c d f s x z
; A B C D D E F F G H I J a a a a b c d d d d e f f f g h i j k s s s
1
2
3
4
5

代码：

try:
    while True:
        ls = list(input())
        ls.sort()
        print(*ls, sep=' ')
except EOFError:
    pass
1
2
3
4
5
6
7

7-2 sdut-数据逆序

一行输入N个整数，按逆序输出数值。

输入格式:
输入有多行。

每行有若干个整数，用空格分隔。

输出格式:
对于每行输入，将数值逆序输出，数值以空格隔开。

输入样例:

1 3 5 9 7 6 8 2 4 0 234 656 2223
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
-3 -43 23 435 -5667 231 100 2002 2035
1
2
3

输出样例:

2223 656 234 0 4 2 8 6 7 9 5 3 1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
2035 2002 100 231 -5667 435 23 -43 -3
1
2
3

代码：

try:
    while True:
        ls = list(input().split())
        ls.reverse()
        print(*ls, sep=' ')
except EOFError:
    pass
1
2
3
4
5
6
7

7-3 计算 1+2+3+…+m

输入一个正整数m(0<=m<=100)，计算 1+2+3+…+m 的值。

输入格式:
多组输入。

在一行输入一个正整数m。

输出格式:
对应每一行输入，在一行中按照格式“sum=S”输出对应的和S.

输入样例:

10
100
1
2

输出样例:
在这里给出相应的输出。例如：

sum=55
sum=5050
1
2

代码：

try:
    while True:
        n = int(input())
        sum = 0
        for i in range(1, n + 1):
            sum += i
        print("sum=%d" % sum)
except EOFError:
    pass
1
2
3
4
5
6
7
8
9

7-4 sdut-统计身高超过平均值的学生

中小学生每个学期都要体检，量身高，因为身高可以反映孩子的生长状况。
现在，一个班的身高已经量好了，请输出其中超过平均身高的那些学生的身高。

输入格式:
输入为一行数据，以空格分隔，每个数据都是一个正整数。

输出格式:
输出超过身高平均数的学生的身高数值，每个数后面有一个空格。

输出的顺序和输入的相同。

输入样例:

143 174 119 127 117 164 110 128
1

输出样例:

143 174 164 
1

代码：

ls = [float(n) for n in input().split()]
avg = float(sum(ls) / len(ls) * 1.0)
for each in ls:
    if each > avg:
        print(int(each), end=' ')
1
2
3
4
5

7-5 sdut-求整数的位数及各位数字之和

对于给定的正整数N，求它的位数及其各位数字之和。
(用Python实现提示：把整数转换成字符串，列表，用sum和len函数)

输入格式:
输入在一行中给出一个正整数N。

输出格式:
在一行中输出N的位数及其各位数字之和，中间用一个空格隔开。

输入样例:

456
1

输出样例:

3 15
1

代码：

ls = list(map(int, input()))
print(len(ls), sum(ls))
1
2

7-6 sdut-字母替换

编写程序，将输入字符串中的大写英文字母按以下对应规则替换，其他字符不变。
(Python实现提示：转换表用元组实现）

原字母 对应字母

    A        Z
    B        Y
    C        X
    D        W
   ...       ...
    X        C
    Y        B
    Z        A
1
2
3
4
5
6
7
8

输入格式:
在一行中输入字符串。

输出格式:
在一行中给出替换完成后的字符串。

输入样例:

This is a pen.
1

输出样例:
在这里给出相应的输出。例如：

Ghis is a pen.
1

代码：

s1 = input()
s2 = ""
for i in s1:
    if i.isupper():
        s2 += chr(155 - ord(i))
    else:
        s2 += i
print(s2)
1
2
3
4
5
6
7
8

7-7 sdut-输出字母在字符串中位置索引

输入一个字符串，再输入两个字符，求这两个字符在字符串中的索引。

输入格式:
第一行输入字符串；

第二行输入两个字符，用空格分开。

输出格式:
从右向左输出字符和索引（中间有一个空格）。下标最大的字符最先输出。每行一个。

输入样例:

pmispsissippi
s p
1
2

输出样例:

11 p
10 p
8 s
7 s
5 s
4 p
3 s
0 p
1
2
3
4
5
6
7
8

代码：

s = input()
c1, c2 = input().split()
for i in range(len(s) - 1, -1, -1):
    if s[i] == c1 or s[i] == c2:
        print(i, s[i])
1
2
3
4
5

7-8 sdut- 输出10个不重复的英文字母

输入一个字符串，把最左边的10个不重复的英文字母（不区分大小写）挑选出来进行输出
如没有10个英文字母，显示信息“not found”。

输入格式:
在一行中输入字符串。

输出格式:
在一行中输出最左边的10个不重复的英文字母；或者显示信息：“not found"

输入样例1:

poemp134567
1

输出样例1:

not found
1

输入样例2:

This 156is a test example
1

输出样例2:

Thisaexmpl
1

代码：

s1 = input()
s2 = ""
for each in s1:
    if each.isalpha() and each.upper() not in s2 and each.lower() not in s2:
            s2 += each
if len(s2) < 10:
    print("not found")
else:
    print(s2[0:10])
1
2
3
4
5
6
7
8
9

7-9 sdut-判断两个字符串是否为变位词

如果一个字符串是另一个字符串的重新排列组合，那么这两个字符串互为变位词。
比如，“heart” 与 “earth” 互为变位词，“Mary” 与 “arMy” 也互为变位词。“Hello world"与“worldHello"不是变位词。

输入格式:
第一行输入第一个字符串；
第二行输入第二个字符串。

输出格式:
若是变位词，输出：yes；否则，输出：no。

输入样例1:

Mary
arMy
1
2

输出样例1:

yes
1

输入样例2:

hello world
world hello
1
2

输出样例2:

yes
1

输入样例3:

I am very good.
verygood I am.
1
2

输出样例3:

no
1

代码：

from collections import *

def slv(s1, s2):
    if Counter(s1) == Counter(s2):
        print("yes")
    else:
        print("no")

sa = input()
sb = input()
slv(sa, sb)
1
2
3
4
5
6
7
8
9
10
11

7-10 sdut-猴子选大王

一群猴子要选新猴王。新猴王的选择方法是：
让N只候选猴子围成一圈，从某位置起顺序编号为1~N号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。
请问是原来第几号猴子当选猴王？

输入格式:
在一行中给一个正整数N（≤1000）。

输出格式:
在一行中输出当选猴王的编号。

输入样例:

11
1

输出样例:

7
1

代码：

n,p = int(input()),0
for i in range(2, n + 1):
    p = (p + 3) % i
print(p + 1)
1
2
3
4

7-11 sdut-找出两组数据中非公共元素

给定两行输入，每行代表一组元素。求两组中非公共的元素。

输入格式:
在两行中给出两组元素，每行的元素间用空格分开。在一行中每个元素只出现一次。

输出格式:
在一行中按照元素的输入顺序输出不是两组共有的元素，以空格分隔。（题目保证至少存在一个这样的元素）

输入样例:

10 3 -5 2 8 0 5 -15 9 100
10 6 4 8 2 -5 9 0 100 1
1
2

输出样例:

3 5 -15 6 4 1
1

代码：

ls1 = list(input().split())
ls2 = list(input().split())
ls3 = []
for it in ls1:
    if it in ls1 and it in ls2:
        pass
    else:
        ls3.append(it)
for it in ls2:
    if it in ls1 and it in ls2:
        pass
    else:
        ls3.append(it)
print(*ls3, sep=' ')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7-12 sdut-特定矩阵元素和

给定一个n×n的方阵，计算该矩阵主、副对角线上的所有元素之和。
主对角线为从矩阵的左上角至右下角的连线；副对角线为从矩阵的右上角至左下角的连线。

输入格式:
输入第一行给出正整数n（1

随后n行，每行给出n个数，其间以空格分隔。

输出格式:
在一行中给出该矩阵主、副对角线的所有元素之和。

输入样例1

4
2 3 4 1
5 6 1 1
7 1 8 1
1 1 1 1
1
2
3
4
5

输出样例1

21
1

输入样例2

3
1 2 3
4 5 6
7 8 9
1
2
3
4

输出样例2

25
1

代码：

n = int(input())
ls1, sum = [], 0
for i in range(n):
    ls2 = input().split()
    ls1.insert(i, ls2)
    sum += int(ls1[i][i]) + int(ls1[i][n - 1 - i])
if n % 2:
    sum -= int(ls1[n // 2][n // 2])
print(sum)
1
2
3
4
5
6
7
8
9

7-13 sdut-矩阵行、列、对角线和的最大值

求一个3*3矩阵每行、每列及对角线和的最大值。

输入格式:
在一行输入9个整数。

输出格式:
在一行输出每行、每列及对角线和的最大值。

输入样例:

3 6 5 9 8 2 1 4 5
1

输出样例:

19
1

代码：

num=list(map(int,input().split()))
l=[]
l.append(num[0]+num[4]+num[8])
l.append(num[2]+num[4]+num[6])
for i in range(0,6,3):
    l.append(num[i]+num[i+1]+num[i+2])
for j in range(0,3):
    l.append(num[j]+num[j+3]+num[j+6])
print(max(l))
1
2
3
4
5
6
7
8
9

7-14 sdut-判断上、下三角矩阵

给定一个三角矩阵，判断其是否为：上三角矩阵、下三角矩阵。
上三角矩阵指主对角线以下的元素都为0的矩阵；
下三角矩阵指主对角线以上的元素都为0的矩阵；
主对角线为从矩阵的左上角至右下角的连线。
输入矩阵是三种情况之一：上三角矩阵、下三角矩阵或者都不是。

输入格式:
输入第一行给出一个正整数T，为待测矩阵的个数。
接下来给出T个矩阵的信息：
每个矩阵信息的第一行给出一个不超过10的正整数n。
随后n行，每行给出n个整数，其间以空格分隔。

输出格式:
每个矩阵的判断结果占一行。
如果输入的矩阵是上三角矩阵，输出“upper”，如果输入的矩阵是下三角矩阵，输出“lower”，都不是输出“no”。

输入样例:

3
3
1 2 3
0 4 5
0 0 6
2
1 0
-8 2
4
1 2 4 0
56 5 7 9
3 4 8 9
0 0 0 0
1
2
3
4
5
6
7
8
9
10
11
12
13

输出样例:

upper
lower
no
1
2
3

代码：

T = int(input())
for i in range(T):
    t = int(input())
    s = []
    s1 = 0
    s2 = 0
    for j in range(t):
        s.append(list(map(int,input().split())))
    for j in range(t):
        for k in range(t):
            if k > j:
                s1 += s[j][k]
            elif k < j:
                s2 += s[j][k]
    if s1 == 0 and s2 != 0:
        print("lower")
    elif s1 != 0 and s2 == 0:
        print("upper")
    else:
        print("no")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7-15 sdut-打印显示直角字母图形

给定行数，输出指定行数的字母组成的图形。

输入格式:
在一行内给出行数n，1<=n<=10。

输出格式:
输出由大小字母组成的直角图形。

输入样例1:

2
1

输出样例1:

A
AB
1
2

输入样例2:

7
1

输出样例2:

A
AB
ABC
ABCD
ABCDE
ABCDEF
ABCDEFG
1
2
3
4
5
6
7

代码：

s="ABCDEFGHIJ"
n=int(input())
for i in range(n):
    for j in range(i+1):
        print(s[j],end='')
    print()
1
2
3
4
5
6

7-16 sdut-array2-4 打印“杨辉三角“ 品中国数学史 增民族自豪感（1）

背景介绍： 北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。

南宋数学家杨辉在《详解九章算法》（1261年）记载并保存了“贾宪三角”，故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角，是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

杨辉三角数字的特点为：

（1）在三角形的首列和对角线上，数值均为1；

（2）其余数据为：每个数字等于上一行的左右两个数字之和，第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，用公式表示为： C(n+1,i)=C(n,i)+C(n,i-1)。

图示为：

杨辉三角的应用：(a+b)的n次方，展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n（1<=n<=13)。

输出格式:
每个数字占据4个字符的位置，数字左对齐，数字不足4位的右边留出空格。

输入样例:

13
1

输出样例:

1   
1   1   
1   2   1   
1   3   3   1   
1   4   6   4   1   
1   5   10  10  5   1   
1   6   15  20  15  6   1   
1   7   21  35  35  21  7   1   
1   8   28  56  70  56  28  8   1   
1   9   36  84  126 126 84  36  9   1   
1   10  45  120 210 252 210 120 45  10  1   
1   11  55  165 330 462 462 330 165 55  11  1   
1   12  66  220 495 792 924 792 495 220 66  12  1 
1
2
3
4
5
6
7
8
9
10
11
12
13

代码:

from math import *
def c(n, r):
    if n == 0 or r == 0:
        return 1
    else:
        return int(factorial(n) / (factorial(r) * factorial(n - r)))

x = int(input())
all,l = [], []
for n in range(x):
    for r in range(n + 1):
        l.append(c(n, r))
    all.append(l[:])
    l.clear()
for n in range(x):
    for nn in range(n + 1):
        print("%-4d" % all[n][nn], end='')
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7-17 sdut-array2-5 打印“杨辉三角“ 品中国数学史 增民族自豪感（2）

背景介绍：
北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。
南宋数学家杨辉在《详解九章算法》（1261年）记载并保存了“贾宪三角”，故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角，是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年，比贾宪迟600年。

杨辉三角数字的特点为：
（1）在三角形的首列和对角线上，数值均为1；
（2）其余数据为：每个数字等于上一行的左右两个数字之和，第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，用公式表示为： C(n+1,i)=C(n,i)+C(n,i-1)。

图示为：

杨辉三角的应用：(a+b)的n次方，展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n（1<=n<=13)。

输出格式:
（1）输出的数据为等腰三角形样式；
（2）每个数字占据4个字符的位置，数字左对齐，数字不足4位的右边留出空格；
（3）最后一行的数值“1”顶格，前面无空格。

提示：以n=5，分析行首空格数为：

输入样例1:

5
1

输出样例:

        1   
      1   1   
    1   2   1   
  1   3   3   1   
1   4   6   4   1
1
2
3
4
5

输入样例2:

6
1

输出样例:

          1   
        1   1   
      1   2   1   
    1   3   3   1   
  1   4   6   4   1   
1   5   10  10  5   1  
1
2
3
4
5
6

代码：

from math import *

def c(n, r):
    if n == 0 or r == 0:
        return 1
    else:
        return int(factorial(n) / (factorial(r) * factorial(n - r)))

x = int(input())
all = []
l = []
for n in range(x):
    for r in range(n + 1):
        l.append(c(n, r))
    all.append(l[:])
    l.clear()
cnt = x*2-2
for n in range(x):
    print(' '*cnt, end='')
    for nn in range(n + 1):
        print("%-4d" % all[n][nn], end='')
    print()
    cnt -= 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7-18 sdut-列表去重

输入一个列表，去掉列表中重复的数字，按原来次序输出！

输入格式:
在一行中输入列表。

输出格式:
在一行中输出不重复的列表元素。

输入样例1:

[4,7,5,6,8,6,9,5] 
1

输出样例1:

4 7 5 6 8 9
1

输入样例2:

[1,2,3,"abcd","hello",1,2,3,4,5,6] 
1

输出样例2:

1 2 3 abcd hello 4 5 6
1

代码：

ls1 = eval(input())
ls2 = sorted(set(ls1), key=ls1.index)
print(*ls2, sep=' ')
1
2
3

7-19 sdut-期末考试之排名次

期末考试结束了，童鞋们的成绩也出来的了，可是为了排名次可忙坏了老师，因为学生太多了。这时，老师把这个任务交给了你，希望你能帮老师完成。作为IT人，你当然不能用笨笨的人工方法了，编程解决才是好办法。
共有三门课，语文、数学和英语，要求根据学生的各科成绩计算出其总成绩，并根据总成绩从高到低排序.

输入格式:
第一行一个整数N（N<=100），代表学生的人数。
接下来的N行数据，每行有三个整数，C,M,E分别代表一个学生语文、数学和英语的成绩.

输出格式:
一共N行，每行一个数，从大到小，分别代表各个学生的总成绩.

输入样例:

3
70 80 90
59 59 59
100 100 100
1
2
3
4

输出样例:

300
240
177
1
2
3

代码：

n = int(input())
ls = []
for i in range(n):
    ls.append(sum(map(int, input().split())))
ls.sort(reverse=True)
for it in ls:
    print(it)
1
2
3
4
5
6
7

7-20 sdut- 矩阵转置(II)

从键盘输入一个m(2<=m<=6)*n(2<=n<=6)阶的矩阵，编程输出它的转置矩阵。

输入格式:
在第一行输入矩阵的行数m和列数n的值;

在第二行按照矩阵格式输入矩阵的数据，同行数据之间用空格隔开。

输出格式:
矩阵格式输出，同行数据之间用一个空格隔开。

输入样例:

3 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1
2
3
4

输出样例:

1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
1
2
3
4
5

代码：

n, m = map(int, input().split())
ls = []
for i in range(n):
    ls.append(list(map(int, input().split())))
ls_re = list(zip(*ls))
for i in range(m):
    print(*ls_re[i], sep=' ')
1
2
3
4
5
6
7

7-21 sdut-array2-1-矩阵转置（I）

从键盘输入矩阵的行数N，和一个N×N阶的矩阵，编程输出它的转置矩阵。

输入格式:
首行为矩阵的行数（列数）N；
然后是N行N列组成矩阵的数据。每行内数据之间用空格隔开。
输出格式:
矩阵格式输出，每行内非尾部的每个数据后跟一个空格，行尾数据后不加空格，为换行符。

输入样例:

4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1
2
3
4
5

输出样例:

1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
1
2
3
4

代码：

n=int(input())
ls = []
for i in range(n):
    ls.append(list(map(int, input().split())))
ls_re = list(zip(*ls))
for i in range(n):
    print(*ls_re[i], sep=' ')
1
2
3
4
5
6
7

7-22 sdut-矩阵输出

输入n个整数，输出由这些整数组成的n行矩阵。

输入格式:
第一行输入一个正整数N（N<=20），表示后面要输入的整数个数。

下面依次输入N个整数。

输出格式:
以输入的整数为基础，输出有规律的n行数据。

第1行原样输出获得的N个整数，从第2行开始，上一行最后一个数变成下一行的首个数值。

输入样例:

5
3 6 2 5 8
1
2

输出样例:

3 6 2 5 8
8 3 6 2 5
5 8 3 6 2
2 5 8 3 6
6 2 5 8 3
1
2
3
4
5

代码：

n = int(input())
ls = list(input().split()*2)
pos1, pos2 = n, len(ls)
for i in range(n):
    print(*ls[pos1:pos2], sep=' ')
    pos1 -= 1
    pos2 -= 1
1
2
3
4
5
6
7

7-23 sdut-对称矩阵的判定

输入矩阵的行数，再依次输入矩阵的每行元素，判断该矩阵是否为对称矩阵，若矩阵对称输出“yes”，不对称输出“no”。

输入格式:
输入有多组，每一组第一行输入一个正整数N（N<=20），表示矩阵的行数（若N=0，表示输入结束）。

下面依次输入N行数据。

输出格式:
若矩阵对称输出“yes"，不对称输出“no”。

输入样例:

3
6 3 12
3 18 8
12 8 7
3
6 9 12
3 5 8
12 6 3
0
1
2
3
4
5
6
7
8
9

输出样例:

yes
no
1
2

代码：

while True:
    n = int(input())
    if n == 0:
        break
    else:
        ls, flag = [], 1
        for i in range(0, n):
            ls.append(list(input().split()))
        for i in range(n):
            for j in range(n):
                if ls[i][j] != ls[j][i]:
                    flag = 0
        if flag == 0:
            print("no")
        else:
            print("yes")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7-24 sdut-array2-2-局部峰值

给定一个N行乘N列的2D数组，逐行扫描该值并打印出所有局部峰值，该值大于其左上、上、右上、左、右、左下、下、右下的值（如果有）。

N的范围是2到150。

输入格式:
多组输入。每组输入包含两部分：

第一行包含整数N，表示2D数组的大小。

后面的N行中的每一行包含N个非负整数，用空格分隔。

输出格式:
对于每组输入，输出所有局部峰值按行顺序排列，每个局部峰值后跟一个空格。

如果没有局部峰值，则输出“none”。

每组输出之后加换行符。

输入样例:

2 
5 1 
1 0 
2
5 2
2 3
3
5 5 5
0 5 0
5 5 5
3
1 2 5
2 3 2
4 2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出样例:

5 
5 
none
5 4 
1
2
3
4

代码：

while True:
    try:
        n, ls = int(input()), []
        ls.append([float('-inf')] * (n + 2))
        for i in range(n):
            row = list(map(int, input().split()))
            row.insert(0, float('-inf'))
            row.append(float('-inf'))
            ls.append(row)
        ls.append([float('-inf')] * (n + 2))
        flag = 0
        for i in range(1, n + 1):
            for j in range(1, n + 1):
                if ls[i][j] > max(ls[i - 1][j - 1], ls[i - 1][j], ls[i - 1][j + 1], ls[i][j - 1], ls[i][j + 1],
                                  ls[i + 1][j - 1], ls[i + 1][j], ls[i + 1][j + 1]):
                    print("%d " % ls[i][j], end='')
                    flag = 1
        if flag == 0:
            print("none")
        else:
            print()
    except EOFError:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

代码可能不是特别好，感谢大家耐心阅读
212丨acc丨2022.11.4