代码收藏家 矿大Python学习通实验4-2详解及实践指南
"""
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))
