Python miller rabin米勒-拉宾素性检验算法详解及源码

已于 2024-09-05 11:46:38 修改
阅读量279 收藏 3
点赞数 5
文章标签： python 算法 开发语言
于 2024-08-13 15:33:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30247949/article/details/141165427
版权

Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。Miller-Rabin算法是一种素性检验算法，用于判断一个大数是否为素数。它的基本原理是基于费马小定理和随机化算法，通过多次随机选择底数进行检验。

算法基本步骤如下：

  1. 将待检测的大数n-1分解为2^s * d，其中d为奇数。
  2. 随机选择一个底数a，使得 1 < a < n-1。
  3. 计算 a^d mod n，若结果为1或n-1，则n可能为素数。
  4. 将计算结果连续平方s次，每次取模n，求得新的结果。
    a. 若某一步结果为1，则n不为素数。
    b. 若某一步结果为n-1，则n可能为素数。
    c. 若连续平方s次后结果都不为1或n-1，则n不为素数。

优点：

  1. 算法的正确性较高，错误判断为合数的概率可以通过选择合适的底数得到极小。
  2. 算法的时间复杂度较低，为O(k * logn)，其中k为检验的次数。

缺点：

  1. 随机选择底数的次数k需要根据误差概率进行选择，较大的误差概率可能需要增加k的值，导致运行时间增加。

下面是使用Python语言实现Miller-Rabin算法的示例代码：

import random

def miller_rabin(n, k):
    # 判断是否为小数
    if n < 2:
        return False
    if n in [2, 3]:
        return True
    if n % 2 == 0:
        return False
    
    # 将 n-1 分解为 2^s * d
    s, d = 0, n - 1
    while d % 2 == 0:
        s += 1
        d //= 2
    
    # 进行 k 次随机测试
    for _ in range(k):
        a = random.randint(2, n-2)
        x = pow(a, d, n)
        
        if x == 1 or x == n - 1:
            continue
        
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    
    return True

# 示例用法
n = 19
k = 10
result = miller_rabin(n, k)
print(result)  # 输出 True 或 False

注意事项：

  1. 在实现算法时，需要选择合适的检验次数k。一般情况下，k的值选择15~20次可以满足大部分的需求，但在对安全性要求较高的应用中，k的值需要更大。
  2. 底数a的选择应尽量随机且范围为(2, n-2)，以减小误差概率。可以使用Python的random模块进行随机选取。
  3. 在使用算法判断一个数是否为素数时，如果结果为合数，则该数一定非素数；但如果结果为素数，则该数可能是素数，需要使用更可靠的算法进行进一步验证。
  4. 对于非常大的数，算法的效率可能不高，并且需要更多的检验次数k来保证正确性。可以考虑使用其他的更高效的素性检验算法。
