Python123 练习7

1. 梯形法计算积分值

计算函数曲线与x轴包围的面积,计算函数曲线在区间(a,b)与x轴包围的面积，可将这个区域平行于y轴切分成相等宽度的小梯形，每个梯形的面积可近似求出，所有梯形面积的和就是函数曲线与x轴包围的面积，也就是函数在给定区间的积分值，dx越小，梯形近似度越高，计算结果越精确，也就是说区间切分段的越多，结果越精确。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬
参考下图，计算函数sin(x)在区间(a,b)与x轴包围的面积，a,b由用户输入，区间切分多少段也由用户输入。

1. 输入格式: 第一行是由空格分隔的两个实数，代表积分区间‪‬‪‬‪‬。‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬第二行是一个正整数，代表切分数量
2. 输出格式: 积分值，结果保留2位小数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬

方法

import math
a, b = map(float, input().split())   
c = int(input()) 
d = (b - a) / c   # 梯形的高度
s = 0
for i in range(c):
    x = math.fabs(math.sin(a))   # 梯形上底，绝对值保证为正数
    a += d
    y = math.fabs(math.sin(a))   # 梯形下底，绝对值保证为正数
    z = (x + y)*d/2      # 单个梯形面积
    s += z    # 所有梯形面积总和
print('{:.2f}'.format(s))

2. 哥德巴赫猜想

数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。

1. 输入格式:输入在一行中给出一个(2, 2 000 000 000]范围内的偶数N。
2. 输出格式:在一行中按照格式“N = p + q”输出N的素数分解，其中p ≤ q均为素数。又因为这样的分解不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。

方法1 函数模块化

def isprime(num):  # 判断是否为素数
    if num == 1:
        return False
    elif num == 2:
        return True
    else:
        for i in range(1, num):
            if num % i == 0:
                y = i
        if y == 1:
            return True


def list_prime(num):  # 将比输入数小的所有素数合并成列表
    a = []
    for i in range(1, num + 1):
        if isprime(i):
            a.append(i)
    return a


def check(num):  # 检查所有可能的两个素数组合
    global b1
    b1 = []
    global b2
    b2 = []
    c = list_prime(num)
    for i in c:
        for j in c:
            if i + j == num:
                b1.append(i)
                b2.append(j)
    return b1 and b2


def begin():   # 按要求输出
    num = eval(input())
    list_prime(num)
    check(num)
    p = b1[0]
    q = b2[0]
    print('N = {} + {}'.format(p, q))


begin()

方法2一般形式

num = eval(input())
a = []
for i in range(2, num):  # 将输入数范围内的所有素数加入列表
    if i == 2:
        a.append(i)
    else:
        for j in range(1, i):    # 判断是否为素数
            if i % j == 0:
                y = j
        if y == 1:
            a.append(i)
b1 = []
b2 = []
for k in a:     # 检查所有可能的两个素数组合
    for z in a:
        if k + z == num:
            b1.append(k)
            b2.append(z)
p = b1[0]   # 按要求输出
q = b2[0] 
print('N = {} + {}'.format(p, q))

3. 鸡兔同笼B

一个笼子里面关了若干只鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外），已经知道了笼子里面脚的总数feets，则笼子里至少有多少只动物，至多有多少只动物？
输入格式: 第一行输入一个正整数，表示测试数据的组数n。接下来的n行，每行一个整数，代表脚的数量。
输出格式：输出包含n行，每行对应一个输入，包含两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数间用一个空格分开，如果没有满足要求的答案，则输出用空格分隔的两个0。

方法

def result(x):    # 函数模块化，参数为脚的数量
    if x >= 4:    # 当脚小于4时不可能有兔子
        a = x // 4   # 兔子数量最大值
        b = x // 2   # 鸡的数量最大值
        c = []
        for i in range(0, a + 1):
            for j in range(0, b + 1):
                if 4 * i + 2 * j == x:
                    z = i + j
                    c.append(z)
                if i == a and b == j and c == []:
                    print('0 0')
        if c:
            c.sort()
            result_min = c[0]
            result_max = c[-1]
            print('{} {}'.format(result_min, result_max))
    else:
        if x == 2:
            print('1 1')
        else:
            print('0 0')
            

