矿大python学习通实验4-2

"""文章来源地址https://www.toymoban.com/news/detail-857638.html

1.实验4-6 编写程序，求出1～n之间（包含1和n，n是小于等于1000的正整数，

从键盘输入）的所有完数。所谓完数，是指一个数恰好等于它的所有因子（包括1但不包括本身）之和。

例如，6的因子为1、2、3，6=1+2+3，因而6是完数。

要求：一行输出一个完数。

【运行示例】

输入：1000

输出：

6

28

496

"""

def perfectNum(n):

    # 初始化一个空列表，用于存储完数

    perfect_numbers = []

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

        factorsSum = 0

        for i in range(1, num):

            # 如果i是num的因子（即num能被i整除）

            if num % i == 0:

                factorsSum += i

        # 如果因子之和等于num，说明num是完数，将其添加到完数列表中

        if factorsSum == num:

            perfect_numbers.append(num)

    # 返回包含所有完数的列表（关键）

    return perfect_numbers

n = int(input())

if 1 <= n <= 1000:

    # 隔行打印出列表中所有完数

    for perfect_number in perfectNum(n):

        print(perfect_number)

# or

n = int(input())

if 1 <= n <= 1000:

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

        sumFactors = 0

        for i in range(1, num):

            if num % i == 0:

                sumFactors += i

        if sumFactors == num:

            print(num)

"""

2.实验4-7 编写程序，找出1～n之间（包含1和n，n是小于等于1000的正整数，

从键盘输入）的全部同构数。所谓同构数，是这样一种数，它出现在它的平方数的右端。

例如，5的平方是25，5是25右端的数，5就是同构数，25也是一个同构数，其平方是625。

要求：一行输出一个同构数。

【运行示例】

输入：1000

输出：

1

5

6

25

76

376

625

"""

def is_isomo(n):

    # 核心部分

    """

    表达式 str(n*n)[-len(str(n)):] == str(n) 用于检查一个数 n 是否是同构数。

    -len(str(n))：从 n 的平方的字符串表示的末尾向前数 len(str(n)) 个字符的位置,

    len(str(n))表示n的位数。这个操作是为了截取平方数中与原始数 n 相同长度的部分。

    str(n*n)[-len(str(n))]：获取 n 的平方的字符串表示中最后 len(str(n)) 个字符。

    """

    return str(n*n)[-len(str(n)):] == str(n)

n = int(input())

if 1 <= n <= 1000:

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

        if is_isomo(i):

            print(i)

# or

n = int(input())

if 1 <= n <= 1000:

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

        if str(num) == str(num**2)[-len(str(num)):]:

            print(num)

"""

3.实验4-8 编写程序，求n以内（不包含n）的所有素数之和。

其中，n是一个大于2的正整数，从键盘输入。

【运行示例】

输入：100

输出：1060

"""

# 类似python123上作业

def is_prime(num):

    if num <= 1:

        return False

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

        if num % i == 0:

            return False

    return True

n = int(input())

if n > 2:

    prime_sum = 0

    for num in range(2, n):

        if is_prime(num):

            prime_sum += num

    print(prime_sum)

"""

4.实验4-9 编程求出所有小于或等于n（n是小于等于50的正整数，从键盘输入）的自然数对及对数。

自然数对是指两个自然数的和与差都是平方数，如8和17的和25(8+17)与其差9(17-8)都是平方数，

则8和17称为自然数对，且8和17、17和8算一对，只算8和17。

提示：判断正整数N是否是平方数，可用关系表达式math.sqrt(N)==int(math.sqrt(N))来判断。

【输出提示】print(n,"以内的自然数对有：",sep="") print("自然数对共有",num,"对。",sep='')

【运行示例】

输入：50

输出：

50以内的自然数对有：

4 5

6 10

8 17

10 26

12 13

12 37

14 50

16 20

20 29

24 25

24 40

30 34

36 45

40 41

自然数对共有14对。

"""

