YYDS Space

Appearance

综合案例 ​

1. 寻找满足条件的数字“自反数” ​

题目：定义自反数：一个整数 n 满足以下条件时称为自反数：

  1. n 是一个四位数。
  2. n 可以被 4 整除。
  3. n 的数位的平方和等于 n 自身。

请编写一个函数 is_autoreflective(num) 来判断一个数是否为自反数，并找出 1000 到 9999 之间的所有自反数。

思路分析：

  1. 使用嵌套循环提取各位数字。
  2. 检查是否为四位数、可被 4 整除、并且数位平方和等于数本身。
  3. 使用 is_autoreflective 函数检查数字条件，在主程序中遍历范围并输出。

代码详解：

python
def is_autoreflective(num):
    """判断一个数是否为自反数"""
    if num % 4 != 0:
        return False
    thousands = num // 1000
    hundreds = (num // 100) % 10
    tens = (num // 10) % 10
    units = num % 10
    return (thousands**2 + hundreds**2 + tens**2 + units**2) == num

# 找出所有自反数
autoreflective_numbers = []
for i in range(1000, 10000):
    if is_autoreflective(i):
        autoreflective_numbers.append(i)

print("所有自反数为：", autoreflective_numbers)

2. 判断“亲密素数对” ​

题目：定义亲密素数对：如果两个素数之差等于 2，则称它们为亲密素数对。例如 (3, 5) 和 (11, 13) 是亲密素数对。编写函数 is_prime(num) 判断一个数是否为素数，找到 1 到 100 之间的所有亲密素数对。

思路分析：

  1. 编写 is_prime(num) 函数判断一个数是否为素数。
  2. 遍历 1 到 100 的素数，检查每对素数之间的差是否等于 2。
  3. 如果差值满足条件，则将素数对存储在列表中并输出。

代码详解：

python
def is_prime(num):
    """判断一个数是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找到 1 到 100 之间的所有亲密素数对
prime_pairs = []
previous_prime = None
for num in range(2, 101):
    if is_prime(num):
        if previous_prime and num - previous_prime == 2:
            prime_pairs.append((previous_prime, num))
        previous_prime = num

print("亲密素数对为：", prime_pairs)

3. 生成和验证“循环素数” ​

题目：循环素数是指通过循环排列数位生成的新数字也都是素数。例如，197 是循环素数，因为 197、971 和 719 都是素数。编写函数 is_circular_prime(num) 判断一个数是否为循环素数，找出 1 到 100 之间的所有循环素数。

思路分析：

  1. 编写 is_prime(num) 判断素数。
  2. 编写 generate_rotations(num) 生成数的所有循环排列。
  3. 使用 is_circular_prime(num) 判断每个循环排列是否为素数。

代码详解：

python
def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def generate_rotations(num):
    """生成所有循环排列"""
    rotations = []
    s = str(num)
    for i in range(len(s)):
        rotated = int(s[i:] + s[:i])
        rotations.append(rotated)
    return rotations

def is_circular_prime(num):
    """判断是否为循环素数"""
    for rotation in generate_rotations(num):
        if not is_prime(rotation):
            return False
    return True

# 找出 1 到 100 之间的循环素数
circular_primes = [num for num in range(1, 101) if is_circular_prime(num)]
print("循环素数有：", circular_primes)

4. 计算“最小公倍数数列” ​

题目：编写函数 gcd(a, b) 计算两个数的最大公约数，编写函数 lcm(a, b) 计算两个数的最小公倍数，再编写 lcm_list(numbers) 计算一个整数列表的最小公倍数。测试 lcm_list 函数求 [4, 5, 12, 15] 的最小公倍数。

思路分析：

  1. 使用欧几里得算法在 gcd 中计算最大公约数。
  2. 使用公式 lcm(a, b) = a * b / gcd(a, b) 在 lcm 中计算最小公倍数。
  3. 使用 reduce 和 lcm 计算列表的最小公倍数。

代码详解：

python
from functools import reduce

def gcd(a, b):
    """计算最大公约数"""
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    """计算最小公倍数"""
    return a * b // gcd(a, b)

def lcm_list(numbers):
    """计算列表中所有数字的最小公倍数"""
    return reduce(lcm, numbers)

# 测试列表的最小公倍数
numbers = [4, 5, 12, 15]
result = lcm_list(numbers)
print("列表 [4, 5, 12, 15] 的最小公倍数是：", result)

5. 判断“完全平方回文数” ​

题目：完全平方回文数是指一个数字的平方是回文数。例如，11 是完全平方回文数，因为 (11^2 = 121)，而 121 是回文数。编写函数 is_palindrome(num) 判断一个数是否为回文数，编写函数 is_square_palindrome(num) 判断一个数是否为完全平方回文数，输出 1 到 100 之间的所有完全平方回文数。

思路分析：

  1. 使用字符串反转在 is_palindrome(num) 中判断回文数。
  2. 使用 is_square_palindrome(num) 判断一个数的平方是否为回文数。
  3. 遍历 1 到 100，找出所有完全平方回文数。

代码详解：

python
def is_palindrome(num):
    """判断一个数是否是回文数"""
    return str(num) == str(num)[::-1]

def is_square_palindrome(num):
    """判断一个数的平方是否是回文数"""
    square = num ** 2
    return is_palindrome(square)

# 找出 1 到 100 之间的完全平方回文数
square_palindromes = [num for num in range(1, 101) if is_square_palindrome(num)]
print("完全平方回文数有：", square_palindromes)

6. 查找“素数回文三角数” ​

题目：素数回文三角数是指同时满足以下条件的数字：

  1. 该数字是素数。
  2. 该数字是回文数（正向和反向相同）。
  3. 该数字是三角数，三角数的公式为 n * (n + 1) / 2。

请编写函数 is_prime(num)、is_palindrome(num) 和 is_triangle_number(num) 来判断一个数是否满足这三个条件，并找出 1 到 10000 之间的所有素数回文三角数。

思路分析：

  1. 使用 is_prime(num) 判断是否为素数。
  2. 使用 is_palindrome(num) 判断是否为回文数。
  3. 使用 is_triangle_number(num) 判断是否为三角数，检查是否符合三角数公式。
  4. 遍历 1 到 10000 的数，筛选出符合所有条件的数字。

代码详解：

python
def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    """判断是否为回文数"""
    return str(num) == str(num)[::-1]

def is_triangle_number(num):
    """判断是否为三角数"""
    n = (-1 + (1 + 8 * num) ** 0.5) / 2
    return n.is_integer()

# 找出 1 到 10000 之间的素数回文三角数
result = []
for i in range(1, 10001):
    if is_prime(i) and is_palindrome(i) and is_triangle_number(i):
        result.append(i)

print("素数回文三角数有：", result)

7. 查找满足特定“数字和”的数字 ​

题目：找出 100 到 999 之间所有的三位数，使得：

  1. 各个位数字之和等于 15。
  2. 各个位数字之积等于 36。

请编写函数 digit_sum(num) 和 digit_product(num) 来分别计算一个数字的位数之和与位数之积，并找出符合条件的三位数。

思路分析：

  1. 定义 digit_sum(num) 和 digit_product(num)，分别计算一个数的位数和与位数积。
  2. 遍历 100 到 999，检查位数和为 15 且位数积为 36 的数。

代码详解：

python
def digit_sum(num):
    """返回数字的位数和"""
    return sum(int(d) for d in str(num))

def digit_product(num):
    """返回数字的位数积"""
    product = 1
    for d in str(num):
        product *= int(d)
    return product

# 找出满足条件的三位数
result = []
for num in range(100, 1000):
    if digit_sum(num) == 15 and digit_product(num) == 36:
        result.append(num)

print("满足条件的三位数有：", result)

8. 寻找满足条件的“质数方差对” ​

题目：找出 1 到 1000 之间所有的质数对 (p, q)，使得 |p - q| 的平方等于 p + q。即满足条件 |p - q|^2 = p + q。

思路分析：

  1. 使用 is_prime(num) 判断质数。
  2. 遍历 1 到 1000 中的质数对，检查是否满足 |p - q|^2 = p + q。
  3. 使用条件判断进行筛选，确保每对只输出一次。

代码详解：

python
def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找出 1 到 1000 之间的所有质数方差对
prime_pairs = []
primes = [i for i in range(1, 1001) if is_prime(i)]

for i in range(len(primes)):
    for j in range(i + 1, len(primes)):
        p, q = primes[i], primes[j]
        if (abs(p - q) ** 2) == (p + q):
            prime_pairs.append((p, q))

print("满足条件的质数方差对有：", prime_pairs)

9. 查找“数位奇偶相反”的数字 ​

题目：找出 1000 到 9999 之间所有四位数，使得：

  1. 数字的奇数位（从左到右的第 1 位和第 3 位）为偶数。
  2. 数字的偶数位（第 2 位和第 4 位）为奇数。

思路分析：

  1. 使用整除和取余操作提取各个数位。
  2. 检查奇数位是否为偶数，偶数位是否为奇数。
  3. 遍历四位数范围，筛选符合条件的数字。

代码详解：

python
# 找出满足条件的四位数
result = []
for num in range(1000, 10000):
    thousands = num // 1000          # 第一位（奇数位）
    hundreds = (num // 100) % 10     # 第二位（偶数位）
    tens = (num // 10) % 10          # 第三位（奇数位）
    units = num % 10                 # 第四位（偶数位）

    if thousands % 2 == 0 and tens % 2 == 0 and hundreds % 2 == 1 and units % 2 == 1:
        result.append(num)

print("满足条件的四位数有：", result)

10. 检查“等差质数序列” ​

题目：找出 1 到 100 之间所有长度为 3 的等差质数序列 (p, q, r)，其中 p < q < r。即满足 q - p = r - q，且 p、q、r 均为素数。

思路分析：

  1. 使用 is_prime(num) 函数判断质数。
  2. 使用嵌套循环枚举质数序列 (p, q, r)。
  3. 检查是否满足等差条件 q - p = r - q。

代码详解：

python
def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

# 找出满足条件的等差质数序列
result = []
primes = [i for i in range(1, 101) if is_prime(i)]

for i in range(len(primes) - 2):
    for j in range(i + 1, len(primes) - 1):
        for k in range(j + 1, len(primes)):
            p, q, r = primes[i], primes[j], primes[k]
            if q - p == r - q:
                result.append((p, q, r))

print("满足条件的等差质数序列有：", result)

11. 检查“连续回文质数对” ​

题目：找出 1 到 1000 之间的所有回文质数对 (p, q)，使得 p < q 且 q 是 p 的下一个回文质数。

思路分析：

  1. 使用 is_prime(num) 和 is_palindrome(num) 判断质数和回文数。
  2. 找到 1 到 1000 的所有回文质数，并检查是否连续。
  3. 将符合条件的回文质数对存储在列表中。

代码详解：

python
def is_prime(num):
    """判断是否为素数"""
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    """判断是否为回文数"""
    return str(num) == str(num)[::-1]

# 找出 1 到 1000 之间所有连续回文质数对
result

 = []
palindromic_primes = [num for num in range(1, 1001) if is_prime(num) and is_palindrome(num)]

for i in range(len(palindromic_primes) - 1):
    p, q = palindromic_primes[i], palindromic_primes[i + 1]
    result.append((p, q))

print("连续回文质数对有：", result)