python编程练习

已于 2024-04-19 11:24:27 修改

阅读量1.2k

点赞数 50

文章标签： python 前端

于 2024-03-30 16:00:33 首次发布

本文链接：https://blog.csdn.net/2302_77625887/article/details/137174128

版权

一、语法基础编程练习

Test01

题目：

输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出转换的公式为如下：

fahrenheit = (9 / 5) * celsius + 32

输入输出描述输入一个值表示摄氏温度celsius 输出华氏温度fahrenheit ，结果保留一位小数

#摄氏温度转化为华氏温度

分析：

"""

数据：cel fah

步骤：

1.输入cel

2.根据给定公式计算fah

3.输出fah

"""

cel = eval(input())

fah = 9 / 5 * cel + 32

print("%.1f "% fah)

Test02

题目：

输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。

area = radius * radius * pi

volume = area * length

分析：

#计算圆柱体的体积

"""

数据：radius length area volume pi

步骤：

1.输入相应半径和长度

2.根据公式进行底面积和体积

3.输出

"""

radius, length = eval(input())

area = radius * radius * 3.14159267

volume = area * length

print(area)

print(volume)

Test03

题目：

输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米

分析：

# 将英尺数转换为米数

"""

数据：chi mi

步骤：

1.输入一个英尺数

2.根据转换单位要求进行转换

3.输出

"""

chi = eval(input())

mi = chi * 0.305

print(mi)

Test04

题目：

读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是 1.5元，合计金额为11.5元

分析：

#计算小费

"""

数据：小计money 酬金率remu 总计total

步骤：

1.输入小计

2.计算需要的酬金，然后计算总计

3.输出

"""

money, remu = eval(input())

total = money * (1 + remu * 0.01)

print("%.2f" % total)

Test05

题目：

读取一个0到1000之间的整数，并计算它各位数字之和

分析：

# 对一个整数中的各位数字求和

"""

数据：num ge shi bai nsum

步骤：

1.输入一个0到999之间的整数

2.分别求出ge shi bai 并进行求和

3.输出

"""

num = eval(input())

ge = num % 10

num //= 10

shi = num % 10

num //= 10

bai = num % 10

nsum = ge + shi + bai

print(nsum)

Test06

题目：

输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天

分析：

# 计算年数和天数

"""

数据：minutes hours days years

步骤：

1.输入一个分钟数

2.进行小时转换

3.进行天数转换

4.进行年的转换

5.输出

"""

minutes = eval(input())

hours = minutes // 60

days = hours // 24

years = days // 365

days = days % 365

print(years)

print(days)

Test07

题目：

水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：

Q = M * (finalTemperature - initialTemperature) * 4184

这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计

分析：

#计算能量

"""

数据：M 初始温度fT 最终温度iT 热量Q

步骤：

1.输入水量，初始温度，最终温度

2.根据公式计算出热量

3.输出

"""

M, fT, iT = eval(input())

Q = M * (fT - iT) * 4184

print(Q)

Test08

题目：

输入一个四位整数，并以反向顺序显示

分析：

# 分割数字

"""

数据：num ge shi bai qian

步骤：

1.输入一个四位整数

2.反向顺序显示个，十，百，千位

3.输出

"""

num = eval(input())

ge = num % 10

num //= 10

shi = num % 10

num //= 10

bai = num % 10

num //=10

qian = num % 10

print(ge)

print(shi)

print(bai)

print(qian)

Test09

题目：

输入三角形的三个顶点坐标，并计算其面积，计算公式如下：

s = (side1 + side2 + side3) / 2

area = (s(s - side1) * (s - side2) * (s - side3)) ** 0.5

分析：

# 计算三角形的面积

"""

数据：三个坐标值面积area s

步骤：

1.输入三个顶点的坐标

2.根据公式计算面积

3.输出

"""

x1, x2, x3, y1, y2, y3 = eval(input())

side1 = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5

side2 = ((x2 - x3) ** 2 + (y2 - y3) ** 2) ** 0.5

side3 = ((x3 - x1) ** 2 + (y3 - y1) ** 2) ** 0.5

s = (side1 + side2 + side3) / 2

area = (s * (s - side1) * (s - side2) * (s - side3))

print("%.1f" % area)

Test10

题目：

输入你所在的时区，并输出当前的时间

分析：

#显示当前时间

"""

数据：输入的时区timezone，当前时间的表示zone0time，当前时区的时间yourzonetime，当前时区时间的秒数secend，当前时区时间的分钟minutes，当前时区时间的小时hours

分析：

1.根据输入的时区，在当前时间的基础上计算出对应时区的时间，并以时：分：秒的格式打印出来

2.首先，需要导入可以显示时间的库

3.用户需要输入一个时区的值，然后通过一系列计算得到该时区的时间

4.最后，打印输出

"""

import time

timezone = eval(input())

zone0time = time.time()

yourzonetime = zone0time + timezone * 60 * 60