# 第一个方案太啰嗦也不美观，建议二

import math

n = int(input())

if 1 <= n <= 50:

    num_of_pairs = 0

    pairs = []

    for i in range(1, n):

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

            sum_ij = i + j

            diff_ij = j - i

            if math.sqrt(sum_ij)==int(math.sqrt(sum_ij))and int(math.sqrt(diff_ij)) == math.sqrt(diff_ij):

                pairs.append((i, j))

                num_of_pairs += 1

    print(n, "以内的自然数对有：",sep='')

    for pair in pairs:

        print(pair[0], pair[1])

    print("自然数对共有", num_of_pairs, "对。",sep='')

# or

def is_square(num):

    import math

    # 把重复的判断弄成函数，减少重复

    return math.sqrt(num) == int(math.sqrt(num))

n = int(input())

num = 0

print(n,"以内的自然数对有：",sep="")

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

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

        if is_square(i+j) and is_square(abs(i-j)):

            print(i, j)

            num += 1

print("自然数对共有",num,"对。",sep='')

"""

5.实验4-10 有算式ABCD-CDC=ABC，其中A、B、C、D均为一位非负整数，

编写程序，求A、B、C、D的值。

提示：可以用一重循环，也可以用四重循环。

【运行示例】

输出：A=1 B=0 C=9 D=8

"""

# 四重循环，暴力算

for A in range(10): # A可以是0到9之间的任何数

    for B in range(10): # B也可以是0到9之间的任何数

        for C in range(10): # C同样可以是0到9之间的任何数

            for D in range(10):

                if (A * 1000 + B * 100 + C * 10 + D) - (C * 100 + D * 10 + C) == (A * 100 + B * 10 + C) and A!=B!=C!=D:

                    print("A={} B={} C={} D={}".format(A,B,C,D))

# 一重循环

loop = []

