✏️ 习题
第 6 章 · 函数 · 各种数 · 共 20 题 · 源自课堂练习
1
编写一个函数，计算一个整数各个数字的和。例如输入 234，输出 9，因为 2 + 3 + 4 = 9。
📝 样例输入： 234
▶ 运行结果： 9
▼
参考答案
python
def sum_of_digits(num):
"""
1、编写一个函数，计算一个整数各个数字的和。
参数: num - 整数
返回: 各位数字之和
原理：利用 % 10 取末位数字，// 10 去掉末位，循环至 num 为 0
过程演示（以 1234 为例）：
1234 % 10 = 4 1234 // 10 = 123
123 % 10 = 3 123 // 10 = 12
12 % 10 = 2 12 // 10 = 1
1 % 10 = 1 1 // 10 = 0 -> 结束
4 + 3 + 2 + 1 = 10
"""
num = abs(num) # 处理负数，取绝对值
total = 0
while num != 0:
total += num % 10 # 取出末位数字，累加
num //= 10 # 去掉末位
return total
num = int(input("请输入一个数字:"))
result = sum_of_digits(num)
print(result)2
输出一个正整数的所有约数。
📝 样例输入： 12
▶ 运行结果： 12 的约数：[1, 2, 3, 4, 6, 12]
▼
参考答案
python
def get_divisors(n):
"""
2、输出一个正整数的所有约数。
参数: n - 正整数
返回: 约数列表
"""
if n <= 0:
return []
divisors = []
for i in range(1, n + 1):
if n % i == 0:
divisors.append(i)
return divisors3
判断一个正整数是否是质数。
📝 样例输入： 29
▶ 运行结果： 29 是质数：True
▼
参考答案
python
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True4
输入一个正整数，将其分解为质因数的乘积（如 12 = 2×2×3）。
📝 样例输入： 120
▶ 运行结果： 120 的质因数分解：[2, 2, 2, 3, 5]
表达式：120 = 2×2×2×3×5
▼
参考答案
python
def prime_factorization(n):
"""
4、输入一个正整数，将其分解为质因数的乘积。
参数: n - 正整数
返回: 质因数列表
"""
if n <= 0:
return []
factors = []
divisor = 2
remaining = n
while remaining != 1:
if remaining % divisor == 0:
remaining = remaining // divisor
factors.append(divisor)
else:
divisor += 1
return factors5
输入两个整数 start 和 end，输出区间 [start, end] 内的所有质数。
📝 样例输入： 10 50
▶ 运行结果： 区间 [10, 50] 内的质数：[11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
▼
参考答案
python
# 依赖 is_prime() 函数
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def primes_in_range(start, end):
"""
5、输入两个整数 start 和 end，输出区间 [start, end] 内的所有质数。
参数: start - 起始整数, end - 结束整数
返回: 质数列表
"""
primes = []
for num in range(start, end + 1):
if is_prime(num):
primes.append(num)
return primes6
输入两个正整数，求它们的最大公约数和最小公倍数。
📝 样例输入： 48 60
▶ 运行结果： 48 和 60 的最大公约数：12
48 和 60 的最小公倍数：240
▼
参考答案
python
def gcd(a, b):
"""
计算两个数的最大公约数
"""
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
"""
计算两个数的最小公倍数
"""
if a == 0 or b == 0:
return 0
return abs(a * b) // gcd(a, b)
def gcd_lcm(a, b):
"""
6、输入两个正整数，求它们的最大公约数和最小公倍数。
参数: a, b - 两个正整数
返回: (最大公约数, 最小公倍数)
"""
return gcd(a, b), lcm(a, b)7
输出斐波那契数列的前n项。
📝 样例输入： 10
▶ 运行结果： 斐波那契数列前 10 项：[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
▼
参考答案
python
def fibonacci(n):
"""
7、输出斐波那契数列的前n项。
参数: n - 项数
返回: 斐波那契数列列表
"""
if n <= 0:
return []
fib = [0, 1]
if n == 1:
return [0]
if n == 2:
return fib
for i in range(2, n):
fib.append(fib[i-1] + fib[i-2])
return fib8
找出所有 3 位水仙花数（一个 3 位数，各位数字的立方和等于它本身，如 153 = 1³ + 5³ + 3³）。
📝 样例输入： （无需输入）
▶ 运行结果： 3位水仙花数：[153, 370, 371, 407]
▼
参考答案
python
def narcissistic_numbers():
"""
8、找出所有3位水仙花数。
返回: 3位水仙花数列表
"""
result = []
for num in range(100, 1000):
hundreds = num // 100
tens = (num // 10) % 10
units = num % 10
if hundreds ** 3 + tens ** 3 + units ** 3 == num:
result.append(num)
return result9
找出 1000 以内的完全数（一个数等于其所有真因子的和，如 6 = 1+2+3）。
📝 样例输入： 1000
▶ 运行结果： 1000以内的完全数：[6, 28, 496]
▼
参考答案
python
def perfect_numbers(limit=1000):
"""
9、找出limit以内的完全数。
参数: limit - 上限（默认1000）
返回: 完全数列表
"""
result = []
for num in range(2, limit + 1):
divisors_sum = 0
for i in range(1, num):
if num % i == 0:
divisors_sum += i
if divisors_sum == num:
result.append(num)
return result10
输入 start 和 end，输出区间内的所有阿姆斯特朗数。。阿姆斯特朗数：广义水仙花数，n 位数的各位数字的 n 次方和等于它本身。
📝 样例输入： 100 500
▶ 运行结果： 区间 [100, 500] 内的阿姆斯特朗数：[153, 370, 371, 407]
▼
参考答案
python
def armstrong_numbers(start, end):
"""
10、输入start和end，输出区间内的所有阿姆斯特朗数。
参数: start - 起始整数, end - 结束整数
返回: 阿姆斯特朗数列表
"""
result = []
for num in range(start, end + 1):
if num < 0:
continue
digits = list(str(num))
n = len(digits)
total = 0
for d in digits:
total += int(d) ** n
if total == num:
result.append(num)
return result11
输入一个整数（可含负数），判断是否为回文数（正读 / 反读一致。
📝 样例输入： 12321
▶ 运行结果： 12321 是回文数：True
-121 是回文数：False
▼
参考答案
python
def is_palindrome(n):
"""
11、输入一个整数（可含负数），判断是否为回文数。
参数: n - 整数
返回: True（是回文数）或 False（不是回文数）
"""
s = str(n)
return s == s[::-1]12
输入start和end,输出区间内的所有回文数。
📝 样例输入： 100 200
▶ 运行结果： 区间 [100, 200] 内的回文数：[101, 111, 121, 131, 141, 151, 161, 171, 181, 191]
▼
参考答案
python
# 依赖 is_palindrome() 函数
def is_palindrome(n):
"""
11、输入一个整数（可含负数），判断是否为回文数。
参数: n - 整数
返回: True（是回文数）或 False（不是回文数）
"""
s = str(n)
return s == s[::-1]
def palindromes_in_range(start, end):
"""
12、输入start和end，输出区间内的所有回文数。
参数: start - 起始整数, end - 结束整数
返回: 回文数列表
"""
result = []
for num in range(start, end + 1):
if is_palindrome(num):
result.append(num)
return result13
请从小到大输出所有4位数的可逆素数。
可逆素数是指一个素数将其各位数字的顺序倒过来构成的反序数也是素数。
可逆素数是指一个素数将其各位数字的顺序倒过来构成的反序数也是素数。
📝 样例输入： （无需输入，遍历所有4位数）
▶ 运行结果： 4位可逆素数（共204个，前10个）：[1009, 1021, 1031, 1033, 1061, 1069, 1091, 1097, 1103, 1109]
▼
参考答案
python
# 依赖 is_prime() 和 reverse_number() 函数
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def reverse_number(n):
"""
反转一个数的各位数字
"""
return int(str(n)[::-1])
def reversible_primes():
"""
13、请从小到大输出所有4位数的可逆素数。
返回: 4位可逆素数列表
"""
result = []
for num in range(1000, 10000):
if is_prime(num):
reversed_num = reverse_number(num)
if reversed_num >= 1000 and reversed_num < 10000 and is_prime(reversed_num):
result.append(num)
return result14
所谓回文素数指的是，对一个整数n从左向右和从右向左读其数值都相同,且n为素数，则称整数n为回文素数。
对于偶数位的整数，除了11以外，都不存在回文素数。即所有的4位整数、6位整数、8位整数等都不存在回文素数。下面列出两位和三位整数中包含的所有回文素数。
两位回文素数：11。
三位回文素数：101，131，151，181，191，313，353，373，383，727，757，787，797，919，929。
求出所有不超过1000的回文素数。
对于偶数位的整数，除了11以外，都不存在回文素数。即所有的4位整数、6位整数、8位整数等都不存在回文素数。下面列出两位和三位整数中包含的所有回文素数。
两位回文素数：11。
三位回文素数：101，131，151，181，191，313，353，373，383，727，757，787，797，919，929。
求出所有不超过1000的回文素数。
📝 样例输入： 1000
▶ 运行结果： 不超过1000的回文素数：[2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929]
▼
参考答案
python
# 依赖 is_prime() 和 is_palindrome() 函数
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def is_palindrome(n):
"""
11、输入一个整数（可含负数），判断是否为回文数。
参数: n - 整数
返回: True（是回文数）或 False（不是回文数）
"""
s = str(n)
return s == s[::-1]
def palindromic_primes(limit=1000):
"""
14、求出所有不超过limit的回文素数。
参数: limit - 上限（默认1000）
返回: 回文素数列表
"""
result = []
for num in range(2, limit + 1):
if is_prime(num) and is_palindrome(num):
result.append(num)
return result15
输入一个十进制整数，手动实现转二进制；扩展题：通用进制转换（十进制转 2~16 进制）。（手动实现，禁用 bin()等函数）
📝 样例输入： 123
▶ 运行结果： 十进制 123 转二进制：1111011
十进制 123 转十六进制：7B
▼
参考答案
python
# 包含扩展题：通用进制转换
def decimal_to_binary(n):
"""
15、输入一个十进制整数，手动实现转二进制。
参数: n - 十进制整数
返回: 二进制字符串
"""
if n == 0:
return '0'
binary = ''
is_negative = False
if n < 0:
is_negative = True
n = -n
while n > 0:
binary = str(n % 2) + binary
n = n // 2
if is_negative:
binary = '-' + binary
return binary
def decimal_to_base(n, base):
"""
扩展题：通用进制转换（十进制转2~16进制）。
参数: n - 十进制整数, base - 目标进制（2-16）
返回: 转换后的字符串
"""
if base < 2 or base > 16:
return None
if n == 0:
return '0'
digits = '0123456789ABCDEF'
result = ''
is_negative = False
if n < 0:
is_negative = True
n = -n
while n > 0:
result = digits[n % base] + result
n = n // base
if is_negative:
result = '-' + result
return result16
输入一个二进制整数，手动实现转十进制（手动实现，禁用 int ()）
📝 样例输入： 1111011
▶ 运行结果： 二进制 1111011 转十进制：123
▼
参考答案
python
def binary_to_decimal(binary_str):
"""
16、输入一个二进制整数，手动实现转十进制。
参数: binary_str - 二进制字符串
返回: 十进制整数
"""
binary_str = str(binary_str)
is_negative = False
if binary_str.startswith('-'):
is_negative = True
binary_str = binary_str[1:]
decimal = 0
power = 0
for digit in reversed(binary_str):
decimal += int(digit) * (2 ** power)
power += 1
if is_negative:
decimal = -decimal
return decimal17
如果整数A的全部因子（包括1，不包括A本身）之和等于B，且整数B的全部因子（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数。求3000以内的全部亲密数。
📝 样例输入： 3000
▶ 运行结果： 3000以内的亲密数：[(220, 284), (1184, 1210), (2620, 2924)]
▼
参考答案
python
# 依赖 get_proper_divisors_sum() 函数
def get_proper_divisors_sum(n):
"""
计算一个数的所有真因子之和（不包括自身）
"""
if n <= 1:
return 0
total = 1
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
total += i
if i != n // i:
total += n // i
return total
def amicable_numbers(limit=3000):
"""
17、求limit以内的全部亲密数。
参数: limit - 上限（默认3000）
返回: 亲密数对列表
"""
result = []
checked = set()
for a in range(2, limit + 1):
if a in checked:
continue
b = get_proper_divisors_sum(a)
if b > a and b <= limit:
if get_proper_divisors_sum(b) == a:
result.append((a, b))
checked.add(a)
checked.add(b)
return result18
所谓孪生素数指的是间隔为2的两个相邻素数，因为它们之间的距离已经近得不能再近了，如同孪生兄弟一样，故将这一对素数称为孪生素数。
显然，最小的一对孪生素数是(1,3)。我们可以写出3～100以内的孪生素数，一共有8对，分别是(3,5)，(5,7)，(11,13)，(17,19)，(29,31)，(41,43)，(59,61)和(71,73)。随着数字的增大，孪生素数的分布也越来越稀疏，人工寻找孪生素数变得非常困难。
编程求出3～1000以内的所有孪生素数。
显然，最小的一对孪生素数是(1,3)。我们可以写出3～100以内的孪生素数，一共有8对，分别是(3,5)，(5,7)，(11,13)，(17,19)，(29,31)，(41,43)，(59,61)和(71,73)。随着数字的增大，孪生素数的分布也越来越稀疏，人工寻找孪生素数变得非常困难。
编程求出3～1000以内的所有孪生素数。
📝 样例输入： 1000
▶ 运行结果： 孪生素数（共35对，前10对）：[(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), (41, 43), (59, 61), (71, 73), (101, 103), (107, 109)]
▼
参考答案
python
# 依赖 is_prime() 函数
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def twin_primes(limit=1000):
"""
18、编程求出3〜limit以内的所有孪生素数。
参数: limit - 上限（默认1000）
返回: 孪生素数对列表
"""
result = []
prev_prime = None
for num in range(3, limit + 1):
if is_prime(num):
if prev_prime is not None and num - prev_prime == 2:
result.append((prev_prime, num))
prev_prime = num
return result19
梅森数（Mersenne Prime）指的是形如2**n-1的正整数，其中指数n是素数，记为Mn。如果一个梅森数是素数，则称其为梅森素数。例如2**2-1＝3、2**3-1＝7都是梅森素数。
试求出指数n<20的所有梅森素数。
试求出指数n<20的所有梅森素数。
📝 样例输入： 20
▶ 运行结果： 梅森素数：
n=2: 2^2-1 = 3
n=3: 2^3-1 = 7
n=5: 2^5-1 = 31
n=7: 2^7-1 = 127
n=13: 2^13-1 = 8191
n=17: 2^17-1 = 131071
n=19: 2^19-1 = 524287
▼
参考答案
python
# 依赖 is_prime() 函数
def is_prime(n):
"""
3、判断一个正整数是否是质数。
参数: n - 正整数
返回: True（是质数）或 False（不是质数）
"""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def mersenne_primes(max_n=20):
"""
19、试求出指数n<max_n的所有梅森素数。
参数: max_n - 指数上限（默认20）
返回: 梅森素数列表（格式：(指数n, 梅森素数Mn)）
"""
result = []
for n in range(2, max_n):
if is_prime(n):
mn = (2 ** n) - 1
if is_prime(mn):
result.append((n, mn))
return result20
自守数是指一个数的平方的尾数等于该数自身的自然数。例如，5**2=25，25**2 =625，76**2 =5776，9376**2 =87909376。求100 000以内的自守数。
📝 样例输入： 100000
▶ 运行结果： 自守数（共10个）：[0, 1, 5, 6, 25, 76, 376, 625, 9376, 90625]
▼
参考答案
python
def automorphic_numbers(limit=100000):
"""
20、求limit以内的自守数。
参数: limit - 上限（默认100000）
返回: 自守数列表
"""
result = []
for num in range(0, limit + 1):
square = num * num
num_str = str(num)
square_str = str(square)
if square_str.endswith(num_str):
result.append(num)
return result