《深度剖析算法优化：提升效率与精度的秘诀》

想象一下，你面前有一堆杂乱无章的数据，你需要从中找到特定的信息，或者按照一定的规则对这些数据进行排序。又或者，你要为一个物流公司规划最佳的配送路线，以降低成本和提高效率。这些问题看似复杂，但都可以通过特定的算法来解决。算法就像是一把神奇的钥匙，为解决各种各样的问题提供了方法和途径。无论是在科学研究、商业运营还是日常生活中，算法都发挥着不可或缺的作用。

原型—源码

原型

import math
import timedef is_prime(n):for i in range(2, n):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):# 如果找到因子且均为质数，则退出循环if is_prime(p) and is_prime(q):if p * q == n:print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

原型—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

一次优化—源码

任何一个数只需要找其小于开根号的整数即可

import math
import timedef is_prime(n):loop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):# 如果找到因子且均为质数，则退出循环if is_prime(p) and is_prime(q):if p * q == n:print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

一次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

二次优化—源码

跳过小于2的数

import math
import timedef is_prime(n):if n < 2:return Falseloop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):# 如果找到因子且均为质数，则退出循环if is_prime(p) and is_prime(q):if p * q == n:print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

二次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

三次优化—源码

在检查大于2的数时，只检查奇数

import math
import timedef is_prime(n):if n < 2:return Falseif n == 2:return Trueif n % 2 == 0:return Falseloop = int(math.sqrt(n)) + 1for i in range(3, loop, 2):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):# 如果找到因子且均为质数，则退出循环if is_prime(p) and is_prime(q):if p * q == n:print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

三次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

四次优化—源码

先算乘积

import math
import timedef is_prime(n):for i in range(2, n):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

四次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

五次优化—源码

任何一个数只需要找其小于开根号的整数即可 先算乘积

import math
import timedef is_prime(n):loop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)    if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

五次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

六次优化—源码

跳过小于2的数 先算乘积

import math
import timedef is_prime(n):if n < 2:return Falseloop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)    if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

六次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

七次优化—源码

在检查大于2的数时，只检查奇数 先算乘积

import math
import timedef is_prime(n):if n < 2:return Falseif n == 2:return Trueif n % 2 == 0:return Falseloop = int(math.sqrt(n)) + 1for i in range(3, loop, 2):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n):for q in range(1, n):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)    if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

七次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n-1，对于每个数p，再遍历从1到n-1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

八次次优化—源码

p、q循环减半

import math
import timedef is_prime(n):for i in range(2, n):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n // 2 + 1):for q in range(1, n // 2 + 1):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

八次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n//2 + 1，对于每个数p，再遍历从1到n//2 + 1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

九次优化—源码

任何一个数只需要找其小于开根号的整数即可 p、q循环减半

import math
import timedef is_prime(n):loop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n // 2 + 1):for q in range(1, n // 2 + 1):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

九次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n//2 + 1，对于每个数p，再遍历从1到n//2 + 1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

十次优化—源码

跳过小于2的数 p、q循环减半

import math
import timedef is_prime(n):if n < 2:return Falseloop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n // 2 + 1):for q in range(1, n // 2 + 1):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

十次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n//2 + 1，对于每个数p，再遍历从1到n//2 + 1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq02函数，传入的参数是99460729。

优化建议:

  1. 优化is_prime函数，只需要检查到sqrt(n)就可以了。

  2. 对于prime_pq02函数，可以考虑使用更高效的算法，如试除法结合埃拉托斯特尼筛法来找出质数因子。

  3. 可以添加更多的错误检查和边界条件处理，例如检查输入的n是否为正整数。

下面是优化后的代码：

import math
import timedef is_prime(n):if n <= 1:return Falseif n == 2:return Trueif n % 2 == 0:return Falseloop = int(math.sqrt(n)) + 1for i in range(3, loop, 2):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(2, int(math.sqrt(n)) + 1):if is_prime(p) and n % p == 0:q = n // pif is_prime(q):print(p, '*', q)end = time.time()print(end - start)returnprint("No prime factors found")if __name__ == '__main__':prime_pq02(99460729)

这个优化后的代码应该会更快地找到99460729的两个质数因子。

十一次优化—源码

在检查大于2的数时，只检查奇数 p、q循环减半