for ABCD in range(1000, 10000):

    A = ABCD // 1000

    B = (ABCD // 100) % 10

    C = (ABCD // 10) % 10

    D = ABCD % 10

    CDC = 100 * C + 10 * D + C

    ABC = 100 * A + 10 * B + C

    # 核心就是loop.append()这里

    if ABCD - CDC == ABC:

        loop.append((A, B, C, D))

for solution in loop:

    A, B, C, D = solution

    print("A={} B={} C={} D={}".format(A,B,C,D))

"""

6.实验4-11 用枚举法解决“鸡兔同笼”问题。

已知在同一个笼子里有鸡和兔共M只，鸡和兔的总脚数为N只，求鸡和兔各有多少只

（允许鸡或兔为0只）。

要求：对输入的数据要考虑下面两个条件。

① 输入的总脚数N必须是偶数，否则输出“输入的脚数为奇数，不合理！”；

② 若求出的只数是负数，则输出“求出的只数为负，输入的数据不合理！”

【运行示例1】

输入：

19

44

输出：鸡有16只，兔有3只

【运行示例2】

输入：

20

45

输出：输入的脚数为奇数，不合理！

【运行示例3】

输入：

100

50

输出：求出的只数为负，输入的数据不合理！

"""

def solve(M, N):

    if N % 2 != 0:

        return "输入的脚数为奇数，不合理！"

    # 枚举所有可能的鸡的数量

    for chickens in range(M + 1):

        # 计算兔子的数量

        rabbits = M - chickens

        # 计算总脚数

        totalFeet = 2 * chickens + 4 * rabbits

        # 如果总脚数等于N，则返回结果

        if totalFeet == N:

            return f"鸡有{chickens}只，兔有{rabbits}只"

    # 如果没有找到符合条件的鸡和兔的数量，说明输入数据不合理

    return "求出的只数为负，输入的数据不合理！"

# 从键盘输入总头数M和总脚数N

M = int(input())

N = int(input())

# 输出结果(没有这一句就打印不出内容)

print(solve(M, N))

"""

7.实验4-12 有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和，

编写程序，求该数列从第几项开始，其数值超过M(M是大于等于2000的整数，从键盘输入)。

【运行示例】

输入：2000

输出：

数列从第14项开始，数值超过2000。

第14项的值为2632

"""

def sequenceNum(M):

    # 初始化设置数列的前三项

    sequence = [1, 2, 3]

    # 初始化项数

    index = 3 # 我们从第四项开始计算

    # 当数列的当前项小于M时，继续计算下一项

    while sequence[-1] < M:

        next1 = sequence[-1] + sequence[-2] + sequence[-3]

        # 将新计算的项添加到数列中

        sequence.append(next1)

        # 增加项数,计数君

        index += 1

    # 返回超过M的项数和该项的值

    return index, sequence[-1]

M = int(input())

if M < 2000:

    print("输入的数不满足条件，请输入大于等于2000的整数。")

else:

    startIndex, value = sequenceNum(M)

    print("数列从第{}项开始，数值超过{}。".format(startIndex,M))

    print("第{}项的值为{}。".format(startIndex,value))

"""

8.实验4-13 利用格里高利公式求圆周率π的近似值：

π/4 = 1 - 1/3 + 1/5 - 1/7 +…

直到最后一项的绝对值小于eps（eps是一个非常小的数，从键盘输入，如0.000001）时，停止计算。

注意：绝对值小于eps的那一项不计算在结果内。

【运行示例】

输入：0.000001

输出：近似值为:3.141590653589692

"""

def calculatePi(eps):

    pi = 0.0

    sign = 1

    term = 1.0

    counter = 0

    # 使用while循环，直到最后一项的绝对值小于eps

    while term >= eps:

        pi += sign * term

        sign = -sign # 交替符号,和题目中的正负号顺序保持一致

        term = 1.0 / (counter + 3) # 计算下一项

        counter += 2 # 每次增加2，跳过偶数项

    pi *= 4 # 根据公式乘以4得到π的近似值

    return pi

eps = float(input())

# 计算并输出π的近似值

pi = calculatePi(eps)

print("近似值为:{}".format(pi))

"""

9.实验4-14 利用以下公式求sin(x)的近似值，直到最后一项的绝对值小于10-6时，停止计算。计算公式为：

sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ... + (-1)^n * x^(2n+1) / (2n+1)! + ...

这里x的单位为弧度。

注意：绝对值小于10-6的那一项不计算在结果内。

【运行示例】

输入：1.57

输出：sin(1.57)的近似值为:0.9999996270418698

"""

x = eval(input())

r = 1

p = x

s = 0

while abs(p) >= 1e-6:

    s += p

    r += 1

    p = p*(-x*x)/((2*r-2)*(2*r-1))

print("sin({})的近似值为:{}".format(x,s))

"""

10.实验4-15 输入任意实数a(a>=0)，用迭代法求x=，要求结果精确到10-6，即|xn+1-xn|<10-6时，xn+1为的近似值。

令x0=a，迭代公式为：x_(n+1)=1/2(x_n+a/x_n)

要求：结果显示到小数点后6位。

【运行示例】

输入：2

输出：x的近似值为:1.414214

"""

def iterative_sqrt(a):
    # 初始猜测值
    x_n = a
    # 迭代计算
    while True:
        # 应用迭代公式
        x_next = (x_n + a / x_n) / 2
        # 检查精度
        if abs(x_next - x_n) < 1e-6:
            break
        # 更新猜测值
        x_n = x_next
    return x_next
# 从键盘输入实数a
a = float(input())
# 确保a大于等于0
if a < 0:
    print("输入的数必须是非负实数。")
else:
    # 计算并输出x的近似值，结果保留6位小数
    x_approximation = iterative_sqrt(a)
    print("x的近似值为:{:.6f}".format(x_approximation))

到了这里，关于矿大python学习通实验4-2的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！