检查数字是否为素数的最佳算法是什么？

Question

只是我正在寻找的一个例子：我可以用一点代表每个奇数对于给定的数字范围（1,10），从3开始：

1110

以下字典可以更加正确吗？我可以通过一些工作来消除五的倍数，但是以1，3,7或9结尾的数字必须存在于位数组中。希望这能澄清我想要的东西。

我正在寻找最好的算法，检查数字是否为素数，即布尔函数：

bool isprime(number);

我想知道实现此功能的最佳算法。当然，我可以查询一个数据结构。我定义最佳算法，作为生成数据结构的算法，该数据结构的范围（1，N）的内存消耗最低，其中N是常量。

Answer 1

一般素数测试的最快算法是AKS。维基百科的文章描述了它的长度和原始论文的链接。

如果您想查找大数字，请查看具有Mersenne primes等特殊格式的素数。

我通常实现的算法（易于理解和编码）如下（在Python中）：

def isprime(n):
    """Returns True if n is prime."""
    if n == 2:
        return True
    if n == 3:
        return True
    if n % 2 == 0:
        return False
    if n % 3 == 0:
        return False

    i = 5
    w = 2

    while i * i <= n:
        if n % i == 0:
            return False

        i += w
        w = 6 - w

    return True

它是经典O(sqrt(N))算法的变体。它使用了一个素数（除了2和3）具有6k - 1或6k + 1形式的事实，并且只看这种形式的除数。

有时，如果我真的想要速度并且范围有限，我会实施基于Fermat's little theorem的伪素数测试。如果我真的想要更快的速度（即完全避免使用O（sqrt（N））算法），我会预先计算误报（参见Carmichael数字）并进行二分搜索。这是迄今为止我实施过的最快的测试，唯一的缺点是范围有限。

Answer 2

有很多方法可以primality test。

您没有真正的数据结构可供查询。如果你要测试很多数字，你应该运行一个probabilistic test，因为它们更快，然后用deterministic test跟进它以确保数字是素数。

你应该知道最快算法背后的数学不适合胆小的人。

Answer 3

在我看来，最好的方法是使用以前的方法。

互联网上有N个素数列表，其中N最多可延伸至fifty million。下载文件并使用它们，它可能比你想出的任何其他方法快得多。

如果你想要一个真正的算法来制作你自己的素数，维基百科在素数here上有各种好东西，包括各种方法的链接，以及初步测试here，两者都有基于概率和快速确定的方法。

应该齐心协力寻找最初的十亿（甚至更多）素数并让它们在网上发布，以便人们可以一遍又一遍地停止做同样的工作......： - ）

Answer 4

bool isPrime(int n)
{
    // Corner cases
    if (n <= 1)  return false;
    if (n <= 3)  return true;

    // This is checked so that we can skip 
    // middle five numbers in below loop
    if (n%2 == 0 || n%3 == 0) return false;

    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;

    return true;
}
this is just c++ implementation of above  AKS algorithm

https://en.wikipedia.org/wiki/AKS_primality_test

Answer 5

根据维基百科的说法，the Sieve of Eratosthenes有complexity O(n * (log n) * (log log n)) and requires O(n) memory - 所以如果您没有针对特别大的数字进行测试，这是一个非常好的起点。

Answer 6

一个人可以使用sympy 。

import sympy

sympy.ntheory.primetest.isprime(33393939393929292929292911111111)

True

来自sympy文档。第一步是寻找微不足道的因素，如果发现这些因素，便可以迅速获得回报。接下来，如果筛子足够大，请在筛子上使用二等分搜索。对于少量样本，使用确定范围内没有反例的碱基执行一组确定性Miller-Rabin测试。最后，如果该数字大于2 ^ 64，则执行强的BPSW测试。虽然这是一个可能的主要检验，我们相信存在反例，但尚无已知的反例

Answer 7