import math
import timedef is_prime(n):if n < 2:return Falseif n == 2:return Trueif n % 2 == 0:return Falseloop = int(math.sqrt(n)) + 1for i in range(3, loop, 2):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(1, n // 2 + 1):for q in range(1, n // 2 + 1):if p * q == n:if is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

十一次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从1开始，遍历到n//2 + 1，对于每个数p，再遍历从1到n//2 + 1的每个数q。

    • 如果p和q都是质数，并且它们的乘积等于n，那么就找到了两个质数因子，打印出来并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

十二次优化—源码

减少p、q循环时间，并对判断p、q为循环优化依次调用

import math
import timedef is_prime(n):for i in range(2, n):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(2, int(math.sqrt(n)) + 1):if n % p == 0:q = n // pif is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

十二次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从2开始，遍历到n的平方根加1，对于每个数p，如果n能被p整除，那么计算q = n // p。

    • 然后检查p和q是否都是质数，如果是，则打印出这两个质数因子，并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

十三次优化—源码

任何一个数只需要找其小于开根号的整数即可 减少p、q循环时间，并对判断p、q为循环优化依次调用

import math
import timedef is_prime(n):loop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(2, int(math.sqrt(n)) + 1):if n % p == 0:q = n // pif is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

十三次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 它从2开始，一直检查到n-1，看n是否能被这些数整除。如果能，则n不是质数，返回False；否则，返回True。

    • 但这个函数可以优化。例如，只需要检查到sqrt(n)就可以了，因为如果n有一个大于sqrt(n)的因子，那么它必然还有一个小于或等于sqrt(n)的因子。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从2开始，遍历到n的平方根加1，对于每个数p，如果n能被p整除，那么计算q = n // p。

    • 然后检查p和q是否都是质数，如果是，则打印出这两个质数因子，并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

十四次优化—源码

跳过小于2的数 减少p、q循环时间，并对判断p、q为循环优化依次调用

import math
import timedef is_prime(n):if n < 2:return Falseloop = int(math.sqrt(n)) + 1for i in range(2, loop):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(2, int(math.sqrt(n)) + 1):if n % p == 0:q = n // pif is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

十四次优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从2开始，遍历到n的平方根加1，对于每个数p，如果n能被p整除，那么计算q = n // p。

    • 然后检查p和q是否都是质数，如果是，则打印出这两个质数因子，并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

最终优化—源码

在检查大于2的数时，只检查奇数 减少p、q循环时间，并对判断p、q为循环优化依次调用

import math
import timedef is_prime(n):if n < 2:return Falseif n == 2:return Trueif n % 2 == 0:return Falseloop = int(math.sqrt(n)) + 1for i in range(3, loop, 2):if n % i == 0:return Falsereturn Truedef prime_pq(n):start = time.time()for p in range(2, int(math.sqrt(n)) + 1):if n % p == 0:q = n // pif is_prime(p) and is_prime(q):print(p, '*', q)end = time.time()print(end - start)exit(0)if __name__ == '__main__':# 9973 * 9973prime_pq(99460729)

最终优化—源码解析

这段代码的目的是找出一个给定数字的两个质数因子。下面是对代码的详细分析：

  1. 导入模块:

    • math: 这个模块提供了数学函数，但在这个代码中并没有被使用。

    • time: 这个模块被用来测量程序的执行时间。

  2. is_prime函数:

    • 这个函数用于判断一个数是否为质数。

    • 首先排除小于2的数，因为它们不是质数。

    • 对于2这个特殊的数，直接返回True。

    • 对于偶数（除了2），直接返回False。

    • 然后从3开始，只检查奇数（因为偶数已经被排除了），直到sqrt(n)。

    • 如果在这个范围内找到一个能整除n的数，那么n就不是质数，返回False；否则，返回True。

  3. prime_pq函数:

    • 这个函数用于找出一个数的两个质数因子。

    • 它从2开始，遍历到n的平方根加1，对于每个数p，如果n能被p整除，那么计算q = n // p。

    • 然后检查p和q是否都是质数，如果是，则打印出这两个质数因子，并结束程序。

    • 这个函数的时间复杂度是O(n^2)，因为它有两个嵌套的循环。对于大的n，这可能会非常慢。

  4. 主程序:

    • 在主程序中，调用了prime_pq函数，传入的参数是99460729。

高阶优化

思路：

1、优化is_prime函数，只需要检查到sqrt(n)就可以了。
2、prime_pq函数，可以考虑使用更高效的算法，如试除法结合埃拉托斯特尼筛法/Pollard's rho算法来找出质数因子。
3、并行化处理在多核处理器上运行，可以将筛选质数或者试除的过程进行并行化，进一步提高效率。
4、添加更多的错误检查和边界条件处理，例如检查输入的n是否为正整数。

以后有时间再来演示高阶算法。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/1987.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

怎么实现Redis的高可用？

怎么实现Redis的高可用？

大家好&#xff0c;我是锋哥。今天分享关于【怎么实现Redis的高可用&#xff1f;】面试题。希望对大家有帮助&#xff1b; 怎么实现Redis的高可用&#xff1f; 1000道 互联网大厂Java工程师 精选面试题-Java资源分享网 为了实现 Redis 的高可用性&#xff0c;我们需要保证在发…
阅读更多...
【CSS】HTML页面定位CSS - position 属性 relative 、absolute、fixed 、sticky

【CSS】HTML页面定位CSS - position 属性 relative 、absolute、fixed 、sticky

目录 relative 相对定位 absolute 绝对定位 fixed 固定定位 sticky 粘性定位 position&#xff1a;relative 、absolute、fixed 、sticky &#xff08;四选一&#xff09; top&#xff1a;距离上面的像素 bottom&#xff1a;距离底部的像素 left&#xff1a;距离左边的像素…
阅读更多...
使用docker-compose安装Redis的主从+哨兵模式

使用docker-compose安装Redis的主从+哨兵模式

必看 本文是一主二从一哨兵模式&#xff1b;其余的单机/集群/多哨兵模式的话&#xff0c;不在本文... 本文的环境主要是&#xff1a;应用app在本地&#xff0c;redis在云服务器上&#xff1b; 图解 图如下&#xff1a;这个图很重要&#xff1b; 之所以要这样画图&#xff0…
阅读更多...
深度剖析RabbitMQ：从基础组件到管理页面详解

深度剖析RabbitMQ：从基础组件到管理页面详解

文章目录 一、简介二、Overview2.1 Overview->Totals2.2 Overview->Nodesbroker的属性2.3 Overview->Churn statistics2.4 Overview->Ports and contexts2.5 Overview->Export definitions2.6 Overview->Import definitions 三、Connections连接的属性 四、C…
阅读更多...
[0405].第05节：搭建Redis主从架构

[0405].第05节：搭建Redis主从架构

Redis学习大纲 一、3主3从的集群配置&#xff1a; 1.1.集群规划 1.分片集群需要的节点数量较多&#xff0c;这里我们搭建一个最小的分片集群&#xff0c;包含3个master节点&#xff0c;每个master包含一个slave节点&#xff0c;结构如下&#xff1a; 2.每组是一主一从&#x…
阅读更多...
QT在 MacOS X上，如何检测点击程序坞中的Dock图标

QT在 MacOS X上，如何检测点击程序坞中的Dock图标

最近在开发MacOS的qt应用&#xff0c;在做到最小化系统托盘功能时&#xff0c;发现关闭窗口后再次点击程序坞中的Dock图标不能将主界面再显示出来。查询里很多资料&#xff0c;发现是QT自身的问题&#xff0c;没有做相关的点击Dock图标的处理。 于是我参考了国内和国外的这两篇…
阅读更多...
Flutter插件制作、本地/远程依赖及缓存机制深入剖析（原创-附源码）

Flutter插件制作、本地/远程依赖及缓存机制深入剖析（原创-附源码）

Flutter插件在开发Flutter项目的过程中扮演着重要的角色&#xff0c;我们从 ​​​​​​https://pub.dev 上下载添加到项目中的第三方库都是以包或者插件的形式引入到代码中的&#xff0c;这些第三方工具极大的提高了开发效率。 深入的了解插件的制作、发布、工作原理和缓存机…
阅读更多...
每日学习30分轻松掌握CursorAI：Cursor插件系统与扩展功能

每日学习30分轻松掌握CursorAI：Cursor插件系统与扩展功能

Cursor插件系统与扩展功能 一、课程概述 今天我们将学习Cursor AI的插件系统&#xff0c;了解如何通过插件扩展和增强IDE功能。由于Cursor AI基于VS Code开发&#xff0c;我们可以利用丰富的VS Code插件生态系统。 1.1 学习目标 了解插件系统原理掌握插件安装管理使用常用开…
阅读更多...
第G1周：生成对抗网络（GAN）入门

第G1周：生成对抗网络（GAN）入门

>- **&#x1f368; 本文为[&#x1f517;365天深度学习训练营]中的学习记录博客** >- **&#x1f356; 原作者&#xff1a;[K同学啊]** 本人往期文章可查阅&#xff1a; 深度学习总结 基础任务 1.了解什么是生成对抗网络2.生成对抗网络结构是怎么样的3.学习本文代码&am…
阅读更多...
浅谈云计算03 | 云计算的技术支撑（云使能技术）

浅谈云计算03 | 云计算的技术支撑（云使能技术）

云计算的技术支撑 一、定义与内涵1.1 定义与内涵 二、云计算使能技术架构2.1 宽带网络和 Internet 架构2.2 数据中心技术2.3 虚拟化技术2.4 Web 技术2.5 多租户技术2.6 服务技术 一、定义与内涵 1.1 定义与内涵 云计算技术包含一些基础的关键技术&#xff0c;这里称为使能技术…
阅读更多...
Open FPV VTX开源之betaflight配置

Open FPV VTX开源之betaflight配置

Open FPV VTX开源之betaflight配置 1. 源由2. 配置3. 总结4. 参考资料5. 补充 - 飞控固件版本 1. 源由 飞控嵌入式OSD - ardupilot配置使用betaflight配套OSD图片。 Choose correct font depending on Flight Controller SW. ──> /usr/share/fonts/├──> font_btfl…
阅读更多...
【数字化】华为-用变革的方法确保规划落地

【数字化】华为-用变革的方法确保规划落地

导读&#xff1a;华为在数字化转型过程中&#xff0c;深刻认识到变革的必要性&#xff0c;并采用了一系列有效的方法确保转型规划的有效落地。华为认为&#xff0c;数字化转型不仅仅是技术层面的革新&#xff0c;更是企业运作模式、流程、组织、文化等深层次的变革。数字化转型…
阅读更多...
Vue2+OpenLayers给标点Feature添加信息窗体（提供Gitee源码）

Vue2+OpenLayers给标点Feature添加信息窗体（提供Gitee源码）

目录 一、案例截图 二、安装OpenLayers库 三、代码实现 3.1、信息窗体DOM元素 3.2、创建Overlay 3.3、创建一个点 3.4、给点初始化点击事件 3.5、完整代码 四、Gitee源码 一、案例截图 二、安装OpenLayers库 npm install ol 三、代码实现 初始化变量&#xff1a; d…
阅读更多...
CRMEB多商户商城系统JAVA版 B2B2C商家入驻平台系统独立版全开源

CRMEB多商户商城系统JAVA版 B2B2C商家入驻平台系统独立版全开源

系统框架 基于Java vueuni-app开发&#xff0c;并采用业界主流开发框架SpringBoot; 前端开发中&#xff0c;Web PC管理端使用vue element山&#xff0c;移动端使用uni-app框架&#xff0c;前后端分离开发;
阅读更多...
【Linux】进程状态

【Linux】进程状态

一、概念 我们需要知道进程的不同状态。一个进程可以有几个状态&#xff08;在Linux内核里&#xff0c;进程有时候也叫做任务&#xff09; 在操作系统原理中&#xff1a;运行状态分为以下三种&#xff1a;运行状态&#xff08;执行&#xff09;、阻塞状态、就绪状态 1. 运行状…
阅读更多...
UE材质节点Fresnel

UE材质节点Fresnel

Fresnel节点 ExponentIn 控制边缘透明度 BaseReflectFractionIn 控制中心透明度
阅读更多...
LeetCode100之搜索二维矩阵(46)--Java

LeetCode100之搜索二维矩阵(46)--Java

1.问题描述 给你一个满足下述两条属性的 m x n 整数矩阵&#xff1a; 每行中的整数从左到右按非严格递增顺序排列。每行的第一个整数大于前一行的最后一个整数。 给你一个整数 target &#xff0c;如果 target 在矩阵中&#xff0c;返回 true &#xff1b;否则&#xff0c;返回…
阅读更多...
“AI 自动化效能评估系统：开启企业高效发展新征程

“AI 自动化效能评估系统：开启企业高效发展新征程

在当今数字化飞速发展的时代&#xff0c;企业面临着日益激烈的市场竞争&#xff0c;如何提升效率、降低成本成为了企业生存与发展的关键。AI 自动化效能评估系统应运而生&#xff0c;它如同一把智能钥匙&#xff0c;为企业开启了高效发展的新征程。 AI 自动化效能评估系统&…
阅读更多...
primitive 编写着色器材质

primitive 编写着色器材质

import { nextTick, onMounted, ref } from vue import * as Cesium from cesium import gsap from gsaponMounted(() > { ... })// 1、创建矩形几何体&#xff0c;Cesium.RectangleGeometry&#xff1a;几何体&#xff0c;Rectangle&#xff1a;矩形 let rectGeometry new…
阅读更多...
提供的 IP 地址 10.0.0.5 和子网掩码位 /26 来计算相关的网络信息

提供的 IP 地址 10.0.0.5 和子网掩码位 /26 来计算相关的网络信息

网络和IP地址计算器 https://www.sojson.com/convert/subnetmask.html提供的 IP 地址 10.0.0.5 和子网掩码位 /26 来计算相关的网络信息。 子网掩码转换 子网掩码 /26 的含义二进制表示:/26 表示前 26 位是网络部分&#xff0c;剩下的 6 位是主机部分。对应的子网掩码为 255…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023