secend = yourzonetime % 60

minutes = yourzonetime // 60 % 60

hours = yourzonetime // 60 // 60 % 24

print("%d:%d:%d"%(hours,minutes,secend))

Test11

题目：

输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）

A = acos((a * a - b * b - c * c) / (-2 * b * c))

B= acos((a * a - b * b - c * c) / (-2 * a* c))

C = acos((a * a - b * b - c * c) / (-2 * b * a))

其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角

分析：

# 计算三角形的三个角

"""

数据：三角形的三个点的坐标以及三角形的三个边，三个角的度数

分析：

1.首先，用户需要输入三个点的坐标(x1, y1), (x2, y2), (x3, y3)。

2.然后，通过计算三个边长a、b、c的长度

3.再利用三角形余弦定理计算出三个角A、B、C的度数

4.最后，打印输出

"""

import math

x1, y1, x2, y2, x3, y3 = eval(input())

a = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

b = math.sqrt((x3 - x2) ** 2 + (y3 - y2) ** 2)

c = math.sqrt((x3 - x1) ** 2 + (y3 - y1) ** 2)

A = math.degrees(math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c)))

B = math.degrees(math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c)))

C = math.degrees(math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b)))

print("A角的度数为%.2f" % A)

print("B角的度数为%.2f" % B)

print("C角的度数为%.2f" % C)

Test12

题目：

假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少

分析：

# 最小数量的硬币

"""

数据：输入的金额、一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币

分析：

1.首先，用户需要输入一个总金额。

2.然后，根据五个面额的硬币的从大到小的顺序来进行整数和减去的操作来得到需要的硬币数以及之后的面值

3.最后，以相应的格式进行打印

"""

total = eval(input())
oneyuan = total // 1
total %= 1
print(total)
twojiao_fivefen = total // 0.25
total = total - twojiao_fivefen * 0.25
onejiao = total // 0.1
total = total - onejiao * 0.1
fivefen = total // 0.05
total = total - fivefen * 0.05
onefen = total // 0.01
print("%d个一元硬币" % oneyuan)
print("%d个两角五分硬币" % twojiao_fivefen)
print("%d个一角硬币" % onejiao)
print("%d个五分硬币" % fivefen)
print("%d个一分硬币" % onefen)

Test13

题目：

正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：

area = n * s ** 2 / 4 * tan(pi / n)

分析：

#正多边形的面积

"""

数据：边的个数，长度，面积

分析：

1.由于需要用到数学运算，导入一个math库

2.输入两个变量

3.根据公式进行运算

4.打印输出

"""

import math
n, s =eval(input())
area = (n * s ** 2) / (4 * math.tan(3.14159267 / n))
print("%.2f" % area)

Test14

题目：

BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出

分析：

#计算身体质量指数

"""

数据：BMI kg height

步骤：

1.输入体重和身高

2.判断在那个区间

3.输出区间对应的值

"""

kg, height = eval(input())
BMI = kg / height ** 2
if BMI < 18.5:
    print("超轻")
elif BMI < 25.0:
    print("标准")
elif BMI < 30.0:
    print("超重")
else:
    print("肥胖")

Test15

题目：

一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年

分析：

# 判定闰年

"""

数据：输入的年份

分析：

1.获取用户输入的年份

2.根据闰年的条件进行if判断

3.打印输出

"""

years = eval(input())
if (years % 4 == 0 and years % 100 != 0) or years % 400 == 0:
    print("Yes")
else:
    print("No")

Test16

题目：

随机产生一个两位数数字，然后用户输入一个两位数数字，并根据以下规则判定用户赢得的奖金是多少

（1）输入的数字和随机产生的数字完全相同（包括顺序），奖金为10000元

（2）输入的数字和随机产生的数字相同（不包括顺序），奖金为3000元

（3）输入的数字和随机产生的数字有一位数相同，奖金为1000美元

（4）输入的数字和随机产生的数字都不相同，没有奖金，0元

分析：

#中彩票

"""

数据：random r1 r2 u1 u2 unum

步骤：

1.随机生成一个两位数，并获取用户输入的一个两位数

2.根据不同情况进行判定

3.输出

"""

import random
randomNum = random.randint(10,99)
print(randomNum)
unum = eval(input())
r1 = randomNum / 10
r2 = randomNum % 10
u1 = unum / 10
u2 = unum % 10
if randomNum == unum:
    print(10000)
elif r1 == u2 and r2 == u1:
    print(5000)
elif r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2:
    print(3000)
else:
    print(0)

Test17

题目：

一元二次方程的解可以使用下面的公式计算

r1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / 2 * a

r2 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / 2 * a

其中 b ** 2 - 4 * a * c称为判别式，如果它为正，则方程有两个实数解；为零，方程只有一个实数解；为负，没有实数

分析：

#解一元二次方程

