Python第六次作业

最新推荐文章于 2024-05-14 11:00:23 发布

人工糖精

最新推荐文章于 2024-05-14 11:00:23 发布

阅读量1.2k

点赞数 10

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_73860010/article/details/134419859

版权

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

题目描述

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

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

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

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

celsius = int (input('请输入温度(摄氏度):'))
fahrenheit = ( 9 / 5 ) * celsius + 32
print('等于' + str(fahrenheit) + '华氏度')

Demo02 计算圆柱体的体积

题目描述

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

volume=area*length

输入输出描述

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

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

radius = float(input("请输入圆柱体的半径："))
length = float(input("请输入圆柱体的高："))
 
import math
pi = math.pi
 
area = radius * radius * pi
volume = area * length
 
print(f"圆柱体的底面积是:{area} , 圆柱体的体积是:{volume}")

Demo03 将英尺数转换为米数

题目描述

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

输入输出描述

输入一个数据表示英尺数

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

foot = float(input("请输入英尺："))
 
meter = foot * 0.305
 
print(f"对应米数为：{meter}")

Demo04 计算小费

题目描述

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

输入输出描述

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

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

a,b=map(float,input("请输入小计和酬金率（用空格隔开）：").split())
 
print(f"小费为：{a * b * 0.01}")
print(f"合计金额为：{a + a * b * 0.01}")

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

题目描述

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

输入输出描述

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

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

num = int(input("请输入一个整数(0-1000)："))
count = 0
 
if  0 >= num or num >= 1000:
    num = int(input("请重新输入一个整数(0-1000)："))
 
while num > 0:
    count += num % 10
    num //= 10 
 
print(f"各位数字之和为：{count}")

Demo06 计算年数和天数

题目描述

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

输入输出描述

输入一个分钟数

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

minute = int(input("请输入分钟数："))
 
year = minute // (60 * 24 * 365)
day = minute // (60 * 24 ) - year * 365
 
print(f"年数为：{year}")
print(f"天数为：{day}")

Demo07 计算能量

题目描述

水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：Q = M * (finalTemperature - initialTemperature) * 4184 这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计

输入输出描述

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

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

M = float(input("请输入水量(kg)："))
initialTemperature = float(input("请输入初始温度："))
finalTemperature = float(input("请输入最终温度："))
 
Q = M * (finalTemperature - initialTemperature) * 4184
 
print(f"所需能量值为:{Q}")

Demo08 分割数字

题目描述

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

输入输出描述

输入一个四位整数

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

num = int(input("请输入一个四位整数："))
 
if num < 1000 or num > 10000:
    num = int(input("请重新输入一个四位整数："))
 
a = num // 1000
b = num // 100 % 10
c = num // 10 % 10
d = num % 10
 
print(f"{d}\n{c}\n{b}\n{a}")

Demo09 计算三角形的面积

题目描述

输入三角形的三个顶点坐标，并计算其面积，计算公式如下s=(side1+side2+side3)/2 \\area = \sqrt{s(s-side1)(s-side2)(s-side3)}

输入输出描述

输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔

输出三角形的面积，结果保留一位小数

x1,y1,x2,y2,x3,y3 = map(float,input("请输入三角形的三个顶点坐标（用空格隔开）：").split())
 
side1 = (x1 ** 2 + y1 ** 2) ** 0.5
side2 = (x2 ** 2 + y2 ** 2) ** 0.5
side3 = (x3 ** 2 + y3 ** 2) ** 0.5
s = (side1 + side2 + side3) / 2
area = (s * (s - side1) * (s - side2) * (s - side3)) ** 0.5
 
print("三角形的面积为：", area)

Demo10 显示当前时间

题目描述

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

输入输出描述

输入时区，如东八区为8，西五区为-5

输出二十四小时制的时间，格式为时:分:秒

# 从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三个角的度数，结果保留两位小数

import math
 
