python作业（md文档）

Augenblick@

已于 2023-12-04 18:37:48 修改

阅读量139

点赞数

文章标签： python 算法数学建模

于 2023-11-16 12:29:54 首次发布

本文链接：https://blog.csdn.net/zmh_zpp/article/details/134437265

版权

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

题目描述

输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出

转换的公式为如下：
fahrenheit=(9/5)*celsius+32

输入输出描述

输入一个值表示摄氏温度celsius

输出华氏温度fahrenheit ，结果保留一位小数点

celsius = int(input("请输入摄氏温度："))
fahrenheit = (9/5) * celsius + 32
print("0.1f"%fahrenheit)

Demo02 计算圆柱体的体积

题目描述

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

volume=area*length

输入输出描述

分别输入圆柱的半径radius和高度length，两个数据之间用空格分隔

输出两行，第一行为圆柱底面积area，第二行为圆柱体积volume，结果保留两位小数点

radius = float(input("请输入圆柱的半径:"))
length = float(input("请输入圆柱的高:"))
PI = 3.14
area = radius * radius * PI
volume = area * length
print(area)
print(volume)

Demo03 将英尺数转换为米数

题目描述

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

输入输出描述

输入一个数据表示英尺数

输出转换后的米数，结果保留四位小数点

a = float(input("请输入英尺数："))
M = 0.305 * a
print("%.4f"%M)

Demo04 计算小费

题目描述

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

输入输出描述

分别输入小计和酬金率，两个数据用之间用空格分隔

输出两行，第一行为小费，第二行为合计金额，结果保留两位小数

print("输入：")
num1, num2= input().split()
print("输出：")
print("%.2f"%(float(num1) *  float(num2) / 100))
print("%.2f"%(float(num1) + float(num1) *  float(num2) / 100))

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

题目描述

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

输入输出描述

输入一个[0,1000]之间的整数

输出该数字的各位数字之和

示例1

输入：

999

输出：

27

解释：

999各位数之和为9 + 9 + 9 = 27

示例2

输入：

12

输出：

3

num = int(input("请输入一个[1,1000]的整数："))
a = num // 100
b = num % 100 // 10
c = num % 10
d = a + b + c
print(d)

Demo06 计算年数和天数

题目描述

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

输入输出描述

输入一个分钟数

输出两行，第一行为年数，第二行为天数

示例

输入：

1000000000

输出：

1902

214

num = int(input("输入一个分钟数："))
a = num // (365 * 24 * 60)
b = num // (24 * 60) - a * 365
print(a)
print(b)

Demo07 计算能量

题目描述

水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：
Q = M * (finalTemperature - initialTemperature) * 4184

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

输入输出描述

输入三行数据，第一行输入水量，第二行输入初始温度，第三行输入最终温度

输出所需的能量值，结果保留一位小数

示例

输入：

55.5

3.5

10.5

输出：

1625484.0

M = float(input("请输入水量："))
initialTemperature = float(input("请输入初始温度："))
finalTemperature = float(input("请输入最终温度："))
Q =  M * (finalTemperature - initialTemperature) * 4184
print("%0.1f"%Q)

Demo08 分割数字

题目描述

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

输入输出描述

输入一个四位整数

输出四行，第一行为个位，第二行为十位，第三行为百位，第四行为千位

示例

输入：

5213

输出：

3

1

2

5

num = int(input("输入一个四位数："))
a = num // 1000
b = num % 1000 // 100
c = num % 1000 % 100 //10
d = num % 10
print("输出：")
print(d)
print(c)
print(b)
print(a)

Demo09 计算三角形的面积

题目描述

输入三角形的三个顶点坐标，并计算其面积，计算公式如下
s=(side1+side2+side3)/2 \\ area = \sqrt{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] = map(float,input().split())
side1 = math.sqrt((x1-x2)**2+(y1-y2)**2)
side2 = math.sqrt((x1-x3)**2+(y1-y3)**2)
side3 = math.sqrt((x2-x3)**2+(y2-y3)**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

# 从datetime模块导入datetime类和timedelta类(表示时间间隔)
from datetime import datetime,timedelta
place = int(input("请输入时区："))
# 获取当前时间
now = datetime.now()
# 将时间格式化为字符串
time_8= now.strftime("%H:%M:%S")
 
if place == 8:
  print(time_8)
elif place == -5:
  # 修改时间（将小时加11）
  modified_time = now +timedelta(hours=11) 
  time_5= modified_time.strftime("%H:%M:%S")
  print(time_5)
else:
  print("输入有误重新输入")

Demo11 计算三角形的三个角

题目描述

输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
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] = map(float,input().split())
a = math.sqrt((x1-x2)**2+(y1-y2)**2)
b  = math.sqrt((x1-x3)**2+(y1-y3)**2)
c = math.sqrt((x2-x3)**2+(y2-y3)**2)
A = math.acos((b*b+c*c-a*a)/(-2*b*c))
B = math.acos((a*a+c*c-b*b)/(-2*a*c))
C = math.acos((a*a+b*b-c*c)/(-2*a*b))
print("%0.2f"%A)
print("%0.2f"%B)
print("%0.2f"%C)