猿来如此yyy
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Python:实现miller rabin米勒-拉宾素性检验算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-01 547
Python:实现miller rabin米勒-拉宾素性检验算法(附完整源码)
Objective-C实现miller rabin米勒-拉宾素性检验算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-22 19
Objective-C实现miller rabin米勒-拉宾素性检验算法(附完整源码)
Python Miller Rabin 米勒-拉宾素性检验
云帝的博客
07-26 2142
Miller Rabin 米勒-拉宾素性检验是一种素数判定法则，利用随机化算法判断一个数是合数还是可能是素数。 卡内基梅隆大学的计算机系教授Gary Lee Miller首先提出了基于广义黎曼猜想的确定性算法，由于广义黎曼猜想并没有被证明，其后由以色列耶路撒冷希伯来大学的Michael O. Rabin教授作出修改，提出了不依赖于该假设的随机化算法。 来自 https://baike.baidu.com/item/米勒-拉宾素性检验/22719763 代码实现 import numpy as np de
python 实现miller rabin米勒-拉宾素性检验算法
luthane的博客
09-05 648
米勒-拉宾素性检验（Miller-Rabin prime test）算法是一种用于判断一个正整数是否为素数的概率性算法。它基于费马小定理和二次探测定理。以下是关于该算法的一些详细解释：起源卡内基梅隆大学的Gary Lee Miller教授首先提出了基于广义黎曼猜想的确定性算法，但由于广义黎曼猜想并未被证明，以色列耶路撒冷希伯来大学的Michael O. Rabin教授后来对其进行了修改，提出了不依赖于该假设的随机化算法。
【学习笔记】Miller-Rabin(米勒-拉宾)素性测试，附常用表
11-13 1558
反正就是玄学，玄学！！
米勒-拉宾素性检验(MillerRabbin)算法详解
热门推荐
1900的博客
12-22 1万+
写在前面 网上有很多关于米勒拉宾素性测试算法的博客 但是大多数都是转载，或者只有模板代码没有分析讲解的，甚至还有的分析的都是错的。花了一早上，借鉴了几十篇博客，总算是把这个算法理解了差不多，并且详细整理了一下我的理解。 讲解很细，篇幅较长，要是想看，准备好耐心。 个人理解，如有不对，欢迎指正。 米勒-拉宾(MillerRabbin)素性测试算法 米勒-拉宾(MillerRa...
javascript:实现miller rabin米勒-拉宾素性检验算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-22 58
javascript:实现miller rabin米勒-拉宾素性检验算法(附完整源码)
C/C++ Miller-Rabin素性测试详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-29 7395
该算法的优点在于时间复杂度较低，相对于传统的试除法具有一定的性能优势。Miller-Rabin素性测试是一种用于判断一个数是否为素数的概率性算法。其基本思想是通过多次测试，检查一个数是否满足一定的条件，从而判断其是否为素数。函数中，首先进行一些边界条件的判断，然后根据Miller-Rabin算法的步骤进行相应的计算。在使用该程序时，只需按照程序要求输入待测试的数和测试次数即可，程序会给出相应的判断结果。，它接受一个待测试的数n和测试次数k作为参数，并返回一个布尔值用于判断n是否为素数。
Python基础 5 - 类、对象、注解
云端梦留白的博客
09-04 1232
面向对象（Object-Oriented, OOP）是一种编程范式，它使用“对象”来设计软件，这些对象包含数据（通常称为属性或字段）和代码（通常称为方法或函数），以模拟现实世界实体的属性和行为。面向对象是一种编程方法，通过创建包含数据和行为的对象来模拟现实世界，提高代码的组织性、重用性和灵活性。在 Pyhon 中，想要使用类，必须先创建对象。class 类名称 : # class 关键字，表示定义了一个类，类首字符大写为标准。
JS都有哪些操作数组的方法
ggq53219的博客
09-04 547
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。
Transiting from CUDA to HIP （二）
weixin_44500921的博客
09-03 1330
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。
mongodb在Java中条件分组聚合查询并且分页(时间戳，按日期分组，年月日...)
简单发点工作中用到的，或者记录下小知识点
09-03 1743
按时间 年月日条件分组，筛选数据，统计数据，聚合查询 打印出mongo的SQL语句
【hot100篇-python刷题记录】【数据流的中位数】
m0_73629042的博客
09-04 338
精简的代码总是难以琢磨。
asyncio note
weixin_48232453的博客
09-03 870
python异步库asyncio入门
访问数组索引时超出边界引发 ArrayIndexOutOfBoundsException
Itmastergo的博客
09-05 1085
在 Java 中，数组是一种数据结构，用于存储固定数量的同类型元素。数组中的元素可以是基本数据类型（如intcharfloat等）或引用类型（如String、自定义类等）。数组是一种线性表数据结构，也就是说，数组中的元素可以通过一个整数索引来访问。数组的索引从0开始，这意味着对于长度为n的数组，合法的索引范围是从0到n-1。// 创建一个长度为 5 的整型数组在上面的例子中，numbers是一个包含 5 个整型元素的数组，索引从0到4。数组的大小在创建时就已经固定，因此无法动态扩展。
PyQt5 opencv-python
weixin_68067302的博客
09-03 857
cap = cv2.VideoCapture(0) # 从摄像头捕获图像。ret, frame = cap.read() # 读取一帧图像。# 例如，可以使用模板匹配（Template Matching）计算相似度。# 在右侧图像上绘制可拖动的矩形框。# 这里可以根据您的需求实现相似度计算算法。# 这里可以根据您的需求实现特征提取算法。在右侧静态区使用鼠标进行目标特征图像框选的功能。# 获取左侧图像并存储到右侧。# 计算拖动矩形框的尺寸。# 模拟实时图像数据。使用模板匹配来计算图像之间的相似度，
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 874
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
Python基础
最新发布
flash的博客
09-06 835
newline=''是一个重要的参数，用于防止在写入文件时在不同的操作系统上产生不必要的空行。将 json 转化为 python 对象，存放在内存中。python 文件名 参数1 参数2。
费马素性检验算法、Solovay-Stassen素性检验算法和Miller-Rabin素性检验算法的区别和联系
05-22
费马素性检验算法、Solovay-Stassen素性检验算法和Miller-Rabin素性检验算法都是用于判断一个数是否为素数的算法，下面是它们的区别和联系： 1.费马素性检验算法 费马素性检验算法是一种基于费马小定理的素性测试算法。它的原理是：如果p是一个素数，a是小于p的正整数，则a^(p-1) mod p = 1；如果p不是素数，那么对于任意小于p的正整数a，a^(p-1) mod p != 1。因此，我们可以在随机选择的a值下，使用快速幂算法来计算a^(p-1) mod p的值，如果结果不等于1，则p一定不是素数。 缺点：费马素性检验算法存在漏报的情况，即有时候会将合数误判为素数。 2.Solovay-Stassen素性检验算法 Solovay-Stassen素性检验算法是一种基于欧拉准则的素性测试算法。它的原理是：如果p是一个素数，a是小于p的正整数，则a^((p-1)/2) mod p = +-1；如果p不是素数，那么对于任意小于p的正整数a，a^((p-1)/2) mod p != +-1。因此，我们可以在随机选择的a值下，使用快速幂算法来计算a^((p-1)/2) mod p的值，如果结果不等于+-1，则p一定不是素数。 缺点：Solovay-Stassen素性检验算法比费马素性检验算法更加复杂，但依然存在漏报的情况。 3.Miller-Rabin素性检验算法 Miller-Rabin素性检验算法是一种基于费马小定理的素性测试算法，它是目前最常用的素性检验算法之一。它的原理是：如果p是一个素数，a是小于p的正整数，则a^(d*2^r) mod p = 1或者p-1，其中d是一个奇数，2^r是p-1的一个因子；如果p不是素数，那么对于任意小于p的正整数a，a^(d*2^r) mod p != 1或者p-1。因此，我们可以在随机选择的a值下，使用快速幂算法来计算a^(d*2^r) mod p的值，如果结果不等于1且不等于p-1，则p一定不是素数。为了提高精度，Miller-Rabin算法通常会多次进行检验。 优点：Miller-Rabin素性检验算法的误判率很低，可以满足绝大部分应用需求。同时，Miller-Rabin算法的时间复杂度比Solovay-Stassen算法更低。 联系：这三种算法都是基于数论定理进行素性检验的，但是原理和具体实现方法有所不同。费马素性检验算法和Solovay-Stassen素性检验算法都有漏报的情况，而Miller-Rabin素性检验算法的误判率较低。因此在实际应用中，Miller-Rabin算法更加常用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿来如此yyy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值