我比较了最流行建议的效率，以确定数字是否为质数。我在python 3.6上使用了ubuntu 17.10；我测试的数字最高为100.000（您可以使用下面的代码测试更大的数字）。

这第一个图比较了这些函数（在我的答案中作了进一步解释），表明当增加数字时，最后一个函数的增长速度不如第一个函数快。

在第二个图表中，我们可以看到在质数的情况下时间稳定增长，但是非质数的时间却没有那么快增长（因为其中大多数可以在早期被消除）。

这是我使用的功能：

1. this answer和this answer建议使用all()的构造：

   def is_prime_1(n):
       return n > 1 and all(n % i for i in range(2, int(math.sqrt(n)) + 1))
   

2. This answer使用了某种while循环：

   def is_prime_2(n):
       if n <= 1:
           return False
       if n == 2:
           return True
       if n == 3:
           return True
       if n % 2 == 0:
           return False
       if n % 3 == 0:
           return False
   
       i = 5
       w = 2
       while i * i <= n:
           if n % i == 0:
               return False
           i += w
           w = 6 - w
   
       return True
   

3. This answer包含一个带有for循环的版本：

   def is_prime_3(n):
       if n <= 1:
           return False
   
       if n % 2 == 0 and n > 2:
           return False
   
       for i in range(3, int(math.sqrt(n)) + 1, 2):
           if n % i == 0:
               return False
   
       return True
   

4. 然后我将其他答案中的一些想法融合到一个新的答案中：

   def is_prime_4(n):
       if n <= 1:          # negative numbers, 0 or 1
           return False
       if n <= 3:          # 2 and 3
           return True
       if n % 2 == 0 or n % 3 == 0:
           return False
   
       for i in range(5, int(math.sqrt(n)) + 1, 2):
           if n % i == 0:
               return False
   
       return True
   

---

这是我用来比较变体的脚本：

import math
import pandas as pd
import seaborn as sns
import time
from matplotlib import pyplot as plt


def is_prime_1(n):
    ...
def is_prime_2(n):
    ...
def is_prime_3(n):
    ...
def is_prime_4(n):
    ...

default_func_list = (is_prime_1, is_prime_2, is_prime_3, is_prime_4)

def assert_equal_results(func_list=default_func_list, n):
    for i in range(-2, n):
        r_list = [f(i) for f in func_list]
        if not all(r == r_list[0] for r in r_list):
            print(i, r_list)
            raise ValueError
    print('all functions return the same results for integers up to {}'.format(n))

def compare_functions(func_list=default_func_list, n):
    result_list = []
    n_measurements = 3

    for f in func_list:
        for i in range(1, n + 1):
            ret_list = []
            t_sum = 0
            for _ in range(n_measurements):
                t_start = time.perf_counter()
                is_prime = f(i)
                t_end = time.perf_counter()

                ret_list.append(is_prime)
                t_sum += (t_end - t_start)

            is_prime = ret_list[0]
            assert all(ret == is_prime for ret in ret_list)
            result_list.append((f.__name__, i, is_prime, t_sum / n_measurements))

    df = pd.DataFrame(
        data=result_list,
        columns=['f', 'number', 'is_prime', 't_seconds'])
    df['t_micro_seconds'] = df['t_seconds'].map(lambda x: round(x * 10**6, 2))
    print('df.shape:', df.shape)

    print()
    print('', '-' * 41)
    print('| {:11s} | {:11s} | {:11s} |'.format(
        'is_prime', 'count', 'percent'))
    df_sub1 = df[df['f'] == 'is_prime_1']
    print('| {:11s} | {:11,d} | {:9.1f} % |'.format(
        'all', df_sub1.shape[0], 100))
    for (is_prime, count) in df_sub1['is_prime'].value_counts().iteritems():
        print('| {:11s} | {:11,d} | {:9.1f} % |'.format(
            str(is_prime), count, count * 100 / df_sub1.shape[0]))
    print('', '-' * 41)

    print()
    print('', '-' * 69)
    print('| {:11s} | {:11s} | {:11s} | {:11s} | {:11s} |'.format(
        'f', 'is_prime', 't min (us)', 't mean (us)', 't max (us)'))
    for f, df_sub1 in df.groupby(['f', ]):
        col = df_sub1['t_micro_seconds']
        print('|{0}|{0}|{0}|{0}|{0}|'.format('-' * 13))
        print('| {:11s} | {:11s} | {:11.2f} | {:11.2f} | {:11.2f} |'.format(
            f, 'all', col.min(), col.mean(), col.max()))
        for is_prime, df_sub2 in df_sub1.groupby(['is_prime', ]):
            col = df_sub2['t_micro_seconds']
            print('| {:11s} | {:11s} | {:11.2f} | {:11.2f} | {:11.2f} |'.format(
                f, str(is_prime), col.min(), col.mean(), col.max()))
    print('', '-' * 69)

    return df

