目录
身份z号基本信息
回文素数
反素数
哥德巴赫猜想
货币转换
角古猜想
计算几何形状的表面积与体积
自幂数
a除以b
二分法求函数的零点
身份z号基本信息
类型：字符串
描述
18位身份z号码第7~10位为出生年份(四位数)，第11~12位为出生月份，第13~14位代表出生日期，第17位代表性别，奇数为男，偶数为女。 用户输入一个合法的身份z号，请输出用户的出生年月日和性别。（不要求较验输入的合法性）
输入格式
输入一个合法的身份z号字符串
输出格式
类似以下格式输出：
出生：1995年11月11日 性别：女
示例 1
输入：
110111199511111101
输出：
出生：1995年11月11日
性别：女代码
num = input()
year = ""
month = ""
day = ""
gender = ""
i = 1
for j in num:
if i in [7,8,9,10]:
year = year + j
if i in [11,12]:
month = month + j
if i in [13, 14]:
day = day + j
if i in [17]:
if int(j) % 2 == 0:
gender = "女"
else:
gender = "男"
i = i + 1
print(f"出生：{year}年{month}月{day}日\n性别：{gender}")类型：函数
描述
回文素数是指一个数既是素数又是回文数。例如，131，既是素数又是回文数。 用户输入一个正整数 n , 请你在一行内输出从小到大排列的的前n个回文素数，数字后面用一个空格进行分隔。
输入格式
输入一个正整数
输出格式
符合要求的回文素数
示例
输入：10
输出：2 3 5 7 11 101 131 151 181 191 代码：
from math import*
def isprime(n):
for j in range(2,int(sqrt(n))+1):
if n%j==0:
return 0
return 1
def ishui(n):
n1=n[::-1]
if n1==n:
return 1
return 0
x=int(input())
i=0
n=2
while(i类型：函数
描述
反素数(逆向拼写的素数)是指一个将其逆向拼写后也是一个素数的非回文数。
例如：
13和31都是素数，且13和31都不是回文数，所以，13和31是反素数。
输入一个正整数 n , 请在同一行输出从小到大排列的的前n个反素数，每个数字后面加一个空格。
输入格式
输入一个正整数
输出格式
符合条件的反素数
示例
输入：
10
输出：
13 17 31 37 71 73 79 97 107 113 代码：
from math import *
def isprime(n):
for j in range(2, int(sqrt(n)) + 1):
if n % j == 0:
return 0
return 1
def ishui(n):
n1 = n[::-1]
if n1 == n:
return 0
return 1
def change(s):
## 转换为列表
s = str(s)
l = list(s)
## 列表翻转
l.reverse()
##将列表中的数字逐个输出，组合成字符串
s = ''
for i in range(len(l)):
s = s + l[i]
return int(s)
x = int(input())
i = 0
n = 10
while (i < x):
if (isprime(n) and isprime(change(n)) and ishui(str(n)) and ishui(str(change(n)))):
print(n, end=' ')
i += 1
n = n +1类型：函数
描述
数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。例如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。输入一个大于2的正整数，当输入为偶数时，在一行中按照格式“N = p + q”输出N的素数分解，其中p 、 q均为素数且p ≤ q。因为这样的分解可能不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。当输入为奇数时，输出'Data error!' 。
输入格式
输入一个大于2的正整数
输出格式
当输入为偶数时，按照格式“N = p + q”输出N的素数分解；当输入为奇数时，输出'Data error!' 。
示例
输入：36
输出：36 = 5 + 31代码：
def isPrime(n): #判断素数的函数
if n < 2:
return False #0和1不是素数
for i in range(2, n):
if n % i == 0:
return False
else:
return True
N = int(input()) #接收用户输入并转成整数
flag = False
if N % 2 == 0:
for i in range(N):
for j in range(N):
if isPrime(i) and isPrime(j) and i+j==N:
print(f"{N} = {i} + {N-i}")
flag = True
break
if flag:
break
else:
print('Data error!')
类型：字符串
描述
编写一个美元与人民币转换的程序，用户输入金额和汇率（合理的汇率是正数），输出转换为另一种货币表示的金额。
（美元用符号’$’表示，人民币用￥表示，￥可以在中文输入法下按shift+4获取）
输入格式
第一行输入一个以货币符号结尾的正数，数值作为金额，货币符号表明货币种类
第二行输入一个浮点数作为汇率
输出格式
输入符合要求时输出一个带货币符号的数值（保留2位小数）
输入不符合要求时输出Data error!
示例 1
输入：
58$
6.75
输出：
391.50￥
示例 2
输入：
100￥
6.85
输出：
14.60$
示例 3
输入：
58
6.75
输出：
Data error!
dollar = input()
rate = float(input())
if float(dollar[:-1])<= 0 or rate <0:
print('Data error!')
elif dollar[-1] in '$' and float(dollar[:-1])> 0 and rate>=0:
print('{0:.2f}￥'.format(float(dollar[:-1])*rate))
elif dollar[-1] in '￥' and float(dollar[:-1])> 0 and rate>=0:
print('{0:.2f}$'.format(float(dollar[:-1])/rate))
else:
print('Data error!')
用户输入自己的个人信息，格式如下：
0122923450321 王昊 法学1801 河北 2001年
数据分别表示：学号 姓名 专业班级 籍贯 出生年份，各数据间空格间隔
有些用户没有按照规则输入数据，输入自己出生年份的时候写成了类似‘1900年生’或‘出生于1985’或‘19岁生于2006年11月’的数据格式
请注意程序仍然需要正确读取该项数据，本题保证这些用户输入时一定只含有1个4位数字连续组成的年份数据。
请按照输出样式输出姓名，班级，出生年份呢
提示：
列表中的数据和字符串当中的字符一样，都具有有序的索引，且引用数据和切片方式一致。
str.isdigit()可以帮助判断字符串是否全部由数字字符组成，返回值为'True'或'False'
输入示例
0122923450321 王昊 法学1801 河北 2001年
输出示例 姓名：王昊 班级：法学1801 出生：2001年
示例
输入：
0122923450321 王昊 法学1801 河北 2001年
输出：
姓名：王昊
班级：法学1801
出生：2001年import re
n=input()
t=n.split(" ")#获取切片
print("姓名："+t[1])
print("班级："+t[2])
print("出生："+re.findall('\d+', t[4])[0]+"年")
类型：流程控制
描述
一个正整数，若为偶数，则把它除以2，若为大于 1 的奇数，则把它乘以3加1。经过如此有限次运算后，可以得到整数1。
求经过多少次运算可得到整数1。
输入格式
输入一个数字
输出格式
第一行依次输出从n开始每步的运算结果，每步的输出后跟一个空格
第二行输出总的运算次数
若输入数据不是正整数，输出’ERROR‘
示例
输入：
33
输出：
33 100 50 25 76 38 19 58 29 88 44 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
26代码：
n = eval(input())
y = 0
if int(n) - n == 0 and n >= 0:
if n % 2 == 0:
for i in range(1, int(n)):
print(int(n), end=" ")
if n % 2 != 0 and n != 1:
n = 3 * n + 1
y = y + 1
elif n == 1:
print("")
print(y)
break
else:
n /= 2
y = y + 1
else:
for i in range(1, int(3 * int(n) + 1)):
print(int(n), end=" ")
if n % 2 != 0 and n != 1:
n = 3 * n + 1
y = y + 1
elif n == 1:
print("")
print(y)
break
else:
n /= 2
y = y + 1
else:
print("ERROR")
类型：数值运算
描述
输入一个表示几何形状名称的字符串，再在一行内输入这种图形的数据，根据表示名称的字符串选择合适的公式计算几何形状的（表）面积和体积，若为二维图形，只计算面积，若为三维图形，计算其表面积与体积，结果严格保留2位小数。
模板程序给出了长方形和长方体的代码，参考这些代码，完成圆形、球、圆柱体、圆锥和正三棱柱这5种形状的计算程序。
(可将模板中的代码复制到本地，先注释掉需要补充代码的函数或在函数体中加pass语句后再运行，调试完成后再复制粘到代码框中)
示例 1
输入：
长方形
4 8
输出：
长方形的面积为32.00
示例 2
输入：
长方体
4 8 9
输出：
长方体的表面积为280.00, 体积为288.00
示例 3
输入：
圆形
88
输出：
圆形的面积为24328.49
示例 4
输入：
球
88
输出：
球的表面积为97313.97, 体积为2854543.24
示例5
输入：
圆柱体
88 88
输出：
圆柱体的表面积为97313.97, 体积为2140907.43
示例 6
输入：
圆锥
88 88
输出：
圆锥的表面积为58734.18, 体积为713635.81
示例 7
输入：
正三棱柱
88 88
输出：
正三棱柱的表面积为29938.50, 体积为295086.03 代码：
import math
def type_judge(geom_type):
"""接收一个字符串为参数，根据参数判断几何体类型
若输入为二维图形，计算其面积
若输入为三维图形，计算其面积与体积
根据类型调用不同的函数进行运算。
"""
if geom_type == '长方形':
length, width = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return square(length, width) # 调用函数计算长方形面积
elif geom_type == '长方体':
length, width, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cube(length, width, height) # 调用函数计算长方体表面积与体积
elif geom_type == '圆形':
radius = float(input()) # 输入转为浮点数
return circle(radius) # 调用函数计算圆面积
elif geom_type == '球':
radius = float(input()) # 输入转为浮点数
return sphere(radius) # 调用函数计算球表面积与体积
elif geom_type == '圆柱体':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cylinder(radius, height) # 调用函数计算圆柱体表面积与体积
elif geom_type == '圆锥':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cone(radius, height) # 调用函数计算圆锥表面积与体积
elif geom_type == '正三棱柱':
side, height = map(float, input().split())
return tri_prism(side, height)
else:
return f'未找到{geom_type}计算方法'
def square(length, width):
"""计算长方形的面积"""
area_of_square = length * width
return f'长方形的面积为{area_of_square:.2f}'
def cube(length, width, height):
"""计算长方体的表面积和体积"""
area_of_cube = length * width * 2 + width * height * 2 + length * height * 2
volume_of_cube = length * width * height
return f'长方体的表面积为{area_of_cube:.2f}, 体积为{volume_of_cube:.2f}'
def circle(radius):
"""接收圆的半径，返回圆形的面积，圆周率用math.pi"""
area_of_circle = math.pi * math.pow(radius, 2)
return f'圆形的面积为{area_of_circle:.2f}'
def sphere(radius):
"""接收球的半径，返回球的表面积和体积，圆周率用math.pi"""
area_of_sphere = 4 * math.pi * math.pow(radius, 2)
volume_of_sphere = math.pi * math.pow(radius, 3) * 4 / 3
return f'球的表面积为{area_of_sphere:.2f}, 体积为{volume_of_sphere:.2f}'
def cylinder(radius, height):
"""接收圆柱体的底面半径和高，返回圆柱体的表面积和体积，圆周率用math.pi"""
area_of_cylinder = 2 * math.pi * radius * (radius + height)
volume_of_cylinder = math.pi * radius * radius * height
return f'圆柱体的表面积为{area_of_cylinder:.2f}, 体积为{volume_of_cylinder:.2f}'
def cone(radius, height):
"""接收圆锥的底面半径和高，返回圆锥的表面积和体积，圆周率用math.pi"""
area_of_cone = math.pi * radius * \
(radius + math.sqrt(math.pow(radius, 2) + math.pow(height, 2)))
volume_of_cone = math.pi * math.pow(radius, 2) * height / 3
return f'圆锥的表面积为{area_of_cone:.2f}, 体积为{volume_of_cone:.2f}'
# 参考前面的方法自定义一个函数计算正三棱柱的表面积与体积，
# 函数名为tri_prism()
# 函数接受底边长和高两个参数side, height
area_of_tri_prism = math.sqrt(3) * math.pow(side, 2) / 2 + 3 * side * height
volume_of_tri_prism = math.sqrt(3) * math.pow(side, 2) * height / 4
return f'正三棱柱的表面积为{area_of_tri_prism:.2f}, 体积为{volume_of_tri_prism:.2f}'
if __name__ == '__main__':
type_of_geometry = input() # 接收用户输入的字符串
geometry = type_judge(type_of_geometry) # 调用判断图形类型的函数
print(geometry) 类型：字符串
描述
自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身,例如：13 + 53+ 3**3 = 153,编程寻找并输出 n 位的自幂数，n 由用户输入，每行输出一个数字。 n为1时，自幂数称为独身数。显然，0,1,2,3，4,5,6,7,8,9都是自幂数。 n为2时，没有自幂数。 n为3时，自幂数称为水仙花数，有4个 n为4时，自幂数称为四叶玫瑰数，共有3个 n为5时，自幂数称为五角星数，共有3个 n为6时，自幂数称为六合数， 只有1个 n为7时，自幂数称为北斗七星数， 共有4个 n为8时，自幂数称为八仙数， 共有3个 n为9时，自幂数称为九九重阳数，共有4个 n为10时，自幂数称为十全十美数，只有1个
输入格式
输入一个大于或等于 3 且小于 7 的正整数 n
输出格式
按从小到大的顺序输出 n 位的自幂数，每行一个数
示例 1
输入：4
输出：
1634
8208
9474代码：
n = eval(input()) #n为正整数位数
output = []
for d in range(pow(10,n-1), pow(10,n)):
s = 0
digits = []
for x in range(n):
digit = d//pow(10,x)%10
digits.append(digit)
for digit in digits:
s += pow(digit, n)
if s == d:
output.append(d)
for i in output:
print(i)
类型：简单分支
描述
输出实数a除以b的结果，计算结果四舍五入，保留2位小数。
输入格式
输入包括两行, 每行一个实数, b不能等于0
输出格式
当用户输入b为0时输出"除零错误"
其他情况下输出一个保留2位小数的实数
示例 1
输入：
5
0
输出：
除零错误
示例 2
输入：
5.0
3
输出：1.67代码
# 计算a除以b，结果保留2位小数
a = eval(input())
b = eval(input())
if b != 0:
print(round(a / b, 2))
else:
print('除零错误')类型：流程控制
描述
现有方程：f(x) = x5-15x4+85x3-225x2+274x-121, 已知f(x)在[1.5,2.4]区间单调下降，且在该区间f(x)==0有且只有一个根，用二分法求解该根。
输入格式
输入一个正整数n，当f(x)值小于10-n时认为函数值为0
输出格式
输出方程在[1.5,2.4]区间的根，精确到小数点后第6位
示例
输入：9
输出：1.849016def fun(x):
return x**5-15*x**4+85*x**3-225*x**2+274*x-121
n=int(input())
if fun(1.5)<0:
a,b=1.5,2.4
else:
a,b=2.4,1.5
while True:
mid=(a+b)/2
if abs(fun(mid))<10**(-n):
break
elif fun(mid)<0:
a=mid
else:
b=mid
print("{:.6f}".format(mid))
中国古代数学问题集锦
类型：流程控制
描述
中国古代《周髀算经》、《九章算术》和《孙子算经》等数学著作中记载了很多有趣的数学问题，其中很多题目非常适用于计算机求解，下面给出几个有趣的问题。
- 鸡兔同笼
大约在1500年前，《孙子算经》中就记载了这个有趣的问题。书中是这样叙述的：今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？这四句话的意思是：有若干只鸡兔同在一个笼子里，从上面数，有35个头，从下面数，有94只脚。问笼中各有多少只鸡和兔？
请编一个程序，用户在同一行内输入两个整数h和f（两数之间用空格隔开），代表头和脚的数量，编程计算笼中各有多少只鸡和兔。假设鸡和兔都正常，无残疾。若有解则按照“有c只鸡，r只兔”的格式输出解；若无解则输出“Data Error!”
2.物不知数
“物不知数”出自《孙子算经》。题目为“今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二,问物几何？”意思是说有一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；7个7个数也会多出2个。
请编写一个程序，读入一个正整数n，计算并输出不超过输入数字n且满足条件的物品个数（有多个解时，按从小到大的顺序每个解占一行）。如无解则不输出。
3.二鼠打洞
《九章算术》的“盈不足篇”里有一个很有意思的老鼠打洞问题。原文这么说的：今有垣厚十尺，两鼠对穿。大鼠日一尺，小鼠亦一尺。大鼠日自倍，小鼠日自半。问：何日相逢？各穿几何？这道题的意思就是说，有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打一尺，小老鼠也是一尺。大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。问它们几天可以相逢，相逢时各打了多少。（要求使用循环完成，不允许使用幂运算）
请编写程序，读入1个正整数，代表墙的厚度，单位为尺；计算并输出两鼠相遇所需天数以及相遇时各自打墙厚度。输出分两行，第一行输出1个整数，表示相遇时所需的天数；第二行输出用空格分隔的2个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1位数字。
4.李白买酒
大诗李白，一生好饮酒。一天，他提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
5. 宝塔上的琉璃灯
有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有765盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出分八行（1~8行），分别说明相应层上琉璃灯的数目，具体输出内容和格式见下面的说明。
输入输出格式说明
第一行输入一个字符串，若为"鸡兔同笼"、"物不知数"、"二鼠打洞"、"李白买酒"、"宝塔上的琉璃灯"五种之一，则调用相应程序处理中国古代数学问题；若不是，则直接打印'输入错误'并结束程序。
（1）当第一行输入“鸡兔同笼”时，第二行输入以空格分隔的两个整数h和f，h代表鸡兔的总头数，f代表鸡兔的总脚数。
若有解则按照“有c只鸡，r只兔”的格式输出解；若无解则输出“Data Error!”
（2）当第一行输入“物不知数”时，第二行输入一个正整数n（题目保证是正整数）。
计算并输出不超过输入数字n且满足条件的物品个数（有多个解时，按照从小到大的顺序、每个解占一行）。如无解则不输出。
（3）当第一行输入“二鼠打洞”时，第二行输入一个正整数w（题目保证是正整数）代表墙的厚度，单位为尺。
输出分两行，第一行输出1个整数，表示相遇时所需的天数；第二行输出用空格分隔的2个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，要求保留小数点后1位数字。
（4）当第一行输入“李白买酒”时，直接输出李白酒壶中原有酒几斗？
（5）当第一行输入“宝塔上的琉璃灯”时，输出共八行（1~8行），每一行都是一个字符串，第i行输出“第i层上有p只琉璃灯”。
示例 1
输入:
鸡兔同笼
35 94
输出:
有23只鸡，12只兔
示例2
输入:
鸡兔同笼
35 140
输出:
有0只鸡，35只兔
示例3
输入:
鸡兔同笼
100 5
输出:
Data Error!
示例4
输入:
物不知数
200
输出:
23
128
示例5
输入:
二鼠打洞
10
输出:
4
1.8 8.2
示例6
输入:
割圆法求圆周率
输出:
输入错误# ------------ ------- -------- ----------- -----------
# @File : 4.4.1 中国古代数学问题实验模板.py
# @Contact : vasp@qq.com
# @Copyright : 2018-2025, Wuhan University of Technology
# @Modify Time: 2021/4/26 11:53
# @Author : 赵广辉
# @Version : 1.0
# @License : 仅限用于Python程序设计基础实践教程(赵广辉,高等教育出版社)配套实验
# ------------ ------- -------- ----------- -----------
def type_judge(question):
"""接收一个字符串为参数，根据参数调用不同函数执行不同代码。
这种写法不规范，但把输入、输出都放在一个函数中，方便管理。
"""
if question == '鸡兔同笼':
chicken_rabbit() # 用户输入为'鸡兔同笼'调用此函数
elif question == '物不知数':
amount_of_goods() # 用户输入为'物不知数'调用此函数
elif question == '二鼠打洞':
two_mice() # 用户输入为'二鼠打洞'调用此函数
elif question == '李白买酒':
libai_buy_wine() # 用户输入为'李白买酒'调用此函数
elif question == '宝塔上的琉璃灯':
lamp_on_pagoda() # 用户输入为'宝塔上的琉璃灯'调用此函数
else:
print('输入错误')
def chicken_rabbit():
"""
在同一行内输入用空格分隔的两个整数，代表头和脚的数量，计算并输出笼中各有多少只鸡和兔，
如无解则输出“Data Error!”，函数无返回值。
输入：35 94
输出：有23只鸡，12只兔
输入：100 5
输出：Data Error!
"""
# =======================================================
a, b = input().split()
a = int(a)
b = int(b)
if a < 0 or b < 0:
print("Data Error!")
return
rabbits = b/2 - a #兔子
chi = a - rabbits
if chi - int(chi) != 0 or chi < 0 or rabbits < 0:
print("Data Error!")
return
print(f"有{int(chi)}只鸡，{int(rabbits)}只兔")
# =======================================================
def amount_of_goods():
"""一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；
7个7个数也会多出2个。输入一个正整数，从小到大依次输出所有不超过输入数字
且满足条件的物品数量，有多个答案时每行输出一个。
例如输入：200
输出：
23
128
"""
# =======================================================
n = int(input())
m = 1
flag = 1
while m <= n:
if m % 3 == 2 and m % 5 == 3 and m % 7 == 2:
print(m)
flag = 0
m += 1
if flag:
print('No solution!')
# =======================================================
def two_mice():
"""有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打洞一尺，小老鼠也是打洞一尺。
大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。计算并输出它们几天可以相逢，
相逢时各打了多少尺。
输入格式：输入1 个整数，代表墙的厚度，单位为尺
输出格式：
第一行输出1 个整数，表示相遇时所需的天数
第二行输出2 个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1 位数字。
"""
# =======================================================
n=int(input())
# 每日打洞量，所需天数
big,small,day,time=1,1,0,1
# 各自总共打洞量
distance_of_big,distance_of_small=0,0
# 洞未打完 循环
while n>0:
# 第一天打完的情况单独考虑
if n-big-small<0:
time=n/(big+small)
# 剩余洞长
n=n-big-small
distance_of_small=distance_of_small+small*time
distance_of_big=distance_of_big+big*time
big*=2
small*=0.5
day=day+1
print(day)
print(round(distance_of_small,1),round(distance_of_big,1))
# =======================================================
def libai_buy_wine():
"""大诗人李白，提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，
遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
"""
print(0.96875)
# =======================================================
def lamp_on_pagoda():
"""有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，
已知共有765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。
输出为8行，从上往下数字依次增大。
"""
# =======================================================
a = 3
for i in range(8):
print(f"第{i + 1}层上有{a}只琉璃灯")
a = a *2
# =======================================================
if __name__ == '__main__':
choice = input() # 接收用户输入的字符串
type_judge(choice) # 调用判断输入的函数决定执行哪个函数
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）