每日一题——Python实现PAT乙级1099 性感素数（举一反三+思想解读+逐步优化）-CSDN博客

本文链接：https://blog.csdn.net/weixin_44915521/article/details/139574666

一个认为一切根源都是“自己不够强”的INTJ

个人主页：用哲学编程-CSDN博客
专栏：每日一题——举一反三
 Python编程学习
 Python内置函数

1. 分而治之（Divide and Conquer）

2. 空间换时间（Space-Time Tradeoff）

3. 懒惰求值（Lazy Evaluation）

4. 优化（Optimization）

5. 渐进式复杂度分析（Asymptotic Analysis）

6. 模块化（Modularity）

7. 迭代与递增（Iterative and Incremental Development）

8. 实际应用中的启发式方法（Heuristics in Practical Applications）

举一反三

1. 分而治之（Divide and Conquer）

2. 空间换时间（Space-Time Tradeoff）

3. 懒惰求值（Lazy Evaluation）

4. 优化（Optimization）

5. 渐进式复杂度分析（Asymptotic Analysis）

6. 模块化（Modularity）

7. 迭代与递增（Iterative and Incremental Development）

8. 实际应用中的启发式方法（Heuristics in Practical Applications）

综合应用实例

题目链接

我的写法

def is_prime(num):
    # 定义一个函数is_prime，用于检查传入的参数num是否为质数。
    if num<=1:
        return False  # 如果num小于等于1，直接返回False，因为1和负数都不是质数。
    if num<=3:
        return True  # 如果num小于等于3，则返回True，因为2和3都是质数。
    if num%2==0 or num%3==0:
        return False  # 如果num能被2或3整除，则不是质数，返回False。
    i=5
    while i*i<=num:
        # 使用一个while循环来检查从5开始的所有数（i的步长为6），直到i的平方大于num。
        if num%i==0 or num%(i+2)==0:
            return False  # 如果num能被i或i+2整除，则不是质数，返回False。
        i+=6
    return True  # 如果所有的检查都通过了，则num是质数，返回True。

N=int(input())  # 从用户那里获取一个整数输入，并将其赋值给变量N。

# 下面检查N和它的邻居（N-6或N+6）是否都是质数。
if is_prime(N-6) and is_prime(N):
    # 如果N-6和N都是质数，则打印"Yes"和N-6。
    print("Yes")
    print(N-6)
elif is_prime(N+6) and is_prime(N):
    # 如果N和N+6都是质数，则打印"Yes"和N+6。
    print("Yes")
    print(N+6)
else:
    # 如果上述条件都不满足，则执行下面的代码。
    print("No")  # 首先打印"No"，表示N和它的邻居不都是质数。
    i=N+1
    while True:
        # 使用一个无限循环来查找距N最近的一对质数距，其中一个数为i，另一个数为i-6或i+6。
        if i<N+6 and (is_prime(i-6) and is_prime(i)) or (is_prime(i) and is_prime(i+6)):
            # 如果i小于N+6，并且i-6和i或者i和i+6都是质数，则打印i并终止循环。
            print(i)
            break
        elif i>N+6 and is_prime(i) and is_prime(i+6):
            # 如果i大于N+6，并且i和i+6都是质数，则打印i并终止循环。
            print(i)
            break
        i+=1  # 将i的值增加1，然后继续循环。

专业点评

is_prime函数：
- 优点：
  - 该函数使用了一些基础的优化技术，例如排除2和3的倍数，提高了检查质数的效率。
  - 使用了6的倍数规则（6k ± 1）来进一步减少检查次数。
- 缺点：
- 对于非常大的数，效率仍然有限。可以考虑使用更高级的质数测试算法，如 Miller-Rabin 质数测试。
find_prime_pair函数：

优点：
- 逻辑结构清晰。先检查给定的 N 是否满足条件，然后逐步递增 N，直到找到满足条件的数。
缺点：

逐个增加 N 并检查，效率较低。对于较大的 N，这种方法可能会很慢。

时间复杂度分析

is_prime函数：
- 时间复杂度是 O(√n)，因为最多需要检查到 n 的平方根。
find_prime_pair函数：

初始检查：最多调用两次 is_prime，因此时间复杂度为 O(√N)。
逐步寻找：最坏情况下，需要检查多个数。假设需要检查 k 个数，每次调用 is_prime 的时间复杂度为 O(√M)（M 是正在检查的数）。因此，最坏情况下，主逻辑的时间复杂度近似为 O(k * √M)，其中 k 和 M 与输入 N 相关。实际复杂度可能更低，但仍在多项式时间内。

空间复杂度分析

is_prime函数：
- 空间复杂度是 O(1)，只使用了常数级别的额外空间（几个变量）。
find_prime_pair函数：

空间复杂度是 O(1)，除了输入和几个常数级别的变量外，没有使用额外的空间。

综合点评

优点：

is_prime 函数通过基础优化减少了计算量，提升了性能。
find_prime_pair 函数逻辑结构清晰，能够有效判断并找到质数对。

改进建议：

当 N 很大时，逐个递增检查的效率较低，可以考虑使用更高效的质数生成算法，如埃拉托斯特尼筛法，提前生成一段范围内的质数以供查找。
is_prime 函数可以进一步优化，比如使用 Miller-Rabin 质数测试来提升大数的质数检查效率。
添加更多注释和代码格式化，以提高代码的可读性。

总体而言，这段代码在功能上是正确的，并且进行了基本的优化，但在处理大数时可以通过更高级的算法进一步提升性能。

我要更强

为了优化时间复杂度和空间复杂度，我们可以采取以下措施：

使用埃拉托斯特尼筛法预生成质数：这可以显著加快质数的判定。
使用更高效的质数测试算法：如 Miller-Rabin 质数测试。
提前生成一段范围内的质数对：避免逐个递增检查。

下面提供一个优化后的代码，包含详细注释：

import math

def is_prime(n):
    """使用基础优化技术检查一个数是否为质数"""
    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 sieve_of_eratosthenes(limit):
    """使用埃拉托斯特尼筛法生成所有小于等于limit的质数"""
    is_prime = [True] * (limit + 1)
    p = 2
    while (p * p <= limit):
        if (is_prime[p] == True):
            for i in range(p * p, limit + 1, p):
                is_prime[i] = False
        p += 1
    prime_list = [p for p in range(2, limit + 1) if is_prime[p]]
    return prime_list

def find_prime_pair(N):
    """寻找满足条件的质数对"""
    limit = max(N + 1000, 1000)  # 设定一个合理的初始值
    primes = set(sieve_of_eratosthenes(limit))
    
    # 检查初始N
    if N in primes and ((N - 6) in primes or (N + 6) in primes):
        print(f"{N} is part of a prime pair with a difference of 6.")
        return
    
    # 逐步增加N并检查
    while True:
        N += 1
        if N > limit:
            limit *= 2  # 扩展筛选范围
            primes.update(sieve_of_eratosthenes(limit))
        if N in primes and ((N - 6) in primes or (N + 6) in primes):
            print(f"{N} is part of a prime pair with a difference of 6.")
            break

# 示例调用
find_prime_pair(20)

优化点

埃拉托斯特尼筛法：
- 时间复杂度：生成所有小于等于 limit 的质数的时间复杂度是 �(�log⁡(log⁡(�)))O(nlog(log(n)))，其中 n 是 limit 的值。
- 空间复杂度：存储质数的空间复杂度是 �(�)O(n)。
动态扩展筛选范围：
- 通过逐步扩展筛选范围（即当 N 超过当前 limit 时，将 limit 翻倍），避免了一开始设置过大的范围，从而节省空间和时间。
使用集合：