运行函数compare_functions(n=10**5)（数字最多100.000），我得到以下输出：

df.shape: (400000, 5)

 -----------------------------------------
| is_prime    | count       | percent     |
| all         |     100,000 |     100.0 % |
| False       |      90,408 |      90.4 % |
| True        |       9,592 |       9.6 % |
 -----------------------------------------

 ---------------------------------------------------------------------
| f           | is_prime    | t min (us)  | t mean (us) | t max (us)  |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_1  | all         |        0.57 |        2.50 |      154.35 |
| is_prime_1  | False       |        0.57 |        1.52 |      154.35 |
| is_prime_1  | True        |        0.89 |       11.66 |       55.54 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_2  | all         |        0.24 |        1.14 |      304.82 |
| is_prime_2  | False       |        0.24 |        0.56 |      304.82 |
| is_prime_2  | True        |        0.25 |        6.67 |       48.49 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_3  | all         |        0.20 |        0.95 |       50.99 |
| is_prime_3  | False       |        0.20 |        0.60 |       40.62 |
| is_prime_3  | True        |        0.58 |        4.22 |       50.99 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_4  | all         |        0.20 |        0.89 |       20.09 |
| is_prime_4  | False       |        0.21 |        0.53 |       14.63 |
| is_prime_4  | True        |        0.20 |        4.27 |       20.09 |
 ---------------------------------------------------------------------

然后，运行功能compare_functions(n=10**6)（最大为1.000.000），我得到以下输出：

df.shape: (4000000, 5)

 -----------------------------------------
| is_prime    | count       | percent     |
| all         |   1,000,000 |     100.0 % |
| False       |     921,502 |      92.2 % |
| True        |      78,498 |       7.8 % |
 -----------------------------------------

 ---------------------------------------------------------------------
| f           | is_prime    | t min (us)  | t mean (us) | t max (us)  |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_1  | all         |        0.51 |        5.39 |     1414.87 |
| is_prime_1  | False       |        0.51 |        2.19 |      413.42 |
| is_prime_1  | True        |        0.87 |       42.98 |     1414.87 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_2  | all         |        0.24 |        2.65 |      612.69 |
| is_prime_2  | False       |        0.24 |        0.89 |      322.81 |
| is_prime_2  | True        |        0.24 |       23.27 |      612.69 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_3  | all         |        0.20 |        1.93 |       67.40 |
| is_prime_3  | False       |        0.20 |        0.82 |       61.39 |
| is_prime_3  | True        |        0.59 |       14.97 |       67.40 |
|-------------|-------------|-------------|-------------|-------------|
| is_prime_4  | all         |        0.18 |        1.88 |      332.13 |
| is_prime_4  | False       |        0.20 |        0.74 |      311.94 |
| is_prime_4  | True        |        0.18 |       15.23 |      332.13 |
 ---------------------------------------------------------------------

---

我使用以下脚本绘制结果：

