第一部分 语法基础
Demo01 摄氏温度转化为华氏温度
题目描述
输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出
转换的公式为如下：
f
a
h
r
e
n
h
e
i
t
=
(
9
/
5
)
∗
c
e
l
s
i
u
s
+
32
fahrenheit=(9/5)*celsius+32
fahrenheit=(9/5)∗celsius+32
输入输出描述
输入一个值表示摄氏温度celsius
输出华氏温度fahrenheit ，结果保留一位小数点
示例
输入：
43
输出：
109.4
celsius = float(input("输入："))
fahrenheit = (9/5)*celsius+32
print("输出："+str(fahrenheit))
Demo02 计算圆柱体的体积
题目描述
输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。
a
r
e
a
=
r
a
d
i
u
s
∗
r
a
d
i
u
s
∗
π
area=radius*radius*π
area=radius∗radius∗π
v o l u m e = a r e a ∗ l e n g t h volume=area*length volume=area∗length
输入输出描述
分别输入圆柱的半径radius和高度length，两个数据之间用空格分隔
输出两行，第一行为圆柱底面积area，第二行为圆柱体积volume，结果保留两位小数点
示例
输入：
5.5 12
输出：
95.03
1140.41
import math
radius,length= input("输入圆柱的半径，高度：").split()
radius= float(radius)
length= float(length)
area= math.pi * radius**2
volume = area * length
print("圆柱的底面积：",'%.2f' %area)
print("圆柱的体积：",'%.2f' %volume)
Demo03 将英尺数转换为米数
题目描述
输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米
输入输出描述
输入一个数据表示英尺数
输出转换后的米数，结果保留四位小数点
示例
输入：
16.5
输出：
5.0325
foot =float(input("输入英尺数："))
metter=foot*0.305
print("米数：",'%.4f' %metter)
Demo04 计算小费
题目描述
读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元
输入输出描述
分别输入小计和酬金率，两个数据用之间用空格分隔
输出两行，第一行为小费，第二行为合计金额，结果保留两位小数
示例
输入：
15.69 15
输出：
2.35
18.04
a,b= input("分别输入小计和酬金率:").split()
a= float(a)
b= float(b)
c= float(a*b)
d= float(a+c)
print("小费：",'%.2f' %c)
print("合计：",'%.2f' %d)
Demo05 对一个整数中的各位数字求和
题目描述
读取一个0到1000之间的整数，并计算它各位数字之和
输入输出描述
输入一个[0,1000]之间的整数
输出该数字的各位数字之和
示例1
输入：
999
输出：
27
解释：
999各位数之和为9 + 9 + 9 = 27
示例2
输入：
12
输出：
3
num= int(input("请输入一个整数："))
sum = 0
if num == 0:
print("sum=", sum)
while num!= 0:
sum = sum+num%10
num= num//10
print("sum=", sum)
Demo06 计算年数和天数
题目描述
输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
输入输出描述
输入一个分钟数
输出两行，第一行为年数，第二行为天数
示例
输入：
1000000000
输出：
1902
214
minute = int(input("请输入分钟："))
year= minute //(24*60*365)
day= minute%(24*60*365)//(24*60)
print("年数：",year)
print("天数：",day)
Demo07 计算能量
题目描述
水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：
Q
=
M
∗
(
f
i
n
a
l
T
e
m
p
e
r
a
t
u
r
e
−
i
n
i
t
i
a
l
T
e
m
p
e
r
a
t
u
r
e
)
∗
4184
Q = M * (finalTemperature - initialTemperature) * 4184
Q=M∗(finalTemperature−initialTemperature)∗4184
这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计
输入输出描述
输入三行数据，第一行输入水量，第二行输入初始温度，第三行输入最终温度
输出所需的能量值，结果保留一位小数
示例
输入：
55.5
3.5
10.5
输出：
1625484.0
M =float(input("请输入水量(kg):"))
finaltemperature=float(input("请输入初始温度:"))
initialtemperature=float(input("请输入最终温度:"))
Q = M*(finaltemperature - initialtemperature)*4184
print("Q=",'%.1f'%Q)
Demo08 分割数字
题目描述
输入一个四位整数，并以反向顺序显示
输入输出描述
输入一个四位整数
输出四行，第一行为个位，第二行为十位，第三行为百位，第四行为千位
示例
输入：
5213
输出：
3
1
2
5
num=int(input("请输入一个整数："))
while num==0:
print(num)
while num!=0:
a=num%10
print(a)
num=num//10
Demo09 计算三角形的面积
题目描述
输入三角形的三个顶点坐标，并计算其面积，计算公式如下
s
=
(
s
i
d
e
1
+
s
i
d
e
2
+
s
i
d
e
3
)
/
2
a
r
e
a
=
s
(
s
−
s
i
d
e
1
)
(
s
−
s
i
d
e
2
)
(
s
−
s
i
d
e
3
)
s=(side1+side2+side3)/2 \\ area = \sqrt{s(s-side1)(s-side2)(s-side3)}
s=(side1+side2+side3)/2area=s(s−side1)(s−side2)(s−side3)
输入输出描述
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三角形的面积，结果保留一位小数
示例
输入：
1.5 -3.4 4.6 5 9.5 -3.4
输出：
33.6
import math
x1,y1,x2,y2,x3,y3 =input("输入三角形三个顶点的坐标：").split()
x1=float(x1)
y1=float(y1)
x2=float(x2)
y2=float(y2)
x3=float(x3)
y3=float(y3)
side1 =math.sqrt((x2-x1)**2+(y2-y1)**2)
side2 =math.sqrt((x2-x3)**2+(y2-y3)**2)
side3 =math.sqrt((x3-x1)**2+(y3-y1)**2)
s=(side1+side2+side3)/2
area=math.sqrt(s*(s-side1)*(s-side2)*(s-side3))
print("面积为：", '%.1f'%area)
Demo10 显示当前时间
题目描述
输入你所在的时区，并输出当前的时间
输入输出描述
输入时区，如东八区为8，西五区为-5
输出二十四小时制的时间，格式为 时:分:秒
示例
输入：
8
输出：
21:43:12
Demo11 计算三角形的三个角
题目描述
输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
A
=
a
c
o
s
(
(
a
∗
a
−
b
∗
b
−
c
∗
c
)
/
(
−
2
∗
b
∗
c
)
)
B
=
a
c
o
s
(
(
b
∗
b
−
a
∗
a
−
c
∗
c
)
/
(
−
2
∗
a
∗
c
)
)
C
=
a
c
o
s
(
(
c
∗
c
−
b
∗
b
−
a
∗
a
)
/
(
−
2
∗
a
∗
b
)
)
A=acos((a*a-b*b-c*c)/(-2*b*c)) \\ B=acos((b*b-a*a-c*c)/(-2*a*c)) \\ C=acos((c*c-b*b-a*a)/(-2*a*b)) \\
A=acos((a∗a−b∗b−c∗c)/(−2∗b∗c))B=acos((b∗b−a∗a−c∗c)/(−2∗a∗c))C=acos((c∗c−b∗b−a∗a)/(−2∗a∗b))
其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角
输入输出描述
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三行，分别为A、B、C三个角的度数，结果保留两位小数
示例
输入：
1 1 6.5 1 6.5 2.5
输出：
15.26
90.00
74.74
import math
x1,y1,x2,y2,x3,y3 =input("输入三角形三个顶点的坐标：").split()
x1=float(x1)
y1=float(y1)
x2=float(x2)
y2=float(y2)
x3=float(x3)
y3=float(y3)
a = math.sqrt((x2-x1)**2+(y2-y1)**2)
b = math.sqrt((x2-x3)**2+(y2-y3)**2)
c = math.sqrt((x3-x1)**2+(y3-y1)**2)
A = math.acos((a**2 - b**2 - c**2) / (-2 * b * c))
B = math.acos((b**2 - a**2 - c**2) / (-2 * a * c))
C = math.acos((c**2 - b**2 - a**2) / (-2 * a * b))
print('%.2f' %A)
print('%.2f' %B)
print('%.2f' %C)
Demo12 最小数量的硬币
题目描述
假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
输入输出描述
输入总金额
输出每种硬币的个数
示例
输入：
11.56
输出：
11个一元硬币
2个两角五分硬币
0个一角硬币
1个五分硬币
1个一分硬币
def coin_min(x):
a = x // 1
b = (x % 1) // 0.25
c = (x % 1 % 0.25) // 0.1
d = (x % 1 % 0.25 % 0.1) // 0.05
e = (x % 1 % 0.25 % 0.1 % 0.05) // 0.01
print(f"{a}个一元硬币")
print(f"{b}个两角伍分硬币")
print(f"{c}个一角硬币")
print(f"{d}个五分硬币")
print(f"{e}个一份硬币")
money = float(input("请输入总金额："))
coin_min(money)
Demo13 正多边形的面积
题目描述
正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：
a
r
e
a
=
n
∗
s
2
4
∗
t
a
n
(
π
n
)
area = \frac{n*s^2}{4*tan(\frac{π}{n})}
area=4∗tan(nπ)n∗s2
输入输出描述
输入两个数据分别表示边的个数n和边的长度s，数据之间用空格分隔
输出边长为s的正n多边形的面积，结果保留两位小数
示例
输入：
5 6.5
输出：
72.69
import math
def area(a,b):
a = float(a)
b = float(b)
S = (a * b**2) / (4 * math.tan(math.pi / a))
S = round(S , 2)
print(f"边长为{b}的正{a}边形的面积为：{S}")
n, s = input("请输入边的个数和边的长度：").split()
area(n, s)
Demo14 计算身体质量指数
题目描述
BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出
BMI指数解读如下：
| BMI | 解释 |
|---|---|
| BMI ＜ 18.5 | 超轻 |
| 18.5 ≤ BMI ＜ 25.0 | 标准 |
| 25.0 ≤ BMI ＜ 30.0 | 超重 |
| 30.0 ≤ BMI | 肥胖 |
输入输出描述
输入体重和身高，数据之间用空格分隔
输出BMI指数结果
示例
输入：
60 1.8
输出：
标准
def BMI(a, b):
a = float(a)
b = float(b)
BMI = b / a**2
if BMI < 18.5:
print("超轻")
elif 18.5 <= BMI < 25.0:
print("标准")
elif 25.0 <= BMI < 30.0:
print("超重")
else:
print("肥胖")
height , weight = input("请输入身高体重：").split()
BMI(height, weight)
Demo15 判定闰年
题目描述
一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年
输入输出描述
输入一个年份
输出Yes表示该年份为闰年，No则表示不是闰年
示例1
输入：
2008
输出：
Yes
示例2
输入：
2002
输出：
No
def leap(year):
if year % 4 == 0 and year % 100 == 0:
print("Yes")
elif year % 400 == 0:
print("Yes")
else:
print("No")
year = int(input("请输入年份："))
leap(year)
Demo16 中彩票
题目描述
随机产生一个两位数数字，然后用户输入一个两位数数字，并根据以下规则判定用户赢得的奖金是多少
（1）输入的数字和随机产生的数字完全相同（包括顺序），奖金为10000元
（2）输入的数字和随机产生的数字相同（不包括顺序），奖金为3000元
（3）输入的数字和随机产生的数字有一位数相同，奖金为1000美元
（4）输入的数字和随机产生的数字都不相同，没有奖金，0元
输入输出描述
输入一个两位数
输出两行，第一行输出那个随机产生的两位数，第二行输出用户的奖金
示例1
输入：
12
输出：
12
10000
示例2
输入：
12
输出：
21
3000
示例3
输入：
12
输出：
23
1000
示例4
输入：
12
输出：
45
0
import random
def lottery(num):
num_random = random.randint(10,99)
print(num_random)
a = num // 10
b = num % 10
c = num_random // 10
d = num_random % 10
if num == num_random:
print(10000)
elif a + b == c + d:
print(3000)
elif a == c or a == d or b == c or b == d:
print(1000)
elif a != c and a != d and b != c and b != d:
print(0)
num = int(input("请输入一个两位数："))
lottery(num)
Demo17 解一元二次方程
题目描述
一元二次方程
a
x
2
+
b
x
+
c
=
0
(
a
!
=
0
)
ax^2+bx+c=0 (a != 0)
ax2+bx+c=0(a!=0)的解可以使用下面的公式计算
r
1
=
−
b
+
b
2
−
4
a
c
2
a
,
r
2
=
−
b
−
b
2
−
4
a
c
2
a
r_1=\frac{-b+\sqrt{b^2-4ac}}{2a},r_2=\frac{-b-\sqrt{b^2-4ac}}{2a}
r1=2a−b+b2−4ac,r2=2a−b−b2−4ac
其中
b
2
−
4
a
c
b^2-4ac
b2−4ac称为判别式，如果它为正，则方程有两个实数解；为零，方程只有一个实数解；为负，没有实数解
输入输出描述
输入a、b、c三个数据，数据之间用空格分隔
两个解每行输出一个；一个解单行输出；无解则单行输出无实数解，保留两位小数
示例1
输入：
1.0 3 1
输出：
-0.38
-2.62
示例2
输入：
1 2.0 1
输出：
-1.00
-2.62
示例3
输入：
1 2 3
输出：
无实数解
import math
def test(a, b, c):
disc = b**2 - 4 * a * c
if disc < 0:
print("无实数解")
elif disc == 0:
r = (-b + math.sqrt(disc)) / 2 * a
r = round(r, 2)
print(r)
else :
r1 = (-b + math.sqrt(disc)) / 2 * a
r2 = (-b - math.sqrt(disc)) / 2 * a
r1 = round(r1, 2)
r2 = round(r2, 2)
print(r1)
print(r2)
a, b, c, = input("输入a,b,c三个数据：").split()
a = float(a)
b = float(b)
c = float(c)
test(a, b, c)
Demo18 解2×2线程方程
题目描述
如有一个2×2的线程方程组：
a
x
+
b
y
=
e
c
x
+
d
y
=
f
ax+by=e \\ cx+dy=f
ax+by=ecx+dy=f
你可以使用克莱姆法则解该线性方程：
x
=
e
d
−
b
f
a
d
−
b
c
,
y
=
a
f
−
e
c
a
d
−
b
c
x=\frac{ed-bf}{ad-bc},y=\frac{af-ec}{ad-bc}
x=ad−bced−bf,y=ad−bcaf−ec
其中
a
d
−
b
c
ad-bc
ad−bc为判别式，如果为零则输出无解
输入输出描述
输入a、b、c、d、e、f六个数据，数据之间用空格分隔
输出两行，第一行x的解，第二行y的解，保留一位小数
示例1
输入：
9.0 4.0 3.0 -5.0 -6.0 -21.0
输出：
-2.0
3.0
示例2
输入：
1.0 2.0 2.0 4.0 4.0 5.0
输出：
无解
def test(a, b, c, d, e, f):
a = float(a)
b = float(b)
c = float(c)
d = float(d)
e = float(e)
f = float(f)
if a * d - b * c == 0:
print("无解")
else:
x = (e * d - b * f) / (a * d - b * c)
y = (a * f - e * c) / (a * d - b * c)
x = round(x, 1)
y = round(y, 1)
print(x)
print(y)
a, b, c, d, e, f = input("请输入六个数据：").split()
test(a, b, c, d, e, f)
Demo19 未来是周几
题目描述
输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，…，星期六是6）
并输入今天之后到未来某天的天数，然后输出该天是星期几
输入输出描述
输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔
输出未来某天是星期几
示例1
输入：
1 3
输出：
星期四
示例2
输入：
0 31
输出：
星期三
def date(a, b):
a = int(a)
b = int(b)
c = (a + b) % 7
if c <= 6:
if c == 0:
print("星期天")
elif c == 1:
print("星期一")
elif c == 2:
print("星期二")
elif c == 3:
print("星期三")
elif c == 4:
print("星期四")
elif c == 5:
print("星期五")
else:
print("星期六")
else:
print("错误")
a, b = input("输入今日星期几的数字和未来某天的天数").split()
date(a, b)
Demo20 本年中的第几天
题目描述
给定某年、某月、某日的一个日期，计算该日是今年中的第几天
输入输出描述
输入三个数据分别表示年、月、日，数据之间用空格分隔
输出该日是今年中的第几天
示例1
输入：
2023 1 28
输出：
28
示例2
输入：
2023 3 2
输出：
61
def day_of_year(year, month, day):
month_day = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
month_day[1] = 29
if month == 1:
total_day = day
else:
sum_day = 0
i = 1
for i in range (month - 1):
sum_day += month_day[i]
total_day = sum_day + day
return total_day
year, month, day = input("请输入年，月，日:").split()
print(day_of_year(int(year), int(month), int(day)))
Demo21 剪刀石头布I
题目描述
计算机随机产生一个数字0、1和2分别表示剪刀、石头和布
用户输入数字0、1或2，输出用户赢、计算机赢或平局
输入输出描述
输入数字0、1或2
输出有三行，第一行输出计算机出的啥，第二行输出用户出的啥，第三行输出结果
示例1
输入：
0
输出：
计算机出的 石头
用户出的 剪刀
计算机赢
示例2
输入：
1
输出：
计算机出的 剪刀
用户出的 石头
用户赢
示例3
输入：
2
输出：
计算机出的 布
用户出的 布
平局
import random
def game(a):
b = random.randint(0,2)
if a == 0:
if b == 0:
print("计算机出的剪刀")
print("用户出的剪刀")
print("平局")
elif b == 1:
print("计算机出的石头")
print("用户出的剪刀")
print("计算机赢")
else:
print("计算机出的布")
print("用户出的剪刀")
print("用户赢")
elif a == 1:
if b == 0:
print("计算机出的剪刀")
print("用户出的石头")
print("用户赢")
elif b == 1:
print("计算机出的石头")
print("用户出的石头")
print("平局")
else:
print("计算机出的布")
print("用户出的石头")
print("计算机赢")
elif a == 2:
if b == 0:
print("计算机出的剪刀")
print("用户出的布")
print("计算机赢")
elif b == 1:
print("计算机出的石头")
print("用户出的布")
print("用户赢")
else:
print("计算机出的布")
print("用户出的布")
print("平局")
else:
print("输入错误！！")
user_choice = int(input("请输入数字:"))
game(user_choice)
Demo22 三角形的周长
题目描述
输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法
如果任意两边之和大于第三边则输入都是合法的
输入输出描述
输入三个数据表示三边，数据之间用空格分隔
输出三角形的周长，如果非法则输出非法
示例1
输入：
1 1 1
输出：
3
示例2
输入：
1 3 1
输出：
非法
def C(a, b, c):
a, b, c = [float(x) for x in [a, b, c]]
if a + b > c or a + c > b or b + c >a:
count = a + b + c
print(count)
else:
print("非法")
a, b, c = input("请输入三角形三遍的长度：").split()
C(a, b, c)
Demo23 一周的星期几
题目描述
泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：
h
=
(
q
+
⌊
26
(
m
+
1
)
10
⌋
+
k
+
⌊
k
4
⌋
+
⌊
j
4
⌋
+
5
j
)
%
7
h=(q+\lfloor\frac{26(m+1)}{10}\rfloor+k+\lfloor\frac{k}{4}\rfloor+\lfloor\frac{j}{4}\rfloor+5j) \% 7
h=(q+⌊1026(m+1)⌋+k+⌊4k⌋+⌊4j⌋+5j)%7
（1）
h
h
h是指一周的星期几（0表示星期六、1表示星期天、…、6表示星期五）
（2） q q q是一个月的哪一天
（3） m m m是月份（3表示三月、4表示四月、…、12表示十二月），其中一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年
（4） j j j是世纪数，即 ⌊ y e a r 100 ⌋ \lfloor\frac{year}{100}\rfloor ⌊100year⌋
（5） k k k是一个世纪的某一年，即 y e a r % 100 year \% 100 year%100
（6） ⌊ ⌋ \lfloor\rfloor ⌊⌋为向下取整符号
输入输出描述
输入年、月、日三个数据，数据之间用空格分隔
输出该日是周几
示例1
输入：
2013 1 25
输出：
星期五
示例2
输入：
2012 5 12
输出：
星期六
def week_day(year, m, q):
year, m, q = [int(x) for x in [year, m, q]]
if m < 3:
m += 12
year -= 1
j = (year) // 100
k = (year) % 100
h = (q + (26 * (m + 1) // 10) + k + (k // 4) + (j // 4) + 5 * j) % 7
day = ["星期六", "星期天", "星期一", "星期二", "星期三", "星期四", "星期五"]
return day[h]
year, month, day = input("请输入年 、月、日：").split()
print(week_day(year, month, day))
Demo24 直线的交点
题目描述
直线A上的两个点是 ( x 1 , y 1 ) (x1,y1) (x1,y1)和 ( x 2 , y 2 ) (x2,y2) (x2,y2)，直线B上的两个点是 ( x 3 , y 3 ) (x3,y3) (x3,y3)和 ( x 4 , y 4 ) (x4,y4) (x4,y4)
如果两条直线有交点，可以通过解下面的线性等式找出：
(
y
1
−
y
2
)
x
−
(
x
1
−
x
2
)
y
=
(
y
1
−
y
2
)
x
1
−
(
x
1
−
x
2
)
y
1
(
y
3
−
y
4
)
x
−
(
x
3
−
x
4
)
y
=
(
y
3
−
y
4
)
x
3
−
(
x
3
−
x
4
)
y
3
(y_1-y_2)x-(x_1-x_2)y=(y_1-y_2)x_1-(x_1-x_2)y_1 \\ (y_3-y_4)x-(x_3-x_4)y=(y_3-y_4)x_3-(x_3-x_4)y_3
(y1−y2)x−(x1−x2)y=(y1−y2)x1−(x1−x2)y1(y3−y4)x−(x3−x4)y=(y3−y4)x3−(x3−x4)y3
如果没有解，则表示两条直线平行
输入输出描述
输入八个数据，分别为x1 y1 x2 y2 x3 y3 x4 y4，数据之间用空格分隔
如有交点则输出交点的坐标x y，否则输出两条直线平行
示例1
输入：
2 2 5 -1 4 2 -1 -2
输出：
2.89 1.11
示例2
输入：
2 2 7 6 4 2 -1 -2
输出：
两条直线平行
def line(x1, y1, x2, y2, x3, y3, x4, y4):
x1, y1, x2, y2, x3, y3, x4, y4 = [float(x) for x in [x1, y1, x2, y2, x3, y3, x4, y4]]
a = y1-y2
b = -(x1-x2)
e = (y1-y2)*x1 - (x1-x2)*y1
c = y3-y4
d = -(x3-x4)
f = (y3-y4)*x3 - (x3-x4)*y3
if a*d - b*c == 0:
print("两条直线平行")
else:
x = (e*d - b*f) / (a*d - b*c)
y = (a*f - e*c) / (a*d - b*c)
print("%0.2f"%x, "%0.2f"%y)
x1, y1, x2, y2, x3, y3, x4, y4 = input("请输入八个数据：").split()
line(x1, y1, x2, y2, x3, y3, x4, y4)
Demo25 回文数
题目描述
输入一个三位整数，然后判断其是否为一个回文数
如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数
输入输出描述
输入一个数字
输出Yes表示是回文数，否则输出No
示例1
输入：
121
输出：
Yes
示例2
输入：
123
输出：
No
def palindrome1(a):
a = int(a)
b = (a % 10)*100 +(a // 10 % 10)*10 + (a // 100)
if a == b:
print("Yes")
else:
print("No")
def palindrome2(b):
c = b[::-1]
if b == c:
print("Yes")
else:
print("No")
x = input("请输入一个三位数：")
palindrome1(x)
palindrome2(x)
Demo26 两个矩形
题目描述
判断两个矩形之间的关系：包含，重叠，相离
输入输出描述
输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
输出两者的关系
示例1
输入：
2.5 4 2.5 43
1.5 5 0.5 3
输出：
包含
示例2
输入：
1 2 3 5.5
3 4 4.5 5
输出：
重叠
示例3
输入：
1 2 3 3
40 45 3 2
输出：
相离
第二部分 循环语句
Demo27 打印数字I
题目描述
利用循环，寻找规律，打印如下数字模式：
模式A
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
模式B
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
模式C
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
模式D
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
def test1(n):
i = 1
for i in range(1, n+1):
j = 1
for j in range(1, i+1):
print(j, end=" ")
print("\n")
def test2(n):
i = 1
for i in range(n+1, 1, -1):
j = 1
for j in range(1, i):
print(j, end=" ")
print("\n")
def test3(n):
i = 1
for i in range(1, n+1):
j = 1
for j in range(1, n - i + 1):
print(" ", end=" ")
for j in range(i, 0, -1):
print(j, end=" ")
print("\n")
def test4(n):
i = 1
for i in range(n , 0, -1):
j = 1
for j in range(n-i):
print(" ", end=" ")
for j in range(1, i+1):
print(j, end=" ")
print("\n")
x = int(input("输入要打印的行数："))
test1(x)
test2(x)
test3(x)
test4(x)
Demo28 打印数字II
题目描述
利用循环，寻找规律，打印如下数字模式：
1
2 1 2
3 2 1 2 3
4 3 2 1 2 3 4
5 4 3 2 1 2 3 4 5
6 5 4 3 2 1 2 3 4 5 6
7 6 5 4 3 2 1 2 3 4 5 6 7
def print_nums(n):
i = 1
for i in range(1, n+1):
for j in range(n - i):
print(" ", end=" ")
j = 1
for j in range(i , 0, -1):
print(j, end=" ")
for j in range(2, i + 1):
print(j, end=" ")
print("\n")
n = int(input("请输入要打印的行数："))
print_nums(n)
Demo29 打印数字III
题目描述
利用循环，寻找规律，打印如下数字模式：
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
1 2 4 8 16 32 64 32 16 8 4 2 1
def print_nums(n):
i = 1
for i in range(1, n+1):
for j in range(n - i):
print(" ", end=" ")
for j in range(0, i):
print(2**j, end=" ")
for j in range(i-1, 0, -1):
print(2**(j-1), end=" ")
print("\n")
n = int(input("请输入要打印的行数："))
print_nums(n)
Demo30 打印菱形I
题目描述
如下所示，是一个高度为9的菱形
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
* * * * * * * * *
def print_diamond(n):
i = 1
for i in range(1, n // 2 + 2):
j = 1
for j in range((n // 2 + 1) - i):
print(" ", end="")
for j in range(i):
print("*", end=" ")
print("\n")
for i in range(n // 2, 0, -1):
for j in range(n // 2 - i + 1):
print(" ", end="")
for j in range(i):
print("*", end=" ")
print("\n")
n = int(input("请输入要打印的高度："))
print_diamond(n)
Demo31 打印菱形II
题目描述
如下所示，是一个高度为9的菱形
*
* *
* *
* *
* *
* *
* *
* *
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
* * * * * * * *
def print_diamond(n):
i = 1
for i in range(1, n // 2 + 2):
for j in range(n // 2 + 1 - i):
print(" ", end="")
for j in range(2 * i - 1):
if j == 0 or j == 2 * i - 2:
print("*", end="")
else:
print(" ", end="")
print("\n")
for i in range(n // 2, 0, -1):
for j in range(n // 2 - i + 1):
print(" ", end="")
for j in range(2 * i - 1):
if j == 0 or j == 2 * i - 2:
print("*", end="")
else:
print(" ", end="")
print("\n")
row = int(input("请输入打印的高度："))
print_diamond(row)
Demo32 打印菱形III
题目描述
如下所示，是一个高度为9的菱形
*
***
*****
*******
*********
*******
*****
***
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
* *** ***** *** *
def print_diamond(n):
i = 1
for i in range(1, n // 2 + 2):
for j in range(n // 2 + 1 - i):
print(" ", end="")
for j in range(2 * i - 1):
print("*", end="")
print("\n")
for i in range(n // 2, 0, -1):
for j in range(n // 2 + 1 - i):
print(" ", end="")
for j in range(2 * i - 1):
print("*", end="")
print("\n")
n = int(input("请输入要打印的高度："))
print_diamond(n)
Demo33 猜数字
题目描述
计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
对于用户输入的数字，程序会提示它是过高还是过低
输入输出描述
每次输入一个整数
每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束
示例
输入：50
输出：高了
输入：25
输出：低了
输入：42
输出：高了
输入：39
输出：猜中了！答案就是39
import random
def number(n):
random_number = random.randint(0, 100)
while n != random_number:
if n < random_number:
print("低了")
else:
print("高了")
n = int(input("请重新输入："))
print(f"猜中了!答案就是{n}")
num = int(input("请输入一个[0,100]的整数："))
number(num)
Demo34 最大公约数I
题目描述
输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8
输入输出描述
输入两个数字
输出最大公约数
示例1
输入：
16 24
输出：
8
示例2
输入：
7 3
输出：
1
def max_divisor(n1, n2):
while n2 != 0:
n1, n2 = n2, n1 % n2
return n1
num1 = int(input("请输入第一个整数："))
num2 = int(input("请输入第二个整数："))
print(max_divisor(num1, num2))
Demo35 判断素数
题目描述
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
输入输出描述
输入一个大于1的正整数
输出Yes表示该数字是素数，否则输出No
示例1
输入：
9
输出：
No
示例2
输入：
11
输出：
Yes
def prime(n):
for i in range(2, n // 2 + 1):
if n % i == 0:
return False
return True
num = int(input("请输入一个大于一的正整数："))
if prime(num):
print("Yes")
else:
print("No")
Demo36 最小公倍数
题目描述
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
输入输出描述
输入两个正整数
输出最小公倍数
示例1
输入：
3 9
输出：
9
示例2
输入：
4 6
输出：
12
def max(n1, n2):
while n2 != 0:
n1, n2 = n2, n1 % n2
return n1
def min(n1,n2):
n1, n2 = [int(x) for x in [n1, n2]]
a = (n1 * n2) // max(n1, n2)
return a
num1 , num2 = input("请输入两个整数：").split()
print(min(num1 , num2))
Demo37 整数的素因子
题目描述
输入一个正整数，然后找出它所有的最小因子，也称之为素因子
输入输出描述
输入一个正整数
输出多行，每行输出一个素因子
示例1
输入：
120
输出：
2 2 2 3 5
解释：
2 * 2 * 2 *3 * 5 = 120
示例2
输入：
100
输出：
2 2 5 5
def f(num):
a = 2
while num >= a:
if num % a == 0:
print(a, end=" ")
num /= a
else:
a += 1
num = int(input("请输入一个整数："))
f(num)
Demo38 完全数
题目描述
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
输入输出描述
输入一个正整数
输出该数是否为完全数
示例1
输入：
6
输出：
Yes
示例2
输入：
9
输出：
No
def number(n):
s = 0
for i in range(1, n):
if n % i == 0:
s += i
if s == n:
print("Yes")
else:
print("No")
num = int(input("请输入一个正整数："))
number(num)
Demo39 前50个素数
题目描述
打印前50个素数，每打印10个素数换行
def prime(n):
if n < 2:
return False
for i in range(2, n // 2 + 1):
if n % i == 0:
return False
return True
num = 2
count = 0
while count < 50:
if prime(num):
print(num, end=" ")
count += 1
if count % 10 == 0:
print("\n")
num += 1
Demo40 计算π
题目描述
你可以使用下面的数列近似计算π
π
=
4
(
1
−
1
3
+
1
5
−
1
7
+
1
9
−
1
11
+
.
.
.
+
(
−
1
)
i
+
1
2
i
−
1
)
π=4(1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\frac{1}{11}+...+\frac{(-1)^{i+1}}{2i-1})
π=4(1−31+51−71+91−111+...+2i−1(−1)i+1)
当i越大时，计算结果越近似于π
def pi(n):
sum = 0
for i in range(1, n+1):
a = 4 * (-1)**(i + 1) / (2 * i - 1)
sum += a
print(sum)
n = int(input("请输入一个数："))
pi(n)
Demo41 计算e
题目描述
你可以使用下面的数列近似计算e
e
=
1
+
1
1
!
+
1
2
!
+
1
3
!
+
1
4
!
+
.
.
.
+
1
i
!
e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!}
e=1+1!1+2!1+3!1+4!1+...+i!1
当i越大时，计算结果越近似于e
import math
def e(n):
sum = 1
for i in range(1, n+1):
a = 1 / math.factorial(i)
sum += a
return sum
num = int(input("请输入一个数："))
print(e(num))
Demo42 剪刀石头布II
题目描述
延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
import random
def get_user_choice():
choice = int(input("请选择0(剪刀),1(石头),2(布) :"))
return choice
def get_computer_choice():
return random.randint(0, 2)
def game(user_choice, computer_choice):
if user_choice == computer_choice:
return "平局"
elif (user_choice == 0 and computer_choice == 2) or (user_choice == 1 and computer_choice == 0) or (user_choice == 2 and computer_choice== 1):
return "用户赢"
else:
return "电脑赢"
user_score = 0
computer_score = 0
while user_score < 3 and computer_score < 3:
user_choice = get_user_choice()
computer_choice = get_computer_choice()
print("用户选择：", user_choice)
print("电脑选择：", computer_choice)
result = game(user_choice, computer_choice)
print("结果：", result)
if result == "用户赢":
user_score += 1
elif result == "电脑赢":
computer_score += 1
if user_score > computer_score:
print("用户是终极胜利者！")
else:
print("电脑是最终胜利者！")
Demo43 组合问题I
题目描述
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
combinations = []
for i in range(1, 8):
for j in range(i + 1, 8):
combinations.append((i, j))
unique_combinations = set(combinations)
count = len(unique_combinations)
print("所有组合：")
for i in unique_combinations:
print(i)
print("组合个数：", count)
Demo44 组合问题II
题目描述
有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
def get_nmbers():
numbers = [1, 2, 3, 4]
count = 0
for i in numbers:
for j in numbers:
for k in numbers:
if i != j and i != k and j != k:
print(i, j, k)
count += 1
return count
get_nmbers()
print(f"能组成{get_nmbers()}个无重复的三位数")
Demo45 水仙花数
题目描述
水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如 153 = 1 3 + 5 3 + 3 3 153=1^3+5^3+3^3 153=13+53+33
编写程序，输出所有的水仙花数
def number():
for i in range(100, 1000):
a = i % 10
b = i // 10 % 10
c = i // 100
if i == a**3 + b**3 + c**3:
print(i)
number()
Demo46 青蛙跳台阶
题目描述
一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？
例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）
def footstep(n):
if n == 1:
return 1
if n == 2:
return 2
else:
return footstep(n-1) + footstep(n-2)
n = int(input("请输入有多少个台阶："))
print(f"青蛙有{footstep(n)}中跳法")
Demo47 堆叠相加
题目描述
现有堆叠相加模式 a + a a + a a a + a a a a + a a a a a + . . . . . . a+aa+aaa+aaaa+aaaaa+...... a+aa+aaa+aaaa+aaaaa+......
例如： 2 + 22 + 222 + 2222 + 22222 2+22+222+2222+22222 2+22+222+2222+22222，其中a为2，且有5组数字
输入输出描述
输入两个数据分别为数字a和组数n
输出按照堆叠相加模式算出的和
示例
输入：
3 4
输出：
3702
解释：
3 + 33 + 333 + 3333 = 3702
def sum(a, n):
a, n = [int(x) for x in [a, n]]
sum = 0
A = a
num = 0
while num < n:
sum += a
a = A + a*10
num += 1
return sum
a, n = input("输入两个数据分别为数字a和组数n：").split()
print(sum(a, n))
Demo48 十进制转二进制
题目描述
输入一个十进制正整数，输出其二进制形式
输入输出描述
输入一个十进制正整数
输出二进制字符串
示例
输入：
9
输出：
1001
def number1(n):
a = bin(n)[2:]
return a
def number2(n):
bin_number =""
if n == 0:
bin_number = 0
while n > 0:
b = n % 2
bin_number = str(b) + bin_number
n = n // 2
return bin_number
num = int(input("请输入一个十进制整数："))
print(number2(num))
Demo49 二进制转十进制
题目描述
输入一个二进制字符串，输出其对应的十进制数字
输入输出描述
输入一个二进制字符串
输出十进制数字
示例
输入：
1001
输出：
9
def d_number(n):
decimal = 0
j = 0
for i in n[::-1]:
decimal += int(i) * (2**j)
j += 1
return decimal
num = input("请输入二进制数：")
print(f"转换为十进制为:{d_number(num)}")
Demo50 十进制转十六进制
题目描述
输入一个十进制正整数，输出其十六进制形式
输入输出描述
输入一个十进制正整数
输出十六进制字符串
示例
输入：
1233321
输出：
1e1b9
def hex(n):
hexadecimal = hex(n)[2::]
return hexadecimal
num = int(input("请输入一个十进制数："))
print(f"转换为十六进制为{hex(num)}")
Demo51 十六进制转十进制
题目描述
输入一个十六进制字符串，输出其对应的十进制数字
输入输出描述
输入一个十六进制字符串
输出十进制数字
示例
输入：
1e1b9
输出：
123321
def int_number(num):
decimal_num = int(num, 16)
print("转换后的十进制数：", decimal_num)
num = input("请输入十六进制数：")
int_number(num)
Demo52 最长公共前缀
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2
输出前缀串
示例
输入：
abcdefg
abcdhko
输出：
abcd
def common_str(s1, s2):
min_len = min(len(s1), len(s2))
for i in range(min_len):
if s1[i] != s2[i]:
return s1[:i]
if min_len == len(s1):
return s1
else:
return s2
s1 = input("请输入第一个字符串：")
s2 = input("请输入第二个字符串：")
print(common_str(s1, s2))
Demo53 子串出现的次数
题目描述
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配
输入输出描述
输入两行字符串，分别为s1和s2，s2的长度小于等于s1
输出s2在s1中出现的次数
示例1
输入：
ABCsdABsadABCasdhjabcsaABCasd
ABC
输出：
3
示例2
输入：
AAAAAAAA
AAA
输出：
def count_occurrences(s1, s2):
count = 0
start = 0
while True:
index = s1.find(s2, start)
if index == -1:
break
count += 1
start = index + len(s2)
return count
# 读取输入
s1 = input()
s2 = input()
# 计算出现次数
occurrences = count_occurrences(s1, s2)
# 输出结果
print(occurrences)
Demo54 最长公共子串
题目描述
给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写
输入输出描述
输入两行字符串，分别为s1和s2
输出最长公共子串
示例
输入：
123ABCDEFG83hsad
iughABCDEFG23uy
输出：
ABCDEFG
def longest_common_substring(s1, s2):
m = len(s1)
n = len(s2)
max_length = 0
end_index = 0
# 创建一个二维数组来存储最长公共子串的长度
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i - 1] == s2[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
if dp[i][j] > max_length:
max_length = dp[i][j]
end_index = i
# 根据最长公共子串的长度和结束索引，提取最长公共子串
longest_substring = s1[end_index - max_length: end_index]
return longest_substring
# 读取输入
s1 = input()
s2 = input()
# 计算最长公共子串
common_substring = longest_common_substring(s1, s2)
# 输出结果
print(common_substring)
Demo55 检测密码
题目描述
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
输入输出描述
输入一串密码
输出该密码是否符合规则
示例1
输入：
123456ab
输出：
No
示例2
输入：
123abcABC
输出：
Yes
def check_password(password):
if len(password) < 8:
return "No"
digit_count = 0
uppercase_count = 0
for char in password:
if char.isdigit():
digit_count += 1
elif char.isupper():
uppercase_count += 1
if digit_count >= 2 and uppercase_count >= 2:
return "Yes"
else:
return "No"
password = input("请输入密码：")
result = check_password(password)
print(result)
Demo56 回文素数
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
def is_prime(n):
if n < 2:
return False
for i in range(2, n // 2 + 1):
if n % i == 0:
return False
return True
def is_palindrome(n):
return str(n) == str(n)[::-1]
count = 0
n = 2
while count < 100:
if is_prime(n) and is_palindrome(n):
print(n, end=" ")
count += 1
if count % 10 == 0:
print()
n += 1
Demo57 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
def reverse_number(n):
return int(str(n)[::-1])
count = 0
n = 2
while count < 100:
if is_prime(n) and is_prime(reverse_number(n)) and n != reverse_number(n):
print(n, end=" ")
count += 1
if count % 10 == 0:
print()
n += 1
Demo58 双素数
题目描述
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
def twin_primes(limit):
twin_primes_list = []
for num in range(2, limit - 1):
if is_prime(num) and is_prime(num + 2):
twin_primes_list.append((num, num + 2))
return twin_primes_list
# 设置限制为1000
limit = 1000
# 获取小于1000的双素数列表
twin_primes_list = twin_primes(limit)
# 输出结果
for twin_prime in twin_primes_list:
print(twin_prime[0], twin_prime[1])
Demo59 梅森素数
如果一个素数可以写成 2 p − 1 2^p-1 2p−1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
def mersenne_primes():
mersenne_primes_list = []
for p in range(2, 32):
num = 2**p - 1
if is_prime(num):
mersenne_primes_list.append((p, num))
return mersenne_primes_list
# 获取p≤31的所有梅森素数列表
mersenne_primes_list = mersenne_primes()
# 输出结果
for mersenne_prime in mersenne_primes_list:
print("p =", mersenne_prime[0], ", Mersenne Prime =", mersenne_prime[1])
Demo60 平方根的近似求法
有几种实现开平方 n \sqrt{n} n的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
n
e
x
t
G
u
e
s
s
=
(
l
a
s
t
G
u
e
s
s
+
n
/
l
a
s
e
t
G
u
e
s
s
)
/
2
nextGuess=(lastGuess+n/lasetGuess)/2
nextGuess=(lastGuess+n/lasetGuess)/2
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
def babylonian_sqrt(n):
last_guess = 1
next_guess = (last_guess + n / last_guess) / 2
while abs(next_guess - last_guess) > 0.0001:
last_guess = next_guess
next_guess = (last_guess + n / last_guess) / 2
return next_guess
# 输入n的值
n = float(input("请输入一个正数n："))
# 调用函数计算平方根的近似值
sqrt_approx = babylonian_sqrt(n)
# 输出结果
print(f"{n}的平方根的近似值为：{sqrt_approx}")
第三部分 容器操作
Demo61 指定等级
题目描述
读入学生成绩，获取最高分best，然后根据下面的规则赋等级值：
（1）如果分数≥best-10，等级为A
（1）如果分数≥best-20，等级为B
（1）如果分数≥best-30，等级为C
（1）如果分数≥best-40，等级为D
（1）其他情况，等级为F
输入输出描述
输入两行，第一行输入学生人数n，第二行输入n个学生的成绩
输入n行，表示每个学生的成绩等级
示例
输入：
4
40 55 70 58
输出：
学生0分数为40，等级为C
学生1分数为55，等级为B
学生2分数为70，等级为A
学生3分数为58，等级为B
def get_grade(score, best):
if score >= best - 10:
return 'A'
elif score >= best - 20:
return 'B'
elif score >= best - 30:
return 'C'
elif score >= best - 40:
return 'D'
else:
return 'F'
# 输入学生人数
n = int(input("请输入学生人数："))
# 输入学生成绩
scores = list(map(int, input("请输入学生成绩：").split()))
# 获取最高分
best = max(scores)
# 输出学生成绩等级
for i, score in enumerate(scores):
grade = get_grade(score, best)
print("学生{}分数为{}，等级为{}".format(i, score, grade))
Demo62 计算数字的出现次数
题目描述
读取1到100之间的整数，然后计算每个数出现的次数
输入输出描述
输入两行，第一行为整数的个数n，第二行为n个整数
输出多行，每行表示某数及其出现的次数，顺序按照数字从小到大
示例
输入：
9
2 5 6 5 4 3 23 43 2
输出：
2出现2次
3出现1次
4出现1次
5出现2次
6出现1次
23出现1次
43出现1次
def count_occurrences(numbers):
occurrences = {}
for num in numbers:
if num in occurrences:
occurrences[num] += 1
else:
occurrences[num] = 1
return occurrences
# 输入整数的个数
n = int(input("请输入整数的个数："))
# 输入整数
numbers = list(map(int, input("请输入整数：").split()))
# 计算每个数出现的次数
occurrences = count_occurrences(numbers)
# 输出结果
for num, count in sorted(occurrences.items()):
print("{}出现{}次".format(num, count))
Demo63 打印不同的数
题目描述
读入n个数字，并显示互不相同的数（即一个数出现多次，但仅显示一次），数组包含的都是不同的数
输入输出描述
输入两行，第一行为数字的个数n，第二行为n个数字
输出数组，包含的都是不同的数
示例
输入：
10
1 2 3 2 1 6 3 4 5 2
输出：
1 2 3 6 4 5
def unique_numbers(numbers, n):
nums = []
for i in numbers:
if i not in nums:
nums.append(i)
return nums
if __name__ == "__main__":
n = int(input("请输入数字的个数："))
numbers = [n]
numbers = list(map(int, input().split()))
print(unique_numbers(numbers, n))
Demo64 最大公约数II
题目描述
输入n个数字，求该n个数字的最大公约数
输入输出描述
输入两行，第一行为数字个数n，第二行为n个整数
输出最大公约数
示例
输入：
9 12 18 21 15
输出：
3
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def gcd_numbers(numbers):
result = numbers[0]
for i in range(1, len(numbers)):
result = gcd(result, numbers[i])
return result
if __name__ == "__main__":
n = int(input("请输入数字个数："))
nums = list(map(int, input().split()))
if len(nums) == n:
print(gcd_numbers(nums))
else:
print("重新输入")
Demo65 打乱数组
题目描述
编程程序，对给定的数组进行随机打乱，并输出打乱后的结果
import random
def shuff_arry(nums):
random.shuffle(nums)
return nums
if __name__ == "__main__":
nums = list(map(int, input().split()))
print(shuff_arry(nums))
Demo66 是否有序
题目描述
编写程序，对给定的数组进行判断，判断其数组元素是否非单调递减
输入输出描述
第一行输入测试数据组数T，接下来有2T行，每第一行表示数组长度n，每第二行有n个元素
输出T行，表示该数组是否有序
示例
输入：
3
5
1 2 3 4 5
4
3 1 2 4
5
1 2 2 3 4
输出：
YES
NO
YES
def decreasing_array(nums):
for i in range(0, len(nums)):
if nums[i] < nums[i+1]:
return True
else:
return False
def get_array(T):
for i in range(T):
n = int(input("输入数组长度："))
nums = list(map(int, input().split()))
if len(nums) != n:
print("输入错误!!")
continue
result = decreasing_array(nums)
if result:
print("YES")
else:
print("NO")
if __name__ == "__main__":
T = int(input("输入测试数据组数:"))
get_array(T)
Demo67 相似词
题目描述
输入两个英文单词，判断其是否为相似词，所谓相似词是指两个单词包含相同的字母
输入输出描述
输入两行，分别表示两个单词
输出结果，为相似词输出YES，否则输出NO
示例
输入：
listen
silent
输出：
YES
def similar_word(word1, word2):
set1 = set(word1)
set2 = set(word2)
if len(set1 .intersection(set2)) > 0:
return "YES"
else:
return "NO"
if __name__ == "__main__":
word1 = input()
word2 = input()
print(similar_word(word1, word2))
Demo68 豆机器
题目描述
豆机器，也称为梅花或高尔顿盒子，它是一个统计实验的设备，它是由一个三角形直立板和均匀分布的钉子构成，如下图所示：
小球从板子的开口处落下，每次小球碰到钉子，它就是50%的可能掉到左边或者右边，最终小球就堆积在板子底部的槽内
编程程序模拟豆机器，提示用户输入小球的个数以及机器的槽数，打印每个球的路径模拟它的下落，然后打印每个槽子中小球的个数
输入输出描述
输入两个数据，分别表示小球个数和槽子的个数
输出每个小球经过的路径，和最终每个槽子里小球的个数（因为牵扯随机数，程序结果不唯一，示例仅用于表明题意）
示例
输入：
5 8
输出：
LRLRLRR
RRLLLRR
LLRLLRR
RRLLLLL
LRLRRLR
0 0 1 1 3 0 0 0
import random
def simulate_bean_machine(ball_count, slot_count):
slots = [0] * slot_count # 初始化槽子列表，每个槽子中的小球个数为0
for _ in range(ball_count):
path = "" # 记录小球的路径
position = 0 # 小球的初始位置在第一个槽子
for _ in range(slot_count - 1):
direction = random.choice(["L", "R"]) # 随机选择小球的下一步方向
path += direction
if direction == "R":
position += 1
slots[position] += 1 # 将小球放入最终位置的槽子中
print("小球路径:", path)
print("每个槽子中小球的个数:", slots)
# 读入小球个数和槽子个数
ball_count, slot_count = map(int, input().split())
# 模拟豆机器
simulate_bean_machine(ball_count, slot_count)
Demo69 更衣室难题
题目描述
一个学校有100个更衣室和100个学生。所有的更衣室在开学第一天都是锁着的。随着学生进入，第一个学生表示为S1，打开每个更衣室；然后第二个学生S2，从第二个更衣室开始，用L2表示，关闭所有其他更衣室；学生S3从第三个更衣室L3开始，改变每三个更衣室（如果打开则关闭，如果关闭则打开）；学生S4从更衣室L4开始，改变每四个更衣室；学生S5开始从更衣室L5开始，改变每五个更衣室。依次类推，直到学生S100改变L100。
在所有学生都经过了操作后，哪些更衣室是打开的？编程找出答案。
def find_open_lockers():
lockers = [False] * 100 # 初始化所有更衣室为关闭状态
for student in range(1, 101):
for locker in range(student - 1, 100, student):
lockers[locker] = not lockers[locker] # 改变更衣室的状态
open_lockers = [i + 1 for i, locker in enumerate(lockers) if locker] # 找出打开的更衣室编号
return open_lockers
open_lockers = find_open_lockers()
print("打开的更衣室编号:", open_lockers)
Demo70 合并两个有序数组
题目描述
给定两个有序递增的数组A和数组B，将其进行合并成一个新的数组C，且保持有序递增，并输出数组C
输入输出描述
第一行输入数组A的长度n，第二行输入n个元素，第三行输入数组B的长度m，第四行输入m个元素
输出数组C的n+m个元素
示例
输入：
5
1 5 16 61 111
4
2 4 5 6
输出：
1 2 4 5 5 6 16 61 111
def hebing_arr(nums1:list,nums2:list):
for i in nums2:
nums1.append(i)
for i in range(len(nums1)-1):
for j in range(i+1,len(nums1)):
if nums1[j] < nums1[i]:
nums1[i],nums1[j] = nums1[j],nums1[i]
print(nums1)
if __name__ == "__main__":
n = int(input())
nums1 =list(int(s)for s in input().split())
m = int(input())
nums2 =list(int(s)for s in input().split())
hebing_arr(nums1,nums2)
Demo71 数组划分
题目描述
给定一个数组A，将第一个元素 A 0 A_0 A0作为枢纽，并把数组划分成三个区间，第一个区间所有元素 < A 0 <A_0 <A0，第二个区间所有元素 = = A 0 ==A_0 ==A0，第三个区间所有元素 > A 0 >A_0 >A0
例如数组[5,2,9,3,6,8]，划分后的结果为[3,2,5,9,6,8]，第一个区间[3,2]，第二个区间[5]，第三个区间[9,6,8]
结果不唯一，只要保证划分后三个区间的元素特性即可，[2,3,5,9,8,6]、[3,2,5,6,8,9]都可作为上述划分的结果
输入输出描述
第一行输入数组的长度n，第二行输入n个元素
输出划分后的结果
示例
输入：
10
5 1 9 2 5 7 4 5 3 6
输出：
1 2 4 3 5 5 5 9 7 6
def separation_arr(A) :
arr_1 = []
arr_2 = []
arr_3 = []
for i in A :
if i < A[0] :
arr_1.append(i)
elif i == A[0] :
arr_2.append(i)
else :
arr_3.append(i)
return arr_1 + arr_2 + arr_3
if __name__ == "__main__" :
n = int(input("请输入数组的长度："))
A = eval(input("请输入一共数组，用逗号相隔："))
print(separation_arr(A))
扫一扫
9322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