x1, y1 = map(float, input("请输入第一个顶点的坐标，以空格分隔：").split())
x2, y2 = map(float, input("请输入第二个顶点的坐标，以空格分隔：").split())
x3, y3 = map(float, input("请输入第三个顶点的坐标，以空格分隔：").split())
 
side1 = math.sqrt( (x1-x2)**2+(y1-y2)**2)
side2 = math.sqrt((x2-x3)**2+(y2-y3)**2)
side3 = math.sqrt((x1-x3)**2+(y1-y3)**2)
 
cont1=math.acos((side1**2-side2**2-side3**2)/(-2*side2*side3))
cont2=math.acos((side2**2-side1**2-side3**2)/(-2*side1*side3))
cont3=math.acos((side3**2-side2**2-side1**2)/(-2*side1*side2))
 
angle_1=math.degrees(cont1)
angle_2=math.degrees(cont2)
angle_3=math.degrees(cont3)
 
print("%.2f\n%.2f\n%.2f\n"%(angle_1,angle_2,angle_3))

Demo12 最小数量的硬币

题目描述

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

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

输入输出描述

输入总金额

输出每种硬币的个数

money = float(input("请输入总金额："))
 
coin_one = int(money)
money = money - coin_one
coin_25j = int(money / 0.25)
money = money - coin_25j * 0.25
coin_1j = int(money / 0.1)
money = money - coin_1j * 0.01
coin_5f = int(money / 0.05)
money = money - coin_5f *0.05
coin_1f = int(money / 0.01)
 
print(f"一元硬币：{coin_one}个, 两角五分硬币：{coin_25j}个, 一角硬币：{coin_1j}个, 五分硬币：{coin_5f}个, 一分硬币：{coin_1f}个")

Demo13 正多边形的面积

题目描述

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

输入输出描述

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

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

import math
 
n = int(input("请输入正多边形的边数："))
s = float(input("请输入正多边形的边长："))
pi = math.pi
 
area = (n * s**2) / (4 * math.tan(pi/n))
print(f"面积为：{area}")

Demo14 计算身体质量指数

题目描述

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

BMI指数解读如下：

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

**输入输出描述**

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

输出BMI指数结果

weight ,high = map(float,input("请输入体重和身高（空格分隔）：").split())
 
BMI = weight/(high**2)
if BMI<18.5:
  print("超轻")
elif BMI<25.0:
  print("标准")
elif BMI<30.0:
  print("超重")
elif BMI>=30.0:
  print("肥胖")
else:
  print("输入错误")

Demo15 判定闰年

题目描述

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

输入输出描述

输入一个年份

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

year = int ( input('请输入年份:') )
 
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
    print('yes')
else :
    print('no')

Demo16 中彩票

题目描述

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

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

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

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

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

输入输出描述

输入一个两位数

输出两行，第一行输出那个随机产生的两位数，第二行输出用户的奖金

import random
 
input_num = int (input("输入："))
input_str =  str(input_num)
random_num = random.randint(10,100)
random_str = str(random_num)
print(random_num)
 
if input_num ==random_num:
  print("奖金为:10000")
elif random_str[0] ==  input_str[1] and random_str[1] == input_str[0]:
  print("奖金为:3000")
elif (random_str[0] == input_str[0] or random_str[0] == input_str[1])or(random_str[1] == input_str[0] or random_str[1] == input_str[1]) :
  print("奖金为:1000")
else:
  print("奖金为:0")

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三个数据，数据之间用空格分隔

两个解每行输出一个；一个解单行输出；无解则单行输出无实数解，保留两位小数

import math
 
a, b, c = map(float,input("请输入a, b, c(空格分隔):").split())
 
if a == 0 :
    print("输入错误")
 