def plot_1(func_list=default_func_list, n):
    df_orig = compare_functions(func_list=func_list, n=n)
    df_filtered = df_orig[df_orig['t_micro_seconds'] <= 20]
    sns.lmplot(
        data=df_filtered, x='number', y='t_micro_seconds',
        col='f',
        # row='is_prime',
        markers='.',
        ci=None)

    plt.ticklabel_format(style='sci', axis='x', scilimits=(3, 3))
    plt.show()

Answer 8

对党来说太晚了，但希望这会有所帮助。如果您正在寻找大素数，这是相关的：

要测试大的奇数，您需要使用Fermat测试和/或Miller-Rabin测试。

这些测试使用模幂运算非常昂贵，对于n位求幂，您至少需要n大整数乘法和n大整数分区。这意味着模幂运算的复杂度为O（n³）。

所以在使用大枪之前，你需要进行相当多的试验。但是不要天真地做，有办法快速做到这一点。 首先将尽可能多的素数相乘，然后将许多素数组合成用于大整数的词。如果使用32位字，则乘以3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29 = 3234846615，并使用欧几里德算法计算最大公约数。在第一步之后，数字减少到字大小以下并继续算法而不执行完整的大整数除法。如果GCD！= 1，这意味着你乘以的素数之一除以数字，所以你有一个证明它不是素数。然后继续31 * 37 * 41 * 43 * 47 = 95041567，依此类推。

一旦你以这种方式测试了几百（或千）个素数，你可以做40轮Miller-Rabin测试以确认数字是素数，经过40轮你可以确定数字是素数只有2 ^ - 80它不是机会（它更可能是你的硬件故障......）。

Answer 9

Python 3：

def is_prime(a):
    return a > 1 and all(a % i for i in range(2, int(a**0.5) + 1))

Answer 10

对于大数，您不能简单地天真地检查候选数N是否可被除sqrt（N）以外的任何数字整除。还有更多可扩展的测试，例如Miller-Rabin primality test。在下面，您可以在python中实现：

def is_prime(x):
    """Fast implementation fo Miller-Rabin primality test, guaranteed to be correct."""
    import math
    def get_sd(x):
        """Returns (s: int, d: int) for which x = d*2^s """
        if not x: return 0, 0
        s = 0
        while 1:
            if x % 2 == 0:
                x /= 2
                s += 1
            else:
                return s, x
    if x <= 2:
        return x == 2
    # x - 1 = d*2^s
    s, d = get_sd(x - 1)
    if not s:
        return False  # divisible by 2!
    log2x = int(math.log(x) / math.log(2)) + 1
    # As long as Riemann hypothesis holds true, it is impossible
    # that all the numbers below this threshold are strong liars.
    # Hence the number is guaranteed to be a prime if no contradiction is found.
    threshold = min(x, 2*log2x*log2x+1)
    for a in range(2, threshold):
        # From Fermat's little theorem if x is a prime then a^(x-1) % x == 1
        # Hence the below must hold true if x is indeed a prime:
        if pow(a, d, x) != 1:
            for r in range(0, s):
                if -pow(a, d*2**r, x) % x == 1:
                    break
            else:
                # Contradicts Fermat's little theorem, hence not a prime.
                return False
    # No contradiction found, hence x must be a prime.
    return True

您可以使用它来查找巨大的素数：

x = 10000000000000000000000000000000000000000000000000000000000000000000000000000
for e in range(1000):
    if is_prime(x + e):
        print('%d is a prime!' % (x + e))
        break

# 10000000000000000000000000000000000000000000000000000000000000000000000000133 is a prime!

如果您要测试随机整数，则可能需要先测试候选数是否可以被小于1000的任何质数整除，然后再致电Miller-Rabin。这将帮助您过滤掉明显的非质数，例如10444344345。

Answer 11

让我为您建议64位整数的完美解决方案。抱歉使用C＃。您尚未在第一篇文章中将其指定为python。希望您可以找到一个简单的modPow函数并轻松进行分析。