Demo12 最小数量的硬币

题目描述

假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币

输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少

输入输出描述

输入总金额

输出每种硬币的个数

示例

输入：

11.56

输出：

11个一元硬币

2个两角五分硬币

0个一角硬币

1个五分硬币

1个一分硬币

num = float(input("请输入总金额："))
a = num //1
b = num % 1 // 0.25
c = num % 1 % 0.25 // 0.1
d = num % 1 % 0.25 % 0.1 // 0.05
e = num % 1 % 0.25 % 0.1 % 0.05 // 0.01
print('%d个一元硬币'%(a))
print('%d个两角五分硬币'%(b))
print('%d个一角硬币'%(c))
print('%d个五分硬币'%(d))
print('%d个一分硬币'%(e))

Demo13 正多边形的面积

题目描述

正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：
area = \frac{n*s^2}{4*tan(\frac{π}{n})}

输入输出描述

输入两个数据分别表示边的个数n和边的长度s，数据之间用空格分隔

输出边长为s的正n多边形的面积，结果保留两位小数

示例

输入：

5 6.5

输出：

72.69

import math
s =float(input("边的长度："))
n =int(input("边的个数："))
area = n*s**2/4*math.tan(math.pi/n)
print(area)

Demo14 计算身体质量指数

题目描述

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

BMI指数解读如下：

BMI	解释
BMI ＜ 18.5	超轻
18.5 ≤ BMI ＜ 25.0	标准
25.0 ≤ BMI ＜ 30.0	超重
30.0 ≤ BMI	肥胖

输入输出描述

输入体重和身高，数据之间用空格分隔

输出BMI指数结果

示例

输入：

60 1.8

输出：

标准

shengao=float(input("请输入身高："))
tizhong=float(input("请输入体重："))
BIM=tizhong/shengao**2
if BIM<18.5:
    print("过轻")
elif 18.5<=BIM<24:
    print("正常")
elif 24<=BIM<27:
    print("过重")
elif 27<=BIM<30:
    print("轻度肥胖")
elif 30<=BIM<35:
    print("中度肥胖")
elif BIM>=35:
    print("重度肥胖")

Demo15 判定闰年

题目描述

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

输入输出描述

输入一个年份

输出Yes表示该年份为闰年，No则表示不是闰年

示例1

输入：

2008

输出：

Yes

示例2

输入：

2002

输出：

No

year=int(input("请输入年份："))
if year%400==0 or year%4==0:
    print("yes")
else:
    print("no")

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 fun(user_num):
    num = random.randint(10,100)
    print(num)
    a = num // 10 
    b = num % 10
    c = user_num // 10 
    d = user_num % 10
    if user_num == num:
        print("10000")
    elif a == d and b ==c:
        print("3000")
    elif a == d or a == c or b == d or b ==c:
        print("1000")
    else:
        print("0")


user_num = int(input("用户输入的数："))
fun(user_num)

Demo17 解一元二次方程

题目描述

一元二次方程$ax^2+bx+c=0 (a != 0)$的解可以使用下面的公式计算
r_1=\frac{-b+\sqrt{b^2-4ac}}{2a},r_2=\frac{-b-\sqrt{b^2-4ac}}{2a}

其中$b^2-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 fun(a,b,c):
    d = b ** 2 - 4 * a * c
    if d > 0:
        r1 = (-b+math.sqrt(b**2-4*a*c))/2*a
        r2 = (-b-math.sqrt(b**2-4*a*c))/2*a
        print("%0.2f"%r1)
        print("%0.2f"%r2)
    elif d == 0:
        r = (-b+math.sqrt(b**2-4*a*c))/2*a
        print("%0.2f"%r)
    else:
        print("无实数解")


[a,b,c] = map(float,input().split())
fun(a,b,c)

Demo18 解2×2线程方程

题目描述

如有一个2×2的线程方程组：
ax+by=e \\ cx+dy=f