def input_n(num): # 通过组数，确定需要输入的几行，并计算动物数量
    t = 0
    while t < num:
        x = int(input())
        result(x)
        t = t + 1


num = eval(input())  # 获取组数
input_n(num)

4. 与7无关的数

一个正整数，如果它能被7整除，或者它的十进制表示法中某一位的数字为7，则称其为与7相关的数
求所有小于n(n < 100)的与7无关的正整数以及他们的平方和。
输入格式:输入为一个正整数。
输出格式:第一行为所有与7无关的数，以列表形式输出，逗号分开。第二行为他们的平方和。

方法

num = eval(input())
x = []
y = []
for i in range(1,num):     # 小于输入n的所有整数列表
    x.append(i)
for j in range(1,num):     # 遍历每一个整数
    if j % 7 == 0:         # 若能整除7，加入与7相关的数的列表
        y.append(j)
    else:                  # 若不能整除7，再判断是否有一位是7
        if j % 10 == 7:    # 个位
            y.append(j)
        elif j // 10 == 7: # 十位，数小于100，仅需检测到十位
            y.append(j)
for k in y:     # 将所有整数列表中的所有与7相关的数移除
    x.remove(k)
x.sort()    # 列表升序排序
result = 0 
for l in x:   # 遍历所有与7无关的数，并递归相加所有值
    result += l*l
print(x)   #打印结果
print(result)

5. 完美立方数

费马大定理断言，当整数n > 2时，关于a,b,c的方程a ** n = b ** n + c ** n 没有正整数解。该定理被提出来后，历经三百多年，经历多人猜想辩证，最终在1995年被英国数学家安德鲁.怀尔斯证明。
当然，可以找到大于1的4个整数满足完美立方等式： a * *3 = b ** 3 + c ** 3 + d ** 3 (例如12 ** 3 = 6 ** 3 + 8 ** 3 + 10 ** 3)
编写一个程序，对于任意给定的正整数N（N<=100），寻找所有的四元组（a,b,c,d），满足a ** 3 = b ** 3 + c ** 3 + d ** 3.其中 1 < a,b,c,d <=N.

1. 输入格式:正整数N(N <= 100)
2. 输出格式:按照a的值从小到大，每行输出一个完美立方等式，其中b,c,d按照非降序排列输出。若两个完美立方式中a值相同，则b值小的先输出；在b值相等的情况下，c值小的先输出，在b,c都相等的情况下，d值小的先输出。

方法

x = int(input())
for a in range(2,x+1):    # 根据题目条件，限定每一个数的范围，去除重复
    for b in range(2,a):
        for c in range(b,a):
            for d in range(c,a):
                if pow(a,3) == pow(b,3)+pow(c,3)+pow(d,3):  # 满足完美立方数条件的数
                    print("Cube = {},Triple = ({},{},{})".format(a,b,c,d))

6. 高次方程求根

有函数
$f(x)=x^5-15x^4+85x^3-225x^2+274x-121$
已知f(1.5)>0,f(2.4)<0，且在[1.5,2.4]区间只且只有一个根，求该根。要求四舍五入到小数点后6位
输出格式:该方程在[1.5,2.4]区间的根,精确到小数点后6位

方法

def f(x):   # 封装 高次方程带入求值 的函数
    result = pow(x, 5) - 15 * pow(x, 4) + 85 * pow(x, 3) - 225 * pow(x, 2) + 274 * x - 121
    return result

a = 1.5
b = 2.4
c = (a + b) / 2          # 浮点型不可能完全等于零
while abs(f(c)) > 1e-6:  # 所以为了判断需要，根据题目一个范围1e-6，即10的-6次方
    if f(a) * f(c) < 0:  # 若abs(f(c))精度超过6时的值，都当作等于0；
        b = c            # 通过二分法计算、缩减范围
    else:
        a = c
    c = (a + b) / 2
print("{:.6f}".format(c))

如果文章内容或代码有问题，或者其他问题，可以评论或者私信