public static bool IsPrime(ulong number)
{
    return number == 2 
        ? true 
        : (BigInterger.ModPow(2, number, number) == 2 
            ? (number & 1 != 0 && BinarySearchInA001567(number) == false) 
            : false)
}

public static bool BinarySearchInA001567(ulong number)
{
    // Is number in list?
    // todo: Binary Search in A001567 (https://oeis.org/A001567) below 2 ^ 64
    // Only 2.35 Gigabytes as a text file http://www.cecm.sfu.ca/Pseudoprimes/index-2-to-64.html
}

Answer 12

在Python中：

def is_prime(n):
    return not any(n % p == 0 for p in range(2, int(math.sqrt(n)) + 1))

从数学形式主义到Python的更直接转换将使用 all（n％p！= 0 ...），但这需要严格评估p的所有值。如果找到True值，不是任何版本可以提前终止。

Answer 13

素数javascript的最佳算法

 function isPrime(num) {
      if (num <= 1) return false;
      else if (num <= 3) return true;
      else if (num % 2 == 0 || num % 3 == 0) return false;
      var i = 5;
      while (i * i <= num) {
        if (num % i == 0 || num % (i + 2) == 0) return false;
        i += 6;
      }
      return true
    }

Answer 14

import math
import time


def check_prime(n):

    if n == 1:
        return False

    if n == 2:
        return True

    if n % 2 == 0:
        return False

    from_i = 3
    to_i = math.sqrt(n) + 1

    for i in range(from_i, int(to_i), 2):
        if n % i == 0:
            return False
    return True

Answer 15

借助Java-8流和lambda，可以在几行中这样实现：

public static boolean isPrime(int candidate){
        int candidateRoot = (int) Math.sqrt( (double) candidate);
        return IntStream.range(2,candidateRoot)
                .boxed().noneMatch(x -> candidate % x == 0);
    }

性能应接近 O（sqrt（N））。也许有人觉得它有用。

Answer 16

### is_prime(number) = 
### if number % p1 !=0 for all p1(prime numbers)  < (sqrt(number) + 1), 
### filter numbers that are not prime from divisors

import math
def check_prime(N, prime_numbers_found = [2]):
    if N == 2:
        return True
    if int(math.sqrt(N)) + 1 > prime_numbers_found[-1]:
        divisor_range = prime_numbers_found + list(range(prime_numbers_found[-1] + 1, int(math.sqrt(N)) + 1+ 1))
    else:
        divisor_range = prime_numbers_found
    #print(divisor_range, N)

    for number in divisor_range:
        if number not in prime_numbers_found:
             if check_prime(number, prime_numbers_found):
                prime_numbers_found.append(number)
                if N % number == 0:
                    return False
        else:
            if N % number == 0:
                return False

    return True

Answer 17

bool isPrime(int n) {
if(n <= 3)
    return (n > 1)==0? false: true;
else if(n%2 == 0 || n%3 == 0)
    return false;

int i = 5;

while(i * i <= n){
    if(n%i == 0 || (n%(i+2) == 0))
        return false;
    i = i + 6;
}

return true;
}

对于任何数字，用于检查数字是否为质数的最小迭代次数可以为2到该数字的平方根。为了减少迭代次数，甚至更多，我们可以检查数字是否可以被2或3整除，因为可以通过检查数字是否可以被2或3整除来消除最大数。此外，任何大于3的素数都可以表示为6k +1或6k-1。因此迭代可以从6k + 1到数字的平方根。

Answer 18

素数是只能被1和其自身整除的任何数字。所有其他数字称为 composite 。

查找素数的最简单方法是检查输入数字是否为复合数字：

    function isPrime(number) {
        // Check if a number is composite
        for (let i = 2; i < number; i++) {
            if (number % i === 0) {
                return false;
            }
        }
        // Return true for prime numbers
        return true;
    }

程序必须将number的值除以所有整数，从1直至其值。如果这个数字不仅可以被一个整数除以本身，那么它就是一个复合数字。