elif b ** 2 - 4 * a * c > 0:
    r_1 = round((-b + math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
    r_2 = round((-b - math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
    print(r_1)
    print(r_2)
 
elif b ** 2 - 4 * a * c == 0:
    r = round((-b + math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
 
else:
    print("无实数解")

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的解，保留一位小数

# 解2×2线程方程
 
a,b,c,d,e,f = map(float,input("输入：").split())
# 前提：(ad - bc)不等于0
 
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(x,y)

Demo19 未来是周几

题目描述

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

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

**输入输出描述**

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

输出未来某天是星期几

# 未来是周几
 
 
week ,future_day = map(int ,input("输入：").split())
day = (week+future_day)%7
if day == 0:
  print("星期天") 
if day == 1:
  print("星期一") 
if day == 2:
  print("星期二") 
if day == 3:
  print("星期三") 
if day == 4:
  print("星期四") 
if day == 5:
  print("星期五") 
if day == 6:
  print("星期六")

Demo20 本年中的第几天

题目描述

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

输入输出描述

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

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

year,month,day = map(int,input("输入").split())
# 定义每月的天数表
month_day =[0,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[2] += 1 
  
for i in range(0 , month):
  day += month_day[i]
 
print(day)

Demo21 剪刀石头布I

题目描述

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

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

输入输出描述

输入数字0、1或2

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

import random
 
my = input('请输入(剪刀 = 1 、石头 = 2 、布 = 3):')
 
i = random.randint(1,4)
 
 
if my == i :
    print('平局')
    
if my == 1 :
    if i == 2:
        print('you=剪刀,电脑=石头')
        print('你输了')
    else:
        print('you=剪刀,电脑=布')
        print('你赢了')
    
if my == 2 :
    if i == 1:
        print('you=石头,电脑=剪刀')
        print('你赢了')
    else:
        print('you=石头,电脑=布')
        print('你输了')
    
if my == 3 :
    if i == 1:
        print('you=布,电脑=剪刀')
        print('你输了')
    else:
        print('you=布,电脑=石头')
        print('你赢了')

Demo22 三角形的周长

题目描述

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

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

输入输出描述

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

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

a , b , c = map(float,input("请输入三边边长：").split())
 
if a + b > c and b + c > a and a + c > b :
    print(f"三角形周长为：{a + b + c}")
else:
    print("非法输入")

Demo23 一周的星期几

题目描述

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

h=(q+⌊26(m+1)10⌋+k+⌊k4⌋+⌊j4⌋+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$为向下取整符号

**输入输出描述**

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

输出该日是周几

from calendar import *
def num_to_string(num):
    numbers={
        0:"日",1:"一",2:"二",3:"三",4:"四",5:"五",6:"六"
    }
    return numbers.get(num,None)
 
def weekday(y,m,d):
    monthDay1=[31,28,31,30,31,30,31,31,30,31,30,31]   
    days=0
    for i in range(1,y):
        if(isleap(i)):
            days=days+366
        else:
            days=days+365
    for j in range(1,m):
        if(j==2 and isleap(y)):    
            days=days+29
        else:          
            days=days+monthDay1[j-1]
    total_days=days+d
    xingqi=(total_days)%7   
    print("{0} 年 {1} 月 {2} 日是 星期{3}".format(y,m,d,num_to_string(int(xingqi)))) 
 
 
y=int(input("请输入年份:"))
m=int(input("请输入月份："))
d=int(input("请输入日期："))
 
if y<1 or m<1 or m>12 or d<1 or d>31: 
    print("输入错误！")
else:
    total=weekday(int(y),int(m),int(d))

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，否则输出两条直线平行

x1, y1 = map(float, input("请输入第一个顶点的坐标，以空格分隔：").split())
x2, y2 = map(float, input("请输入第二个顶点的坐标，以空格分隔：").split())
x3, y3 = map(float, input("请输入第三个顶点的坐标，以空格分隔：").split())
x4, y4 = map(float, input("请输入第三个顶点的坐标，以空格分隔：").split())
 
try:
#(y1 - y2)*x - (x1 - x2)*y == (y1 - y2)*x1 - (x1 - x2)*y1
#(y3 - y4)*x - (x3 - x4)*y == (y3 - y4)*x3 - (x3 - x4)*y3
    x = ( (x3-x4) * (  (y1 - y2)*x1 - (x1 - x2)*y1  ) - (x1 - x2) * ( (y3 - y4)*x3 - (x3 - x4)*y3 ) ) / (   (y1 - y2)*(x3 - x4) - (y3 - y4)*(x1 - x2)  )
    y = ( (y3-y4) * (  (y1 - y2)*x1 - (x1 - x2)*y1  ) - (y1 - y2) * ( (y3 - y4)*x3 - (x3 - x4)*y3 ) ) / (   (y1 - y2)*(x3 - x4) - (y3 - y4)*(x1 - x2)  )
except ZeroDivisionError:
    print("两直线平行")
else:
    print("直线的交点是：(",x,",",y,")")

Demo25 回文数

题目描述

输入一个三位整数，然后判断其是否为一个回文数

如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数

**输入输出描述**

输入一个数字

输出Yes表示是回文数，否则输出No

num = int (input("输入："))
temp =num
change_num =0
 
while num >0:
 change_num *= 10
 change_num += num%10
 num //= 10 
 
if temp == change_num:
  print("yes")
else:
  print("no")

Demo26 两个矩形

题目描述

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

**输入输出描述**

输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高

输出两者的关系

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---32 打印数字或图案

题目描述

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

#第一题
#             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
 
# 用户输入打印的行数
rows = int(input("输入"))
 
 
def print_num (row):
  for i in range(1,rows+1):
    print(" "*(row*2-2*i),end="")
    for j in range(i,0,-1):
      print(str(j)+" ",end="")
    for j in range(2,i+1):
      print(str(j)+" ",end="")
    print()  
 
 
print_num(rows)
 
 
#第二题
#         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
 
 
# 用户输入需要的层数
row = int(input("输入"))
 
 
def print_row (row):
  
  for i in range(1,row+1):
    print(" "*(row*2-2*i),end="")
    num = 1
    for j in range(1,i*2):
 
      if j<i:
        print(str(num)+" ",end="")
        num*=2
      else:
        print(str(num)+" ",end="")
        num = int(num/2)
    print()
 
    
print_row(row)
 
 
#空心菱形
#方法一
layer = int(input('请输入图案输出行数(奇数)：'))
p = 1
j = 1 
 
if layer % 2 == 0:
    layer = int(input('请输入图案输出行数(奇数)：'))
 
print(' '*(layer // 2 - p + 2) + '*')
while p <= layer//2:
    print(' '*(layer // 2 - p + 1) + '*' + ' '*(2 * p - 1) + '*')
    p += 1
p = 1
while p <= layer//2 - 1:
    print(' '*(p+1) + '*' + ' '*(layer - 2 * p - 2) + '*')
    p += 1
    j -= 1
p = 1
print(' '*(layer // 2 - p + 2) + '*')
 
#方法二
layer = int(input('请输入图案输出行数：'))
 
if layer % 2 == 0:
    while layer % 2 == 0:
        layer = int(input('请输入图案输出行数(奇数):'))
 
for i in range(1,(layer+1)//2):
    print(' ' * (layer - i),end='')
    for j in range(2 * i -1):
        if j == 0 or j == 2 * i - 2:
            print('*',end='')
        else:
            print(' ',end='')
    print()
 
for i in range((layer+1)//2,0,-1):
    print(' ' * (layer - i),end='')
    for j in range(2 * i -1):
        if j == 0 or j == 2 * i - 2 :
            print('*',end='')
        else:
            print(' ',end='')
    print()    
 
 
 
#实心菱形
#方法一
layer = int(input('请输入图案输出行数(奇数)：'))
p = 1
j = 1 
 
if layer % 2 == 0:
    while layer % 2 == 0:
        layer = int(input('请输入图案输出行数(奇数)：'))
 
while p <= layer/2:
    print( ' '*(layer // 2 - p + 1) + '*'*(2 * p - 1))
    p += 1
p = 0
while p <= layer:
    print(' '*p + '*'*(layer - 2 * p) )
    p += 1
    j -= 1
 
#方法二
layer = int(input('请输入图案输出行数：'))
 
if layer % 2 == 0:
    while layer % 2 == 0:
        layer = int(input('请输入图案输出行数(奇数):'))
 
for i in range(1,(layer + 1) // 2):
    print(' '*(layer - i) + '*'*(i * 2 - 1))
 
for i in range((layer + 1) // 2,0,-1):
    print(' '*(layer - i) + '*'*(2 * i - 1))

Demo33 猜数字

题目描述

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

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

**输入输出描述**

每次输入一个整数

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

import random
 
 
computer = random.randint(0,101)
person = int(input("输入"))
while computer != person:
  if computer>person:
    print("猜低了")
  else:
    print("猜高了")
  person = int(input("输入"))
print(f"恭喜你猜中了！ ：{person}")

Demo34 最大公约数I

题目描述

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

**输入输出描述**

输入两个数字

输出最大公约数

tmp = 0
x , y =map(int,input("请输入两个数字：").split())
 
def common_divisor(x,y) -> int:
    while ( y != 0):
        tmp = x % y
        x = y
        y = tmp
 
    return x
 
print(f"最大公约数是：{common_divisor(x,y)}")

Demo35 判断素数

题目描述

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

**输入输出描述**

输入一个大于1的正整数

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

import math
 
 
def prime(num):
  if num<2:
    return False
  else:
    for i in range(2,int(math.sqrt(num)+1)):
      if num % i == 0:  
        return False
    return True
 
 
num = int(input("输入"))
 
flag = prime(num)
if flag:
  print("yes")
else:
  print("no")

Demo36 最小公倍数

题目描述

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

输入输出描述

输入两个正整数

输出最小公倍数

x , y = map(int,input("请输入两个数字：").split())
 
 
def commom_multiples(x,y):
# 将大的数值赋值给tmp
    if x < y:
        tmp = y
    else:
        tmp = x
 
    while True :
        if tmp % x == 0 and tmp % y == 0:
            break
        tmp += 1
    
    return tmp
	
print(f"最小公倍数是:{commom_multiples(x,y)}")

Demo37 整数的素因子

题目描述

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

输入输出描述

输入一个正整数

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

def prime(num):
  arr=[]
  i = 2
  while i * i <= num :
    if num % i == 0:
      arr.append(i)
    else:
      i += 1
  if num > 1 :
    arr.append(num)
  return arr
 
 
num = int(input("输入"))
 
print(prime(num))

Demo38 完全数

题目描述

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

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

输入输出描述

输入一个正整数

输出该数是否为完全数

num = int(input("输入"))
 
 
def perfect_num (num):
  sum = 1
  for i in range (2,num // 2 + 1):
    if num % i == 0:
      sum += i
  if num == sum:
    return True
  else:
    return False
 
 
if perfect_num(num):
  print("yes")
else:
  print("no")

Demo39 前50个素数

题目描述

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

import math
 
 
arr = []
 
 
def prime_num (num):
  if num < 2:
    return False
  elif num == 2 or num == 3:
    return True
  elif num % 2 == 0 or num % 3 == 0:
    return False
  
  sqrt_num = int(math.sqrt(num))
  i = 1
  while 6 * i - 1 <= sqrt_num:
    if num%(6 * i - 1) ==  0 or num % (6 * i + 1) == 0:
      return False
    i += 1
  return True
 
 
num = 2
i = 1
while i <= 50:
  if prime_num(num):
    arr.append(num)
    i += 1
  num += 1
 
i = 1
while i <= 50:  
  print(str(arr[i-1]) + " " ,end=" ")
  if  i % 10 == 0:
    print()
  i += 1

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越大时，计算结果越近似于π

j = 1
sum = 0
 
for i in range(10000):  
    if (i + 1) % 2 == 0:
        j = -(2 * (i + 1) - 1)
    else:
        j = (2 * (i + 1) - 1)
    n = 4 / j
    sum = sum + n
    
print(sum)

Demo41 计算e

题目描述

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

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

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

import math
 
def calc_e(n):
    e = 1
    for i in range(1, n+1):
        e += 1 / math.factorial(i)
    return e
 
print(calc_e(1000))

Demo42 剪刀石头布II

题目描述

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

import random
 
count_use = 0
count_com = 0
 
while True:
  use_num = int( input("输入："))
  com_num = random.randint(0,2)
 
  def change(num):
    if num ==0:
      return " 剪刀"
    elif num == 1:
      return " 石头"
    elif num ==2:
      return " 布"
    else :
      return 0
      
 
  if change(use_num)==0 :
    print("输入不合法")
    continue
    
  else:
    print("计算机输出" + change(com_num))
    print("用户出的" + change(use_num))
  
    if com_num == use_num:
        print("平手")
    elif (com_num == 1 and use_num == 0) or (com_num == 0 and use_num == 2) or (com_num == 2 and use_num == 1):
        count_com += 1
        print("计算机赢"+str(count_com)+"回")
      
    else:
        count_use += 1
        print("用户赢了" + str(count_use) + "回")
      
    if count_use == 3:
        print("用户获得了胜利")
        break
    elif count_com == 3:
        print("电脑获得了胜利")
        break

Demo43 组合问题I

题目描述

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

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

count = 0
 
for i in range(1,7):
  for j in range(i + 1,8):
    if i != j  :
      print(f"({i} , {j})",end="")
      count +=1
 
print()
print(f"共有{count}个组合")

Demo44 组合问题II

题目描述

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

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:
                count+=1
                print(f'{i}{j}{k}',end=" ")
print()
print(f'一共有{count}个')

Demo45 水仙花数

题目描述

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

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

# 打印输出标准水仙花数，输出这些水仙花数
num = 100
while num >= 100 and num < 1000:
    a = num // 100         # a得到百位的
    b = (num // 10) % 10   # b得到十位的
    c = num % 10           # c得到个位的
    if num == a ** 3 + b ** 3 + c ** 3:
        print(num,end=' ')
    num += 1

Demo46 青蛙跳台阶

题目描述

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

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

def get_staircase(n:int) -> int:
    if n == 1 or n == 2:
        return n
    return get_staircase(n - 1) + get_staircase(n - 2)
 
 
n = int(input("请输入台阶数："))
print(get_staircase(n))

Demo47 堆叠相加

题目描述

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

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

**输入输出描述**

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

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

num , group = map(int ,input("输入数字和组数:").split())
 
 
def get_num(num,group):
  sum = 0
  for i in range(1,group+1): 
    sum += int(str(num)*i)
  return sum
  
 
print(get_num(num,group))

Demo48 十进制转二进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出二进制字符串

num = int(input('请输入一个正整数：'))
i = 0
count = ''
num_1 = 0
num_0 = 0
 
while num > 0 :
    i = num % 2
    num //= 2
    if i == 1:
        num_1 += 1
    if i == 0:
        num_0 += 1
    count += str(i)
    
j = 0
for j in range(-1,-len(count)-1,-1):
    print(count[j],end='')

Demo49 二进制转十进制

题目描述

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

输入输出描述

输入一个二进制字符串

输出十进制数字

num = int(input('请输入一个二进制数：'))
 
 
def num_turn_d(num):
  all = 0
  str_num = str(num)
  for i in range(0,len(str_num)):
    all += int(str_num[i])
    if i == len(str_num)-1: 
      return all
    all *= 2 
 
 
 
print(num_turn_d(num))

Demo50 十进制转十六进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出十六进制字符串

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 十六进制转十进制

题目描述

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

输入输出描述

输入一个十六进制字符串

输出十进制数字

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

输出前缀串

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中出现的次数

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

输出最长公共子串

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

**输入输出描述**

输入一串密码

输出该密码是否符合规则

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个

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
 
 
# 判断回文数
def is_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
 
 
 
# 反转
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)/

当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))

人工糖精

关注

10
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Python第六次作业

输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）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分别表示三边对应的角。四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）直线A上的两个点是(x1,y1)和(x2,y2)，直线B上的两个点是(x3,y3)和(x4,y4)
复制链接

扫一扫