你可以使用克莱姆法则解该线性方程：
x=\frac{ed-bf}{ad-bc},y=\frac{af-ec}{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

输出：

无解

[a,b,c,d,e,f] = map(float,input().split())
def jiefangcheng(a,b,c,d,e,f):
    if a *d - b * c != 0:
        x = (e*d-b*f)/(a*d-b*c)
        y = (a*f-e*c)/(a*d-b*c)
        print(x)
        print(y)
    else:
        print("无解")


jiefangcheng(a,b,c,d,e,f)

Demo19 未来是周几

题目描述

输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）

并输入今天之后到未来某天的天数，然后输出该天是星期几

输入输出描述

输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔

输出未来某天是星期几

示例1

输入：

1 3

输出：

星期四

示例2

输入：

0 31

输出：

星期三

[a,b] = map(int,input().split())
def week_time(a,b):
    c = a + b
    if c % 7 == 0:
        print("星期天")
    elif c % 7 == 1:
        print("星期一")
    elif c % 7 == 2:
        print("星期二")
    elif c % 7 == 3:
        print("星期三")
    elif c % 7 == 4:
        print("星期四")
    elif c % 7 == 5:
        print("星期五")
    elif c % 7 == 6:
        print("星期六")


[a,b] = map(int,input().split())
week_time(a,b)

Demo20 本年中的第几天

题目描述

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

输入输出描述

输入三个数据分别表示年、月、日，数据之间用空格分隔

输出该日是今年中的第几天

示例1

输入：

2023 1 28

输出：

28

示例2

输入：

2023 3 2

输出：

61

def year_day(year,mouth,day):
    leap_year = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    no_leap_year = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        a = sum(leap_year[0:mouth-1]) +day
    else:
        a = sum(no_leap_year[0:mouth-1]) + day
    print(a)


[year,mouth,day] = map(int,input().split())
year_day(year,mouth,day)

Demo21 剪刀石头布I

题目描述

计算机随机产生一个数字0、1和2分别表示剪刀、石头和布

用户输入数字0、1或2，输出用户赢、计算机赢或平局

输入输出描述

输入数字0、1或2

输出有三行，第一行输出计算机出的啥，第二行输出用户出的啥，第三行输出结果

示例1

输入：

0

输出：

计算机出的石头

用户出的剪刀

计算机赢

示例2

输入：

1

输出：

计算机出的剪刀

用户出的石头

用户赢

示例3

输入：

2

输出：

计算机出的布

用户出的布

平局

import random
def caiquan(a):
    if a == 0:
        if b == 0:
            print("计算机出的剪刀")
            print("用户出的剪刀")
            print("平局")
        elif b == 1:
            print("计算机出的剪刀")
            print("用户出的石头")
            print("用户赢")
        elif b == 2:
            print("计算机出的剪刀")
            print("用户出的布")
            print("计算机赢")
    if a == 1:
        if b == 0:
            print("计算机出的石头")
            print("用户出的剪刀")
            print("计算机赢")
        elif b == 1:
            print("计算机出的石头")
            print("用户出的石头")
            print("平局")
        elif b == 2:
            print("计算机出的石头")
            print("用户出的布")
            print("用户赢")
    if a == 2:
        if b == 0:
            print("计算机出的布")
            print("用户出的剪刀")
            print("用户赢")
        elif b == 1:
            print("计算机出的布")
            print("用户出的石头")
            print("计算机赢")
        elif b == 2:
            print("计算机出的布")
            print("用户出的布")
            print("平局")



a = random.randint(0,2)
b = int(input("用户输入一个数:"))
caiquan(a)

Demo22 三角形的周长

题目描述

输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法

如果任意两边之和大于第三边则输入都是合法的

输入输出描述

输入三个数据表示三边，数据之间用空格分隔

输出三角形的周长，如果非法则输出非法

示例1

输入：

1 1 1

输出：

3

示例2

输入：

1 3 1

输出：

非法

def Triangle_area(a,b,c):
    a,b,c = [int(i) for i in [a,b,c]]
    if a + b > c and a + c > b and b + c > a:
        d = a+b+c
        print(d)
    else:
        print("非法")


a,b,c = input("输入三边：").split()
Triangle_area(a,b,c)

Demo23 一周的星期几

题目描述

泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：
h=(q+\lfloor\frac{26(m+1)}{10}\rfloor+k+\lfloor\frac{k}{4}\rfloor+\lfloor\frac{j}{4}\rfloor+5j) \% 7

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

（2）$q$是一个月的哪一天

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

（4）$j$是世纪数，即$\lfloor\frac{year}{100}\rfloor$

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

（6）$\lfloor\rfloor$为向下取整符号

输入输出描述

输入年、月、日三个数据，数据之间用空格分隔

输出该日是周几

示例1

输入：

2013 1 25

输出：

星期五

示例2

输入：

2012 5 12

输出：

星期六

import math
def week_day(year,mouth,day):
    if mouth == 1:
        mouth = 13
        year = year - 1
    elif mouth == 2:
        mouth = 2 
        year = year - 1
    j = math.floor((year / 100))
    k = year % 100
    q = day
    m = mouth
    h = (q+math.floor(26*(m+1)/10)+k+math.floor(k/4)+math.floor(j/4)+5*j)%7

    if h == 0:
        print("星期六")
    elif h == 1:
        print("星期天")
    elif h == 2:
        print("星期一")
    elif h == 3:
        print("星期二")
    elif h == 4:
        print("星期三")
    elif h == 5:
        print("星期四")
    else:
        print("星期五")

[year,mouth,day]=map(int,input().split())
week_day(year,mouth,day)

Demo24 直线的交点

题目描述

直线A上的两个点是$(x1,y1)$和$(x2,y2)$，直线B上的两个点是$(x3,y3)$和$(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
$$

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

输入输出描述

输入八个数据，分别为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 plalindrome_number(num):
#     a = num // 100
#     b = num % 100 // 10
#     c = num % 10
#     if a == c:
#         print("yes")
#     else:
#         print("no")


# num = int(input("输入："))
# plalindrome_number(num)


def plalindrome_number(num : str):
    b = num[::-1]
    if num == b:
        print("yes")
    else:
        print("no")


num = str(input("输入："))
plalindrome_number(num)

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

输出：

相离

x1,y1,w1,h1 = map(float ,input("输入：").split())
x2,y2,w2,h2 = map(float ,input("输入：").split())
 
#求水平距离和垂直距离
level =abs(x1-x2) 
vertical = abs(y1-y2)
 
# 判断：
if level < (w1+w2)/2 and vertical<(h1+h2)/2:
# 包含：如果两个矩形的中心点之间的水平距离小于两个矩形宽度之和的一半，并且垂直距离小于两个矩形高度之和的一半，则两个矩形相交。  
  print("包含")
elif level<abs(w1-w2) and vertical<abs(h1-h2):
# 重叠： 如果一个矩形的中心点到另一个矩形的中心点的水平距离小于两个矩形宽度之差的一半，并且垂直距离小于两个矩形高度之差的一半
  print("重叠")
else:
  print("相离")

第二部分循环语句

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 mode_A():
    for i in range(1,7):
        for j in range(i):
            print(j+1,end='')
        print()


def mode_B():
    for i in range(6,0,-1):
        for j in range(i):
            print(j+1,end='')
        print()



mode_A()
mode_B()

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

layer = int(input("请输入您想打印的金子塔的层数(1-15):"))
for i in range(1,layer+1):
	print(" "*(15-i),end="")
	border_num = i
	while border_num >= 1:
		print(border_num,end="") 
		border_num -= 1
	border_num += 2
	while border_num <= i:
		print(border_num,end="")
		border_num += 1
	print()

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

layer = int(input("请输入您想打印的金子塔的层数(1-15):"))
for i in range(1,layer+1):
	print(" "*(15-i),end="")
	border_num = i
	while border_num >= 1:
		print(border_num,end="") 
		border_num -= 1
	border_num += 2
	while border_num <= i:
		print(border_num,end="")
		border_num += 1
	print()

Demo30 打印菱形I

题目描述

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

    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：
  *
 * *
* * *
 * *
  *

layer = int(input("请输入层数："))
while layer & 1 == 0:
	layer = int(input("层数必须是奇数层！"))

for i in range(1, layer//2 + 2):
	print(" "* (layer - i), end="")
	print("*"* (2*i - 1))

for i in range(layer//2, 0, -1):
	print(" "* (layer - i), end="")
	print("*"* (2*i - 1))

Demo31 打印菱形II

题目描述

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

    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：
  *
 * *
*   *
 * *
  *

layer = int(input("输入打印行数："))
for i in range(1, (layer // 2 + 2)):
    for j in range(layer - i):
        print(" ", end="")
    for j in range(2 * i - 1):       
        if j == 0 or j == 2 * i - 2:
            print("*", end="") 
        else:
            print(" ", end="")
    print()

Demo32 打印菱形III

题目描述

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

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：
  *
 ***
*****
 ***
  *

layer = int(input("请输入层数："))
while layer & 1 == 0:
	layer = int(input("层数必须是奇数层！"))

for i in range(1, layer//2 + 2):
	print(" "* (layer - i), end="")
	print("*"* (2*i - 1))

for i in range(layer//2, 0, -1):
	print(" "* (layer - i), end="")
	print("*"* (2*i - 1))

Demo33 猜数字

题目描述

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

对于用户输入的数字，程序会提示它是过高还是过低

输入输出描述

每次输入一个整数

每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束

示例

输入：50

输出：高了

输入：25

输出：低了

输入：42

输出：高了

输入：39

输出：猜中了！答案就是39

import random
def number_cai():
    num = random.randint(0,100)
    i = 0
    while True:
        user_num = int(input("输入："))
        i += 1
        if user_num > num:
            print("高了")
            
        elif user_num < num:
            print("低了")
            
        elif user_num == num:
            print(f"猜中了！答案就是{user_num}")
            break



number_cai()

Demo34 最大公约数I

题目描述

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

输入输出描述

输入两个数字

输出最大公约数

示例1

输入：

16 24

输出：

8

示例2

输入：

7 3

输出：

1

def common_divisor(x , y):
    _gcd = 1
    if x > y:
        smaller = y
    else:
        smaller = x
    for i in range(1, smaller + 1):
        if (x % i == 0) and (y % i == 0):
            _gcd = i
    print(_gcd) 


[x,y] = map(int,input().split())
common_divisor(x , y)

Demo35 判断素数

题目描述

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

输入输出描述

输入一个大于1的正整数

输出Yes表示该数字是素数，否则输出No

示例1

输入：

9

输出：

No

示例2

输入：

11

输出：

Yes

def prime_number(num):
    flag = True
    for i in range(2,num):
        if num % i == 0:
            flag = False
            break
    if flag == True:
        print("Yes")
    else:
        print("No")
        

num = int(input("输入:"))
prime_number(num)

Demo36 最小公倍数

题目描述

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

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

def lcm(x, y):
    
    greater = max(x,y)
    while True:
        if (greater % x == 0) and (greater % y == 0):
            _lcm = greater
            break
        greater += 1
    print(_lcm)


[x,y] = map(int,input().split())
lcm(x,y)

Demo37 整数的素因子

题目描述

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

输入输出描述

输入一个正整数

输出多行，每行输出一个素因子

示例1

输入：

120

输出：

2 2 2 3 5

解释：

2 * 2 * 2 *3 * 5 = 120

示例2

输入：

100

输出：

2 2 5 5

def prime_factor(num):
    list = []
    i = 2 
    while i * i < num:
        if num % i :
            i += 1
        else:
            num //= i
            list.append(i)
    if num > 1:
        list.append(num)
    print(list)
    

num = int(input("输入:"))
prime_factor(num)

Demo38 完全数

题目描述

如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数

例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

def Perfect_number(num):
    list = []
    for i in range(1,num):
        if num % i == 0:
            list.append(i)
    if sum(list) == num:
        print("Yes")
    else:
        print("No")


num = int(input("输入:"))
Perfect_number(num)

Demo39 前50个素数

题目描述

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

def isprime(number): #判断一个数是否为素数#
    div=2
    while div<=number/2:
        if number%div==0:
            return False
        div+=1
    return True

def PrintPrinme(numberOfPrime):  #打印前五十个素数，每十个换行打印
    number_Of_Primes=50
    number_Of_Primes_Per_Line=10
    count=0
    number=2
    while count<numberOfPrime:
        if isprime(number):
            count+=1
            print(number,end=" ")
            if count%number_Of_Primes_Per_Line==0:
                print()
        number+=1

def main():
    print("前五十个素数为：")
    PrintPrinme(50)

main()

Demo40 计算π

题目描述

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

$$
π=4(1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\frac{1}{11}+...+\frac{(-1)^{i+1}}{2i-1})
$$

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

def pi_one(n):
    s= 0
    flag=True

    for i in range(1,n+1,2):
        if flag:
            s += 1 / i
            flag = False
        else:
            s -= 1 / i
            flag = True

    print('pi的近似值是', 4*s, sep='')


n=int(input('请输入正整数n：'))
pi_one(n)

Demo41 计算e

题目描述

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

$$
e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!}
$$

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

def e_count(n):
    e=1
    divisor=1
    for i in range(1,n+1):
        divisor *= i
        e=e+1/divisor
    print(e)


n=eval(input())
e_count(n)

Demo42 剪刀石头布II

题目描述

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

import random
computer = random.randint(0,2)
usr_sum = 0
com_sum = 0
while True:
	user = int(input("剪刀(0),石头(1)，布(2):"))
	if user - computer == -1 or user - computer == 2:
		com_sum += 1
		if com_sum >= 2:
			print("电脑胜")
			choice=input("是否继续(Y/N):")
			if choice == 'Y' or choice== 'y':
				user = int(input("剪刀(0),石头(1)，布(2):"))
			else:
				break
	elif user - computer == -2 or user - computer == 1:
		usr_sum += 1
		if usr_sum >= 2:
			print("玩家胜")
			choice=input("是否继续(Y/N):")
			if choice == 'Y' or choice== 'y':
				user = int(input("剪刀(0),石头(1)，布(2):"))
			else:
				break

Demo43 组合问题I

题目描述

在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数

注：组合（a，b）与组合（b，a）算同一种组合，只记录一次

def combination_number2():
    list01 = []
    list02 = []
    count = 0
    nums = [1,2,3,4,5,6,7]
    for i in nums:
        for j in nums:
            if i != j :
                count += 1
                list01.append((i,j))

    print(list01)
    print(count)


combination_number2()

Demo44 组合问题II

题目描述

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

nums = [1,2,3,4]
def combination_number(nums:list):
    count = 0
    for i in nums:
        for j in nums:
            for k in nums:
                if i != j and i != k and j != k:
                    count += 1
                    a = i * 100 + j * 10 + k 
                    print(a, end=" ")
                    if count % 10 == 0:
                        print()
    print()                   
    print(count)
                    


combination_number(nums)

Demo45 水仙花数

题目描述

水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$

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

def fun():
    for i in range(100,1000):
        a = i // 100
        b = i % 100//10
        c = i % 10
        if a**3 + b**3 + c**3 == i:
            print(i)

fun()

Demo46 青蛙跳台阶

题目描述

一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？

例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）

def jump(n):
    if n==1:
        return 1
    if n==2:
        return 2
    else:
        return jump(n-1) + jump(n-2)
print(jump(5))

Demo47 堆叠相加

题目描述

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

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

输入输出描述

输入两个数据分别为数字a和组数n

输出按照堆叠相加模式算出的和

示例

输入：

3 4

输出：

3702

解释：

3 + 33 + 333 + 3333 = 3702

def Stacking_adding(a,n):
    sum = 0
    for i in range(1,n+1): 
        sum += int(str(a)*i)
    print(sum)


a,n = map(int,input().split())
Stacking_adding(a,n)

Demo48 十进制转二进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出二进制字符串

示例

输入：

9

输出：

1001

num = int(input("输入十进制数："))
def Decimal_binary(num):
    i = 0
    count = ''
    while num > 0:
        a = num % 2 
        num //= 2
        count += str(a)
        i += 1
    count1 = count[::-1]
    print(count1)
        



Decimal_binary(num)

Demo49 二进制转十进制

题目描述

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

输入输出描述

输入一个二进制字符串

输出十进制数字

示例

输入：

1001

输出：

9

num = str(input("输入二进制字符串："))
def Binary_decimal(num:str):
    count = num[::-1]
    a = 0
    for i in range(1,len(count)+1):
        a += int(count[i-1]) * 2 ** (len(count)-i)
    print(a)


Binary_decimal(num)

Demo50 十进制转十六进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出十六进制字符串

示例

输入：

1233321

输出：

1e1b9

num = int(input("请输入一个正整数："))
 
 
def change_num(num):
  ox_num = "0123456789ABCDEF"
  fin_num = ""
  while num > 0:
    get_num = num % 16
    num //= 16
    fin_num = ox_num[get_num] + fin_num  
  return fin_num
 
 
print(change_num(num))

Demo51 十六进制转十进制

题目描述

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

输入输出描述

输入一个十六进制字符串

输出十进制数字

示例

输入：

1e1b9

输出：

123321

num = str(input("请输入一个十六进制的数："))
 
 
def change_num(num):
  ox_num = "0123456789abcdef"
  all = 0
  len_num = len(num)
  for j in num:
    for i in ox_num:
      if i == j:
        all += ox_num.index(i)* 16 ** (len_num-1)
        len_num -= 1
  return all
  
 
print(change_num(num))

Demo52 最长公共前缀

题目描述

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

输入输出描述

输入两行，分别表示s1和s2

输出前缀串

示例

输入：

abcdefg

abcdhko

输出：

abcd

str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
 
def find_lcs(str1,str2):
    lcs=set()
    if len(str1)>len(str2):
        str1,str2=str2,str1
 
    for i in range(len(str1),0,-1):
        flag=False
        for j in range(len(str1)-i+1):
            s=str1[j:i+j]
            if str2.find(s)>-1:
                lcs.add(s)
                flag=True
            else:
                flag=False    
        if flag:
            break             
    print("最长公共子串为：",lcs)   
 
find_lcs(str1,str2)

Demo53 子串出现的次数

题目描述

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

输入输出描述

输入两行字符串，分别为s1和s2，s2的长度小于等于s1

输出s2在s1中出现的次数

示例1

输入：

ABCsdABsadABCasdhjabcsaABCasd

ABC

输出：

3

示例2

输入：

AAAAAAAA

AAA

输出：

2

str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
 
 
def count_occurrences(s1, s2):
    count = 0
    i = 0
    while i < len(s1):
        if s1[i:i+len(s2)] == s2:
            count += 1
            i += len(s2)
        else:
            i += 1
    return count
 
print(count_occurrences(str1,str2))

Demo54 最长公共子串

题目描述

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

输入输出描述

输入两行字符串，分别为s1和s2

输出最长公共子串

示例

输入：

123ABCDEFG83hsad

iughABCDEFG23uy

输出：

ABCDEFG

str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
 
def find_lcs(str1,str2):
    lcs=set()
    if len(str1)>len(str2):
        str1,str2=str2,str1
 
    for i in range(len(str1),0,-1):
        flag=False
        for j in range(len(str1)-i+1):
            s=str1[j:i+j]
            if str2.find(s)>-1:
                lcs.add(s)
                flag=True
            else:
                flag=False    
        if flag:
            break             
    print("最长公共子串为：",lcs)   
 
find_lcs(str1,str2)

Demo55 检测密码

题目描述

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

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

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

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

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

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

输入输出描述

输入一串密码

输出该密码是否符合规则

示例1

输入：

123456ab

输出：

No

示例2

输入：

123abcABC

输出：

Yes

s1 = str(input("输入"))
 
 
def string_pass(s1):
  get_num = 0
  get_capital = 0
  if len(s1)<8:
    return "no"
  for i in s1:
    if ord(i)<48 or 57<ord(i)<65 or 90<ord(i)< 96 or ord(i)>122:
      return "no"
    if 47<ord(i)<58:
      get_num += 1
    if 64<ord(i)<91:
      get_capital += 1
  if get_num < 2:
    return "no"
  if get_capital< 2:
    return "no"
  return "yes"
 
 
print(string_pass(s1))

Demo56 回文素数

题目描述

回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数

输出显示前100个回文素数，每行显示10个

import math
 
 
# 判断素数
def find_prime(num):
  if num < 2 :
    return False
  if num == 2 or num == 3:
    return True
  elif num % 2 == 0:
    return False
  elif num % 3 == 0:
    return False
  
  sqrt = int(math.sqrt(num))
  i = 1
  while (6*i-1) < sqrt :
    if num % (6*i-1) == 0 or num % (6*i+1) == 0:
      return False
    i += 1
  else:
      return True
  
 
# 判断回文数
def find_palindromic(num):
  str_num = str(num)
  i = 0
  j = len(str_num)-1
  while i < j:
    if str_num[i] != str_num[j]:
      return False
    i += 1
    j -= 1
  return True  
 
i = 100
count = 0
while count < 100:
  if find_prime(i) and find_palindromic(i):
    print(str(i) +" ",end="")
    count += 1
    if count % 10 == 0:
      print()
  i += 1

Demo57 反素数

题目描述

反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数

输出显示前100个反素数，每行显示10个

 j = len(str_num)-1
  while i < j:
    if str_num[i] != str_num[j]:
      return False
    i += 1
    j -= 1
  return True
 
 
 
# 反转
def get_sort_num(num):
  str_num = str(num)
  reversed_str =  str_num[::-1]
  return int(reversed_str)
 
count = 0
i = 17
while count < 100:
  if is_prime(i) and is_prime(get_sort_num(i))  and not is_palindromic(i):
    print (str(i)+" ",end="")
    count += 1
    if count % 10 == 0:
      print()
  i += 1

Demo58 双素数

题目描述

双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数

输出显示小于1000的双素数

import math
 
 
# 判断质数
def is_prime(num):
  if num<2:
    return False
  if num == 2 or num ==3:
    return True
  if num % 2 == 0 or num % 3 == 0:
    return False
  
  sqrt_num =int(math.sqrt(num))
  k = 1
  while (6*k-1)<sqrt_num:
    if num % (6*k-1) == 0 or num % (6*k+1) == 0:
      return False
    k += 1
  return True
 
 
i = 1
while i+2 < 1000:
  if is_prime(i):
    if is_prime(i+2):
      print(f"[{i},{i+2}] ",end="")
  i += 2

Demo59 梅森素数

如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数

输出p≤31的所有梅森素数

def is_prime(p):
    for i in range(2, p // 2 + 1):
        if p % i == 0:
            return False
    return True
 
 
def is_prime_range(start, end):
    arr = []
    b = []
    for p in range(start, end + 1):
        if is_prime(p):
            arr.append(p)
    for p in arr:
        b.append(2 ** (p - 1))
    print(b)
 
 
res = is_prime_range(2, 31)
print(res)

Demo60 平方根的近似求法

有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法

它通过使用下面公式的反复计算近似地得到：

$$
nextGuess=(lastGuess+n/lasetGuess)/2
$$

当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值

lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行

编写代码，求解n的平方根的近似值

def square_root(n):
    lastGuess = n / 2
    for i in range(20):
        nextGuess =(1 / 2) * (lastGuess + (n / lastGuess))
        lastGuess = nextGuess
    return nextGuess
 
 
print(square_root(6))

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 gread_fun(nums:list, a):
    best = max(nums)
    for i in range(0,a):
        if nums[i] >= best - 10 :
            print(f"学生{i}分数为{nums[i]},等级为A")
        elif nums[i] >= best -20 :
            print(f"学生{i}分数为{nums[i]},等级为B")
        elif nums[i] >= best - 30 :
            print(f"学生{i}分数为{nums[i]},等级为C")
        elif nums[i] >= best - 40 :
            print(f"学生{i}分数为{nums[i]},等级为D")
        else:
            print(f"学生{i}分数为{nums[i]},等级为F")


a = int(input("输入："))
nums = [int(s)for s in input().split()]
gread_fun(nums, a)

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次

list=[int(s)for s in input().split()]
list.sort()  # 将列表进行排序
sum=[]#定义一个用来记录每个数出现次数的列表
for i in range(101):
    sum.append(0)#对sum列表进行初始化
for i in range(len(list)):#对列表list进行遍历
    sum[list[i]]+=1#对于出现的数字i，他的计数数组sum[i]+1
t=list[-1]#对列表list进行去重
for i in range(len(list)-2,-1,-1):
    if t==list[i]:
        list .remove(list[i])
    else :
        t=list[i]
for i in range(101):#从0到100遍历
    if sum[i] >= 2:#当数字i出现的次数大于等于2时
        print(i,"出现",sum[i],"次")
    elif sum[i]==1:#当数字i只出现一次时
        print(i,"出现 1 次")

Demo63 打印不同的数

题目描述

读入n个数字，并显示互不相同的数（即一个数出现多次，但仅显示一次），数组包含的都是不同的数

输入输出描述

输入两行，第一行为数字的个数n，第二行为n个数字

输出数组，包含的都是不同的数

示例

输入：

10

1 2 3 2 1 6 3 4 5 2

输出：

1 2 3 6 4 5

def fun(num , a):
    nums = []
    len(nums) <= a
    for i in num:
        if i not in nums:
            nums.append(i)
    for b in nums:
        print(f"输出:{b}, end=" "")

        


a = int(input("输入:"))
num = list(int(s)for s in input().split())
fun(num , a)

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 common_divisor(numbers:list):
    if len(numbers) < 2:
        return None
    result = numbers[0]
    for i in range(1, len(numbers)):
        result = gcd(result, numbers[i])
    print(result)




numbers = list(int(s)for s in input().split())
common_divisor(numbers)

Demo65 打乱数组

题目描述

编程程序，对给定的数组进行随机打乱，并输出打乱后的结果

import random
def random_arr(nums:list):
    random.shuffle(nums)
    print(nums)


nums = list(int(s)for s in input().split())
random_arr(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():
    T = int(input()) # 输入测试数据组数
    for _ in range(T): 
        n = int(input()) # 输入数组长度
        arr = list(map(int, input().split())) # 输入数组元素
        if len(arr) != n:
            print("NO")
            continue
        min_val, max_val = min(arr), max(arr)
        if (arr == list(range(min_val, max_val + 1)) or arr == list(range(max_val, min_val - 1, -1))):
            print("YES")
        else:
            print("NO")


decreasing_array()

Demo67 相似词

题目描述

输入两个英文单词，判断其是否为相似词，所谓相似词是指两个单词包含相同的字母

输入输出描述

输入两行，分别表示两个单词

输出结果，为相似词输出YES，否则输出NO

示例

输入：

listen

silent

输出：

YES

def are_similar(word1, word2):
    # 将两个单词转换为集合，方便进行字母比较
    set1 = set(word1)
    set2 = set(word2)

    # 如果两个集合的长度相等，并且它们的交集不为空，那么这两个单词就是相似词
    if len(set1) == len(set2) and len(set1.intersection(set2)) > 0:
        return "YES"
    else:
        return "NO"

# 从用户那里获取两个单词
word1 = input("请输入第一个单词：")
word2 = input("请输入第二个单词：")

# 判断这两个单词是否相似
print(are_similar(word1, word2))

Demo68 豆机器

题目描述

豆机器，也称为梅花或高尔顿盒子，它是一个统计实验的设备，它是由一个三角形直立板和均匀分布的钉子构成，如下图所示：

小球从板子的开口处落下，每次小球碰到钉子，它就是50%的可能掉到左边或者右边，最终小球就堆积在板子底部的槽内

编程程序模拟豆机器，提示用户输入小球的个数以及机器的槽数，打印每个球的路径模拟它的下落，然后打印每个槽子中小球的个数

输入输出描述

输入两个数据，分别表示小球个数和槽子的个数

输出每个小球经过的路径，和最终每个槽子里小球的个数（因为牵扯随机数，程序结果不唯一，示例仅用于表明题意）

示例

输入：

5 8

输出：

LRLRLRR

RRLLLRR

LLRLLRR

RRLLLLL

LRLRRLR

0 0 1 1 3 0 0 0

import random

def drop_ball(ball_num, slot_num):
    # 初始化槽子，每个槽子中小球数量为0
    slots = [0] * slot_num
    # 记录每个小球的下落路径
    paths = []
    
    for ball in range(ball_num):
        # 随机选择一个槽子
        slot = random.randint(0, slot_num - 1)
        # 记录小球下落的路径
        paths.append(slot)
        # 在槽子中增加一个小球
        slots[slot] += 1
    
    # 打印每个槽子中小球的个数
    for i, slot in enumerate(slots):
        print(f'槽子 {i+1}: {slot} 个球')
    
    # 打印每个小球经过的路径
    print('每个小球经过的路径：')
    for ball, path in enumerate(paths):
        print(f'小球 {ball+1}: 槽子 {path}')

# 调用函数，输入小球个数和槽子个数
drop_ball(map(int,input().split()))

Demo69 更衣室难题

题目描述

一个学校有100个更衣室和100个学生。所有的更衣室在开学第一天都是锁着的。随着学生进入，第一个学生表示为S1，打开每个更衣室；然后第二个学生S2，从第二个更衣室开始，用L2表示，关闭所有其他更衣室；学生S3从第三个更衣室L3开始，改变每三个更衣室（如果打开则关闭，如果关闭则打开）；学生S4从更衣室L4开始，改变每四个更衣室；学生S5开始从更衣室L5开始，改变每五个更衣室。依次类推，直到学生S100改变L100。

在所有学生都经过了操作后，哪些更衣室是打开的？编程找出答案。

def door():
    temp_door = [False for i in range(100)]
    for s in range(1, 101):
        for l in range(s, 100, s + 1):
            if s == 1:
                temp_door[l - 1] = not temp_door[l - 1]
            elif s == 2:
                temp_door = [False for i in temp_door]
                temp_door[1] = True
            else:
                temp_door[l - 1] = not temp_door[l - 1]
    return temp_door
 
 
def pri(arr):
   
    door_id = []
    for i in range(100):
        if arr[i]:
            door_id.append(i + 1)
    return door_id
 
 
if __name__ == '__main__':
    print(f"还开着的门有：{pri(door())}")

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)


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$，第二个区间所有元素$==A_0$，第三个区间所有元素$>A_0$

例如数组[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))