变量i的初始值必须为2，因为质数和复合数均可以被1除。

    for (let i = 2; i < number; i++)

然后，出于相同的原因，i小于number。质数和复合数都可以自己平均分配。因此，没有理由对其进行检查。

然后我们检查变量是否可以使用余数运算符平均分配。

    if (number % i === 0) {
        return false;
    }

如果余数为零，则意味着number可以被平均除，因此是一个复合数字并返回false。

如果输入的数字不符合条件，则表示它是质数，并且该函数返回true。

Answer 19

这是我的答案：

def isprime(num):
    return num <= 3 or (num + 1) % 6 == 0 or (num - 1) % 6 == 0

如果以下任何属性为True，则该函数将返回True。这些属性从数学上定义了素数。

1. 该数字小于或等于3
2. 数字+1被6整除
3. 数字-1被6整除

Answer 20

我们可以使用Java流在O（sqrt（n））中实现此功能；考虑到noneMatch是一种shortCircuiting方法，当发现不需要用于确定结果的操作时，它将停止操作：

Scanner in = new Scanner(System.in);
int n = in.nextInt();
System.out.println(n == 2 ? "Prime" : IntStream.rangeClosed(2, ((int)(Math.sqrt(n)) + 1)).noneMatch(a -> n % a == 0) ? "Prime" : "Not Prime");

Answer 21

以前的大多数答案都是正确的，但这是测试数字是否为质数的另一种方法。回顾一下，素数是大于1的整数，其唯一因素是1及其本身。（source）

解决方案：

通常，您可以建立一个循环并开始测试您的数字，以查看数字是否可以被1,2,3整除...直到您正在测试的数字...等，但是为了减少检查时间，您可以对将您的数字乘以数字价值的一半，因为数字不能被其价值一半以上的东西完全整除。 例如，如果您想看到100是质数，则可以循环查看最多50。

实际代码：

def find_prime(number):
    if(number ==1):
        return False
    # we are dividiing and rounding and then adding the remainder to increment !
    # to cover not fully divisible value to go up forexample 23 becomes 11
    stop=number//2+number%2
    #loop through up to the half of the values
    for item in range(2,stop):
        if number%item==0:
           return False
        print(number)
    return True


if(find_prime(3)):
    print("it's a prime number !!")
else:
    print("it's not a prime")  

Answer 22

您可以尝试这样的事情。

def main():
    try:
        user_in = int(input("Enter a number to determine whether the number is prime or not: "))
    except ValueError:
        print()
        print("You must enter a number!")
        print()
        return
    list_range = list(range(2,user_in+1))
    divisor_list = []
    for number in list_range:
        if user_in%number==0:
            divisor_list.append(number)
    if len(divisor_list) < 2:
        print(user_in, "is a prime number!")
        return
    else:
        print(user_in, "is not a prime number!")
        return
main()

Answer 23

myInp=int(input("Enter a number: "))
if myInp==1:
    print("The number {} is neither a prime not composite no".format(myInp))