"""

数据：参数 a b c 解x1 x2 判别式delt

步骤：

1.输入a，b，c三个数据

2.利用公式进行delt判别式的判定，得出相应解的数量

3.通过求解公式得出解

4.输出

"""

print("输入：")
a, b, c = eval(input())
delt = b ** 2 - 4 * a * c
if delt > 0:
    x1 = (-b + delt ** 0.5) / 2 * a
    x2 = (-b - delt ** 0.5) / 2 * a
    print("输出：")
    print("%.2f" % x1)
    print("%.2f" % x2)
elif delt == 0:
    x1 = x2 = -b / 2* a
    print("输出：")
    print("%.2f" % x1)
else:
    print("输出：")
    print("无实数解")

Test18

题目：

如有一个2×2的线程方程组：

ax + by = e

cx + dy = f

你可以使用克莱姆法则解该线性方程：

x = (ed - bf) / (ad - bc)

y = (af -ec) / (ad - bc)

其中 ad - bc为判别式，如果为零则输出无解

分析：

# 解2×2线程方程

"""

数据：线性方程组的六个参数

分析：

1.用户需要输入6个参数a, b, c, d, e, f，代表线性方程组的系数。

2.程序首先判断方程组是否有解，如果a * d - b * c等于0，则输出"无解"；否则，根据克莱姆法则计算出方程组的解x和y

3.打印输出

"""

a, b, c, d, e, f = eval(input())
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("%.1f" % x)
    print("%.1f" % y)

Test19

题目：

输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）并输入今天之后到未来某天的天数，然后输出该天是星期几

分析：

#未来是周几

"""

数据：今日星期几，未来某天的天数

分析：

1.获取用户输入的今日星期几，和未来某天的天数

2.由于星期的进制是七进制，只需要得到这两个数据对于7的余数即可知道未来的星期

3.打印输出

"""

today, future = eval(input("请输入今天是一周内哪一天的数字和今天之后到未来某天的天数:"))
futureweek = (today + future) % 7
if futureweek == 0:
    print("周日")
elif futureweek == 1:
     print("周一")
elif futureweek == 2:
    print("周二")
elif futureweek == 3:
    print("周三")
elif futureweek == 4:
    print("周四")
elif futureweek == 5:
    print("周五")
else:
    print("周六")

Test20

题目：

给定某年、某月、某日的一个日期，计算该日是今年中的第几天

分析：

#本年中的第几天

"""

数据：年，月，日

分析：

1.获取今年的年，月，日

2.计算给定日期距离当年1月1日的天数

3.程序首先判断年份是否为闰年，根据不同月份的天数累加得到给定日期距离当年1月1日的天数

4.最后输出

"""

years, month, day = eval(input())
days = 0
if (years % 4 == 0 and years % 100 != 0) or years % 400 == 0:
    for time in range(1, month):
        time += 1
        if time in (1, 3, 5, 7, 8, 10, 12):
            days += 31
        elif time in (4, 6, 9, 11):
            days += 30
        else:
            days += 29
else:
    for time in range(1, month):
        time += 1
        if time in (1, 3, 5, 7, 8, 10, 12):
            days += 31
        elif time in (4, 6, 9, 11):
            days += 30
        else:
            days += 28
days += day
print(days)

Test21

题目：

计算机随机产生一个数字0、1和2分别表示剪刀、石头和布用户输入数字0、1或2，输出用户赢、计算机赢或平局

分析：

#剪刀石头布

"""

数据：用户输入的代表石头，剪刀，布的数值，系统随机产生具有同样含义的数值

分析：

1.由于需要系统随机产生，需要导入random库

2.定义系统和用户随机产生数值的区间

3.进行各种结果的判定

4.输出相应的结果

"""

import random

randomNum = random.randint(0,2)

num = eval(input("请输入0，1，2分别代表剪刀，石头，布:"))

if randomNum == 0:

    print("计算机出的剪刀")

elif randomNum == 1:

    print("计算机出的石头")

else:

    print("计算机出的布")

if num == 0:

    print("用户出的剪刀")

elif num == 1:

    print("用户出的石头")

else:

    print("用户出的布")

if (randomNum == 0 and num == 2) or (randomNum == 1 and num == 0) or (randomNum == 2 and num == 1):

    print("计算机赢")

elif (num == 0 and randomNum == 2) or (num == 1 and randomNum == 0) or (num == 2 and randomNum == 1):

    print("用户赢")

else:

    print("平局")

Test22

题目：

输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法如果任意两边之和大于第三边则输入都是合法的

分析：

#三角形的周长

length1, length2, length3 = eval(input()) # 用户输入的三角形的三个边

if (length1 + length2 > length3) and (length1 + length3 > length2) and (length3 + length2 > length1): #判断是否为三角形：任意两边大于第三边

    C = length1 + length2 + length3 #计算周长

    print(C)

else:

    print("非法")

Test23

题目：

泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：