elif myInp>1:
    for i in range(2,myInp//2+1):
        if myInp%i==0:
            print("The Number {} is not a prime no".format(myInp))
            print("Because",i,"times",myInp//i,"is",myInp)
            break
    else:
        print("The Number {} is a prime no".format(myInp))
else:
    print("Alas the no {} is a not a prime no".format(myInp))

Answer 24

查找某个范围内的数字是否为素数。

#!usr/bin/python3

def prime_check(*args):
    for arg in args:
        if arg > 1:     # prime numbers are greater than 1
            for i in range(2,arg):   # check for factors
                if(arg % i) == 0:
                    print(arg,"is not Prime")
                    print(i,"times",arg//i,"is",arg)
                    break
            else:
                print(arg,"is Prime")

            # if input number is less than
            # or equal to 1, it is not prime
        else:
            print(arg,"is not Prime")
    return

# Calling Now
prime_check(*list(range(101)))  # This will check all the numbers in range 0 to 100 
prime_check(#anynumber)         # Put any number while calling it will check.

Answer 25

与已提到的AKS算法类似的想法

public static boolean isPrime(int n) {

    if(n == 2 || n == 3) return true;
    if((n & 1 ) == 0 || n % 3 == 0) return false;
    int limit = (int)Math.sqrt(n) + 1;
    for(int i = 5, w = 2; i <= limit; i += w, w = 6 - w) {
        if(n % i == 0) return false;
        numChecks++;
    }
    return true;
}

Answer 26

我认为最快的方法之一是我制作的方法。

void prime(long long int number) {
    // Establishing Variables
    long long int i = 5;
    int w = 2;
    const long long int lim = sqrt(number);

    // Gets 2 and 3 out of the way
    if (number == 1) { cout << number << " is hard to classify. \n";  return; }
    if (number == 2) { cout << number << " is Prime. \n";  return; }
    if (number == 3) { cout << number << " is Prime. \n";  return; }

    // Tests Odd Ball Factors
    if (number % 2 == 0) { cout << number << " is not Prime. \n";  return; }
    if (number % 3 == 0) { cout << number << " is not Prime. \n";  return; }

    while (i <= lim) {
        if (number % i == 0) { cout << number << " is not Prime. \n";  return; }
        // Tests Number
        i = i + w; // Increments number
        w = 6 - i; // We already tested 2 and 3
        // So this removes testing multepules of this
    }
    cout << number << " is Prime. \n"; return;
}

Answer 27

最小的记忆？这不是最小的，但是朝着正确的方向迈出了一步。

class PrimeDictionary {
    BitArray bits;

    public PrimeDictionary(int n) {
        bits = new BitArray(n + 1);
        for (int i = 0; 2 * i + 3 <= n; i++) {
            bits.Set(i, CheckPrimality(2 * i + 3));
        }
    }

    public PrimeDictionary(IEnumerable<int> primes) {
        bits = new BitArray(primes.Max());
        foreach(var prime in primes.Where(p => p != 2)) {
            bits.Set((prime - 3) / 2, true);
        }
    }

    public bool IsPrime(int k) {
        if (k == 2) {
            return true;
        }
        if (k % 2 == 0) {
            return false;
        }
        return bits[(k - 3) / 2];
    }
}

当然，您必须指定CheckPrimality的定义。

Answer 28

public static boolean isPrime(int number) {
 if(number < 2)
   return false;
 else if(number == 2 || number == 3)
        return true;
      else {
        for(int i=2;i<=number/2;i++)
           if(number%i == 0)
             return false;
           else if(i==number/2)
                return true;
      }
    return false;
}

Answer 29

这是最快的方法：

def divisors(integer):
    result = []
    i = 2 
    j = integer/2
    while(i <= j):
        if integer % i == 0:
            result.append(i)
            if i != integer//i:
                result.append(integer//i)
        i += 1
        j = integer//i
    if len(result) > 0:
        return sorted(result)
    else:
        return f"{integer} is prime"

Answer 30

当我必须进行快速验证时，我会根据低于输入平方根的数字之间的基本除法来编写此简单代码。

def isprime(n):
    if n%2==0:
        return n==2
    else:
        cota = int(n**0.5)+1
        for ind in range(3,2,cota):
            if n%ind==0:
                print(ind)
                return False
    is_one = n==1
    return True != is_one

isprime(22783)

• 最后一个True != n==1是为了避免出现n=1这种情况。

Answer 31

素数的第一个规则：如果除以2等于整数或整数。

使用任何一种计算机语言来知道的最快方法是使用字符串而不是数学进行类型匹配。匹配DOT中的字符串Float。

• 将其除以2 ,, n = n / 2
• 将其转换为字符串，n = string（n）
• 如果为“。”旅店： {    printf“是的，我是总理！”
  }