h = (q + [26 * (m + 1) / 10] + k + [k / 4] +[j / 4) + 5 * j] % 7

（1）是指一周的星期几（0表示星期六、1表示星期天、...、6表示星期五）

（2） q是一个月的那一天

（3）是一个月的哪一天是月份（3表示三月、4表示四月、...、12表示十二月），其中一月和二月都是按照前一年的13 月和14月来计数的，所以还得把年份改为前一年

（4）是世纪数，即[year / 100]

（5）是一个世纪的某一年，即year % 100

（6）[]为向下取整符号

分析：

# 一周的星期几

import math #导入math库，用于后面相关于数学的运算

yesrs, months, days = eval(input()) #用户输入的年，月，日

h = (days + math.floor(26 * (months + 1) // 10) + yesrs % 100 + math.floor((yesrs % 100) // 4) + math.floor((math.floor(yesrs // 100)) // 4) + 5 * math.floor(yesrs // 100)) % 7 #泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几

if h == 1:

    print("周天")

elif h == 2:

     print("周一")

elif h == 3:

    print("周二")

elif h == 4:

    print("周三")

elif h == 5:

    print("周四")

elif h == 6:

    print("周五")

else:

    print("周六")

Test24

题目：

直线A上的两个点是(x1,y1)和(x2,y2)，直线B上的两个点(x3,y3)是(x4,y4) 如果两条直线有交点，可以通过解下面的线性等式找出：

如果没有解，则表示两条直线平行

分析：

#直线的交点

import sympy #sympy库提供了符号计算的功能，包括符号代数、微积分、方程求解、微分方程求解、矩阵运算等

x, y = sympy.symbols('x y')

x1, y1, x2, y2, x3, y3, x4, y4 = eval(input())

ka = (y2 - y1) / (x2 - x1) #求直线的斜率

kb = (y4 - y3) / (x4 - x3)

if ka != kb: # 两条直线的斜率不相同就终会相交

    eq1 = (y1 - y2) * x - (x1 - x2) * y - (y1 - y2) * x1 + (x1 - x2) * y1 #构建第一条直线的方程。

    eq2 = (y3 - y4) * x - (x3 - x4) * y - (y3 - y4) * x3 + (x3 - x4) * y3 #构建第二条直线的方程。

    solutions = sympy.solve([eq1, eq2], [x, y])  # 使用SymPy解方程组，求解两条直线的交点坐标。

    print(solutions)

else:

    print("无解")

Test25

题目：

输入一个三位整数，然后判断其是否为一个回文数如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数

分析：

#回文数，由于这里只有三位数，无论从前开始还是从后开始，中间值都不会变，所以只需要比较个位和百位

num = eval(input("请输入一个三位数："))

bai = num // 100

ge = num % 10

if bai == ge:

    print("Yes")

else:

    print("No")

Test26

题目：

判断两个矩形之间的关系：包含，重叠，相离

分析：

#判断两个矩形之间的包含，重叠，相离关系

# 读取输入数据

rect1 = list(map(float, input().split()))

rect2 = list(map(float, input().split()))



# 解析矩形1的数据

x1, y1, w1, h1 = rect1

left1 = x1 - w1 / 2

right1 = x1 + w1 / 2

top1 = y1 + h1 / 2

bottom1 = y1 - h1 / 2



# 解析矩形2的数据

x2, y2, w2, h2 = rect2

left2 = x2 - w2 / 2

right2 = x2 + w2 / 2

top2 = y2 + h2 / 2

bottom2 = y2 - h2 / 2



"""

判断两个矩形的关系

如果任意一个矩形的左边界大于等于另一个矩形的右边界，或者上边界小于等于另一个矩形的下边界，则两个矩形相离。

如果一个矩形完全包含另一个矩形，则称为包含关系。这里判断了两种情况：一个矩形的左上角和右下角都在另一个矩形内部，或者一个矩形完全被另一个矩形包围。

如果两个矩形有部分重叠，则称为重叠关系。

"""

if left1 >= right2 or left2 >= right1 or top1 <= bottom2 or top2 <= bottom1:

    relation = "相离"

elif left1 <= left2 and right1 >= right2 and top1 >= top2 and bottom1 <= bottom2:

    relation = "包含"

elif left1 >= left2 and right1 <= right2 and top1 <= top2 and bottom1 >= bottom2:

    relation = "包含"

else:

    relation = "重叠"



# 输出结果

print(relation)

Test27

题目：

利用循环，寻找规律，打印如下数字模式：

分析：

"""

分析：循环的四要素：

1.循环的开始

2.循环的继续条件

3.循环体

4.循环的步长

"""

print("模式A:")

for n in range(1, 7):

    for i in range(1, n + 1):

        print(i, end = " ")

    print()

print("模式B:")

for n in range(1, 7):

    for i in range(1, 8 - n):

        print(i, end = " ")

    print()

print("=" * 12)

for n in range(6, 0, -1):

    for i in range(1, n + 1):

        print(i, end = " ")

    print()

"""

分析：

1.由于需要打印的有空格个数字，同时数字和空格的排序也有一定的重复性和规律

2.定义一个大的循环来进行行数的循环，然后把空格的循环和数字的循环分开进行定义

3.注意缩进，然后输出

"""

print("模式C:")

for n in range(1, 7):

    for k in range(6 - n):

        print(" ",end = " ")

    for i in range(n, 0, -1):

        print(i, end = " ")

    print()

print("模式D:")

for n in range(6, 0, -1):

    for k in range(6 - n):

        print(" ",end = " ")

    for i in range(1, n+1):

        print(i, end = " ")

    print()

Test28

题目：

利用循环，寻找规律，打印如下数字模式：

分析：

#打印数字

for n in range(1, 8): # 行数的循环

    for k in range(7 - n): #空格的数量是从6个到0个，找到规律后就去找怎么表达这个规律

        print(" ",end = " ")

    for x in range(1 - n, n): # 由于数值先降序后升序，这就像绝对值的函数，需要用到取绝对值的方法

       print(abs(x) + 1,end = " ")

    print()

Test29

题目：

利用循环，寻找规律，打印如下数字模式：

分析：

# 打印数字

for n in range(1, 8): # 循环7次，只有7行

    for k in range(7 - n): #空格的数量是从6个到0个，找到规律后就去找怎么表达这个规律

        print("  ",end = "  ")

    for x in range(1 - n, n): #由于是先升序后降序，也是需要有绝对值

        num = 2 ** (n - 1 - abs(x)) #输出的值是2的次幂

        print("%-2d" %num,end = "  ")

    print()

Test30

题目：

如下所示，是一个高度为9的菱形

分析：

# 打印菱形

num = eval(input("请输入一个奇数："))

for n in range(-(num // 2), num // 2 + 1): #把没有空格的那一行当作0行，从上到下为先负后正，再通过一个具体的数据来找规律

  i = abs(n) # 取n的绝对值

    for k in range(i):

        print("",end = " ")

    for x in range(num // 2 + 1 - i):

        print("*",end = " ")

    print()

Tset31

题目：

如下所示，是一个高度为9的菱形

分析：

根据30题的思路容易知道，把空格的位置和星星的位置加上一个

限制条件即可进行准确的打印

   if j <= i and i + j <= n + 1:

   if j == 1 or j == i or j + i == n + 1:

# 打印菱形 II

n = eval(input())

for i in range(1, n + 1):

    for k in range(abs(n // 2 + 1 - i )):

        print(" ", end = "")

    for j in range(1, i + 1):

        if j <= i and i + j <= n + 1:

            if j == 1 or j == i or j + i == n + 1:

                print("*", end = " ")

            else:

                print(" ", end = " ")

    print()

Tset32

题目：

如下所示，是一个高度为9的菱形

分析：

星星从上到下是先多后少，需要用到绝对值函数abs（）

同时星星的递增值（递减值）均为2

星星最多的值与输入的函数一致

#打印菱形 III

num = eval(input("请输入一个奇数："))

for n in range(-(num // 2), num // 2 + 1): #把没有空格的那一行当作0行，从上到下为先负后正，再通过一个具体的数据来找规律

    i = abs(n) # 取n的绝对值

    for k in range(i):

        print(" ",end = "")

    for x in range(num - 2 * i):

        print("*",end = "")

    print()

Tset33

题目：

计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同对于用户输入的数字，程序会提示它是过高还是过低

分析：

随机产生一个数值需要导入random库

import random

randnum = random.randint(0, 100) #随机产生一个0到99的整数来进行与用户输入的值进行比较

while True: #一直循环，知道出现break跳出循环

    usernum = eval(input())

    if usernum > randnum:

        print("高了")

    elif usernum < randnum:

        print("低了")

    else:

        print("恭喜你个傻逼")

        break

Tset34

题目：

输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8

分析：

最大的循环次数不难得知时两个正整数中最大值的一半，这样可以减少循环次数

因为要最大的公约数，所以最好是从大往小进行循环，一旦条件成立即可结束循环

#最大公约数 I

x, y = eval(input())

min_num = min(x, y)

for n in range(min_num, 0, -1):

    if x % n == 0 and y % n == 0:

        print(n)

        break

Tset35

题目：

一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、 6、8、9则不是

分析：

素数的判定需要除了1和它本身外，中间的值没有一个可以整除即为素数

所以中间值的循环需要全部完成，这个时候就需要一个标识物来证明全部循环结束

可以用到flag

#判断素数

x = eval(input("请输入一个大于1的正整数："))

flag = True

for n in range(2, x // 2 + 1):

    if x % n == 0:

        flag = False

        break

if flag:

    print("Yes")

else:

    print("No")

Tset36

题目：

输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15

分析：

若输入的两个值中间的值都没有公倍数，那么最小的公倍数即为两数之积

所以我们暂定最小公倍数为两数之积

然后进行遍历循环，当有值满足条件就进行重新赋值

# 最小公倍数

x, y = eval(input())

max_num = x * y

flag = True

for n in range(1, max_num + 1):

    if n % x == 0 and n % y == 0:

        flag = False

        break

print(n)

Tset37

题目：

输入一个正整数，然后找出它所有的最小因子，也称之为素因子

分析：

依次遍历进行整除判定

从小到大进行循环，只要满足即是最小因子

#整数的素因子

num = eval(input())

while num != 1: # 120 60 30 15 5

    for n in range(2, num + 1):

        if num % n == 0:

            print(n, end = " ")

            num = num // n

            break

Tset38

题目：

如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1

分析：

由于需要得到一个正整数除了它本身之外所有正因子的和，这里就需要用到循环

然后得到后进行相加和本身的值进行比较出结果

# 完全数

num = eval(input())

sum = 0

for i in range(1, num):

    if num % i == 0:

        sum += i

if sum == num:

    print("Yes")

else:

    print("No")

Tset39

题目：

打印前50个素数，每打印10个素数换行

分析：

跟求素数的逻辑是一样的

这里需要加个count来进行素数个数的累加

# 前50个素数

num = 2

count = 0

while count != 50:

    flag = True

    for i in range(2, int(num ** 0.5) + 1):

        if num % i == 0:

            flag = False

    if flag:

        print(num, end = "\t")

        count += 1

        if count % 10 == 0:

            print()

    num += 1

Tset40

题目：

你可以使用下面的数列近似计算π

pi = 4(1 - 1/3 + 1/5 - 1/7 + 1/9 -...-(-1) ** (i + 1)/(2i - 1)

当i越大时，计算结果越近似于π

分析：

根据公式进行输入值的多个计算即可

#计算π

k = eval(input("请输入需要计算的Π后面的小数位："))

pi = 0

for k in range(k + 1):

    pi +=  (-1) ** k / (2 * k + 1)  #((-1) ** (i + 1)) // (2 * i - 1)

pi = 4 * pi

print(pi)

Tset41

题目：

你可以使用下面的数列近似计算e

e = 1 + 1/ 1! + 1 / 2! + 1/3! +...+1/i!

当i越大时，计算结果越近似于e

分析：

和pi的计算相同

根据公式进行多次运算即可

#计算e

i = eval(input())

num = 0

e = 0

for n in range(1, i + 1):

    for fengmu in range(n, 0, -1):

        num += fengmu

    e += 1 / num

e += 1

print(e)

Tset42

题目：

延伸【Demo21剪刀石头布 I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者

分析：

把石头剪刀布的这个流程放到一个循环中

并规定结束循环的条件为计算机或者用户赢三次即可

# 剪刀石头布 II

import random

computer = 0

user = 0

while computer != 3 or user != 3:

    num = int(input("请输入0，1，2分别代表剪刀，石头，布:"))

    randomNum = random.randint(0,2)

    if randomNum == 0:

        print("计算机出的剪刀")

    elif randomNum == 1:

        print("计算机出的石头")

    else:

        print("计算机出的布")

    if num == 0:

        print("用户出的剪刀")

    elif num == 1:

        print("用户出的石头")

    else:

        print("用户出的布")

    if (randomNum == 0 and num == 2) or (randomNum == 1 and num == 0) or (randomNum == 2 and num == 1):

        print("计算机赢")

        computer += 1

    elif (num == 0 and randomNum == 2) or (num == 1 and randomNum == 0) or (num == 2 and randomNum == 1):

        print("用户赢")

        user += 1

    else:

        print("平局")

print("游戏结束")

Tset43

题目：

在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数注：组合（a，b）与组合（b，a）算同一种组合，只记录一次

分析：

按照正常思维都是从第一个开始，一个一个往后移动，

再移动前面的数值来进行多次遍历

#组合问题 I

count = 0

for x in range(1, 7):

    for y in range(x + 1, 8):

        print(f'({x},{y})')

        count += 1

print(count)

Tset44

题目：

有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？

分析：

由于是三位数，需要定义三个变量进行遍历

然后进行条件的限制，让其自行循环匹配即可

# 组合问题 II

count = 0

for i in range(1, 5):

    for j in range(1, 5):

        for k in range(1, 5):

            if i != j and j != k and i != k:

                num = i * 100 + j * 10 + k

                print(num)

                count += 1

print(count)

Tset45

题目：

水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如

153 = 1 ** 3 + 5 ** 3 + 3 ** 3

编写程序，输出所有的水仙花数

分析：

水仙花数的逻辑很简单

需要得到三位数的每一个位置的值然后进行公式判定即可

# 水仙花数

x = int(input("输入一个三位数，判断是否为水仙花数："))

ge = x % 10

shi = x % 100 // 10

bai = x // 100

if x == ge ** 3 + shi ** 3 + bai ** 3:

    print(f'{x}是水仙花数')

else:

    print("请重新输入")

Tset46

题目：

一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1， 1+1+2，2+2）

分析：

青蛙一次跳一个台阶或者两个台阶

后一次的跳法等于前两次的跳法之和

# 青蛙跳台阶

n = eval(input())

a = 1

b = 2

if n == 1 or n == 2: #当前项等于前两项的和，所以第一项和第二项需要先单独定义出来

    print(n)

for i in range(3, n + 1): #

    c = a + b

    a = b

    b = c

print(c)

Tset47

题目：

现有堆叠相加模式a + aa + aaa + aaaa + aaaaa + ....

例如：2 + 22 + 222 + 2222 + 22222，其中a为2，且有5组数字

分析：

# 堆叠相加

a, n = eval(input())

sum = 0

num = 0 #当n为第一项时，num等于0的定义可以防止越界

for i in range(n):

    num = num * 10 + a #当前项等于前一项×10再加上用户输入的个位数即可

    sum += num  

print(sum)

Tset48

题目：

输入一个十进制正整数，输出其二进制形式

分析：

由于十进制转二进制后，二进制的排版是余数从下到上，所以需要翻转拼接

先定义一个空的字符串等会用来进行余数的拼接

再通过翻转和强制转换达到效果

#十进制转二进制

x = int(input())

result = ''

while x != 0:

    num = x % 2

    x = x // 2

    result += str(num)

result = int(result[::-1])

print(result)

Tset49

题目：

输入一个二进制字符串，输出其对应的十进制数字

分析：

小进制转大进制的思路都一样

从右往左，位置的值乘上小进制的次幂（从0开始）

# 二进制转十进制

x = input("请输入一个二进制的数：")

mi = len(x)

sum = 0

for y in x:

    sum += int(y) * (2 ** (mi - 1))

    mi -= 1

print(sum)

Tset50

题目：

输入一个十进制正整数，输出其十六进制形式

分析：

十进制转十六进制比较特别，因为中间有字母

先定义一个十六进制所有元素的字符串

到时候再根据十进制转换后的值进行位置的取值

最后进行所有值的拼接

#十进制转十六进制

decimal_input = int(input("请输入一个十进制数: "))

hex_digits = "0123456789ABCDEF"

hex_output = ""

while decimal_input > 0:

    remainder = decimal_input % 16

    hex_digit = hex_digits[remainder]

    hex_output = hex_digit + hex_output

    decimal_input = decimal_input // 16

print(f"十进制数转换为十六进制为: {hex_output}")

Tset51

题目：

输入一个十六进制字符串，输出其对应的十进制数字

分析：

由于十六进制有大于9后的字母

所以要在遍历每个值后进行判断，

要是值大于9，需要进行ASCII码的转换，ord（）把字母转换成ascii码对应的数值

#十六进制转十进制

x = input("请输入一个十六进制的数：")

sum = 0

n = 0

for n in range(len(x) - 1, -1, -1): #根据十六进制的数的下标进行循环次数的选值

    if int(x[n], 16) >= 10:

        num = ord(x[n]) - ord('a') + 10

    else:

        num = int(x[n])

    sum += num * (16 ** (len(x) - 1 - n))

print(sum)

Tset52

题目：

给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写

分析：

# 最长公共前缀

s1 = input()

s2 = input()

s3 = ""

max_cishu = max(len(s1), len(s2))

i = 0

while i < max_cishu:  # 将while循环条件修正为i < max_cishu

    if i < len(s1) and i < len(s2) and s1[i] != s2[i]:  # 添加对索引越界的判断

        break

    s3 = s3 + s1[i]  # 将s1改为s1[i]，并且将字符串拼接改为取字符

    i += 1  # 每次循环结束后增加i的值

print(s3)

Tset53

题目：

给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配

分析：

判断s2在s1中出现的次数，首先s2需要短于s1

然后需要获取到s2的长度，在s1中一个一个与s2的值进行比较

#子串出现的次数

方法一：

flag = True

while flag == True:

    s1 = input()

    s2 = input()

    if len(s1) > len(s2):

        flag = False

    else:

        print("请重新输入：")

count = 0

for i in range(len(s1) - len(s2) + 1):

    if s1[i:i+len(s2)] == s2:

        count += 1

print(count)

方法二：

s1 = input()
s2 = input()
count = 0
i = 0
while i <= len(s1) - len(s2):
    if s1[i] == s2[0]:
        j = i + 1
        for k in range(1, len(s2)):
            if s1[j] != s2[k]:
                i += 1
                break
            j += 1
        else:     #在for循环完整完成后执行的语句
            i = j
            count += 1
    else:
        i += 1
print(count)

Tset54

题目：

给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写

分析：

这一题暂时不是很明白

#最长公共子串

方法一：

s1 = input()

s2 = input()

m = len(s1)

n = len(s2)

dp = [[0] * (n+1) for _ in range(m+1)]

max_len = 0

end_index = 0

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_len:

                max_len = dp[i][j]

                end_index = i

print(s1[end_index-max_len : end_index])

方法二：

s1 = input()
s2 = input()
length = len(s2)
while length > 0:
    left = 0
    right = length - 1
    while right < len(s2):
        if s2[left : right + 1] in s1:
            print(s2[left : right + 1])
            exit()
        left += 1
        right += 1
    length -= 1

Tset55

题目：

一些网站会给密码强加一些规则：

（1）密码必须至少有8个字符

（2）密码只能包含英文字母和数字

（3）密码应该至少包含两个数字

（4）密码应该至少包含两个大写字母

如果密码符合规则，输出Yes；否则输出No

分析：

# 检测密码

flag = True

passwad = input()

if len(passwad) < 8:

    flag = False

if not passwad.isalnum():  #isalnum(): 是字符串对象的一个方法，用于检查字符串中的字符是否全部为字母和数字。

    flag = False

if sum(c.isdigit() for c in passwad) < 2:  #c.isdigit()：这是一个字符串方法，用于检查一个字符是否为数字。

    flag = False

if sum(c.isupper() for c in passwad) < 2: #c.isupper()：这是一个字符串方法，用于检查一个字符是否为大写字母。

    flag = False

if flag:

    print("Yes")

else:

    print("No")

Tset56

题目：

回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数输出显示前100个回文素数，每行显示10个

分析：

跟判断素数的原理相同

只需要在if筛选语句中加入回文的判断即可

# 回文素数

num = 2

count = 0

while count != 100:

    flag = True

    for i in range(2, int(num ** 0.5) + 1):

        if num % i == 0 or str(num)[::-1] != str(num):

            flag = False

    if flag:

        print(num, end = "\t")

        count += 1

        if count % 10 == 0:

            print()

    num += 1

Tset57

题目：

反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数输出显示前100个反素数，每行显示10个

分析：

同理，只需要素数的判定以及不是回文数的判定

再进行一下正序和反序的比较，相同即可输出

# 反素数

num = 2

count = 0

while count != 100:

    flag = True

    for i in range(2, int(num ** 0.5) + 1):

        if num % i == 0 or str(num)[::-1] == str(num):

            flag = False

            break

    if flag:

        print(num, end = '\t')

        count += 1

        if count % 10 == 0:

            print()

    num += 1

Tset58

题目：

双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数输出显示小于1000的双素数

分析：

# 双素数

num = 0

while num <= 1000:

    flag = True  # 添加一个标志位用于判断是否为素数

    for i in range(2, int(num ** 0.5) + 1):

        if num % i == 0:

            flag = False  # 如果能整除，则不是素数，将标志位设为False

            break  # 跳出循环，不再进行后续判断

    if flag and num + 2 <= 1000:  # 判断当前数和当前数+2是否都为素数，并且不超过1000

        flag2 = True  # 添加一个标志位用于判断当前数+2是否为素数

        for j in range(2, int((num + 2) ** 0.5) + 1):

            if (num + 2) % j == 0:

                flag2 = False  # 如果能整除，则不是素数，将标志位设为False

                break  # 跳出循环，不再进行后续判断

        if flag2:

            print(f"{num} 和 {num + 2} 是双素数")

    num += 1

Tset59

题目：

如果一个素数可以写成 2 ** p -1输出p≤31的所有梅森素数的形式，其中p是某个正整数，那么这个素数就称作梅森素数

分析：

跟判定素数的原理是一样的

不过需要对num的取值进行一个范围的限制和判定

# 梅森素数

for p in range(2, 32):

    num = 2 ** p - 1

    flag = True

    for i in range(2, int(num ** 0.5) + 1):

        if num % i == 0:

            flag = False

            break

    if flag:

        print(num)

Tset60

题目：

有几种实现开平方的技术，其中一个称为巴比伦法它通过使用下面公式的反复计算近似地得到：

当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值 lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为 nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行编写代码，求解n的平方根的近似值

分析：

根据介绍和公式照着理解即可

#平方根的近似求法

n = eval(input())

lastGuess = 1

nextGuess = (lastGuess + n / lastGuess) / 2

while abs(lastGuess - nextGuess) > 0.0001:

    lastGuess = nextGuess

    nextGuess = (lastGuess + n / lastGuess) / 2

print(nextGuess)

关注

50
点赞
踩
47

收藏

觉得还不错? 一键收藏
1
评论
python编程练习

h = (days + math.floor(26 * (months + 1) // 10) + yesrs % 100 + math.floor((yesrs % 100) // 4) + math.floor((math.floor(yesrs // 100)) // 4) + 5 * math.floor(yesrs // 100)) % 7 #泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几。yesrs, months, days = eval(input()) #用户输入的年，月，日。
复制链接

扫一扫