自然地,因为bool isprime(number)
会有可以查询的数据结构。
我定义了最佳算法,该算法将生成在((1,N])范围内具有最低内存消耗的数据结构,其中N是常数。这
只是我要查找的示例:我可以表示每个奇数以一位为例,例如对于给定的数字范围(1,10],从3开始:1110
下面的字典可以压缩更多,对吧?我可以通过一些工作消除5的倍数,但是以1、3、7或9结尾的数字必须存在于位数组中。
我该如何解决这个问题?
自然地,因为bool isprime(number)
会有可以查询的数据结构。
我定义了最佳算法,该算法将生成在((1,N])范围内具有最低内存消耗的数据结构,其中N是常数。这
只是我要查找的示例:我可以表示每个奇数以一位为例,例如对于给定的数字范围(1,10],从3开始:1110
下面的字典可以压缩更多,对吧?我可以通过一些工作消除5的倍数,但是以1、3、7或9结尾的数字必须存在于位数组中。
我该如何解决这个问题?
Answers:
用于一般素数测试的最快算法是AKS。Wikipedia文章详细介绍了该文章,并链接到原始论文。
如果要查找大数,请查看具有特殊形式的素数,例如Mersenne素数。
我通常实现的算法(易于理解和编码)如下(在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
仅查看此形式的除数的事实。
有时,如果我真的想要速度并且范围有限,我会根据费马小定理实施伪素数测试。如果我真的想要更高的速度(即完全避免使用O(sqrt(N))算法),则可以预先计算误报(请参阅Carmichael数)并进行二进制搜索。这是迄今为止我执行过的最快的测试,唯一的缺点是范围有限。
i
和w
是什么,以及形式6k-1
和是什么意思6k+1
?感谢您的见解和代码示例(我正试图理解)
sqrt
的n
一次,相比i
于它,而不是计算i * i
循环的每个周期?
我认为最好的方法是使用以前的方法。
N
互联网上有头等素数的清单,数量N
至少可达五千万。下载文件并使用它们,它可能比您将想到的任何其他方法都快得多。
如果您想要一种用于生成自己的素数的实际算法,则Wikipedia在这里有关于素数的各种好东西,包括用于执行素数的各种方法的链接以及此处的素数测试,包括基于概率的方法和快速确定性方法。
应该齐心协力找到头十亿个(甚至更多)的素数,并将它们发布在网上某个地方,以便人们可以一遍又一遍地......-)
x
一旦建成,第一个质数的列表就不太可能是不完整的:-)
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;
}
这只是上述AKS算法的 C ++实现
What is the algorithm that produces a data structure with lowest memory consumption for the range (1, N]
?
How does (n%i == 0 || n%(i+2) == 0) correspond to 6n+1 & 6n-1?
答案的一部分是针对的不同角色n
,另一个是6n + 1和6n-1,相当于(6n-1)+0和(6n-1)+ 2 *。
5
和提供正确的结果7
。
我比较了最流行的建议的效率,以确定数字是否为质数。我用python 3.6
的ubuntu 17.10
; 我测试的数字最高为100.000(您可以使用下面的代码测试更大的数字)。
第一个图比较了这些函数(在我的答案中有进一步解释),表明当增加数字时,最后一个函数的增长速度不如第一个函数快。
在第二个图表中,我们可以看到在质数的情况下时间稳定增长,但是非质数的时间却没有那么快地增长(因为大多数可以在早期被消除)。
这是我使用的功能:
def is_prime_1(n):
return n > 1 and all(n % i for i in range(2, int(math.sqrt(n)) + 1))
这个答案使用了某种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
这个答案包括一个带有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
然后,我将其他答案中的一些想法融合到一个新的答案中:
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()
根据Wikipedia的说法,Eratosthenes筛具有复杂性O(n * (log n) * (log log n))
并且需要O(n)
内存 -因此,如果您不进行特别大的测试,这是一个不错的起点。
可以使用sympy。
import sympy
sympy.ntheory.primetest.isprime(33393939393929292929292911111111)
True
来自sympy文档。第一步是寻找微不足道的因素,如果发现这些因素,便可以迅速获得回报。接下来,如果筛子足够大,请在筛子上使用二等分搜索。对于小数,使用已知范围内没有反例的碱基执行一组确定性Miller-Rabin测试。最后,如果该数字大于2 ^ 64,则执行强大的BPSW测试。尽管这是一个可能的主要测试,我们相信存在反例,但尚无已知的反例
memory consumption
?
在Python 3中:
def is_prime(a):
if a < 2:
return False
elif a!=2 and a % 2 == 0:
return False
else:
return all (a % i for i in range(3, int(a**0.5)+1))
说明: 质数是只能被其自身和1整除的数字。例如:2,3,5,7 ...
1)如果a <2:如果“ a”小于2,则不是质数。
2)elif a!= 2和%2 == 0:如果“ a”可以被2整除,那么它绝对不是质数。但是,如果a = 2,我们不想对其进行评估,因为它是质数。因此条件a!= 2
3)返回all(range(3,int(a 0.5)+1)中i的i个%i):**首先看一下all()命令在python中的作用。从3开始,我们将“ a”除以其平方根(a ** 0.5)。如果“ a”是可分割的,则输出将为False。为什么是平方根?假设a = 16。16的平方根=4。我们不需要评估直到15。我们只需要检查直到4就可以说它不是素数。
额外: 一个循环,用于查找范围内的所有素数。
for i in range(1,100):
if is_prime(i):
print("{} is a prime number".format(i))
range()
……中的“第2步” )
Python 3:
def is_prime(a):
return a > 1 and all(a % i for i in range(2, int(a**0.5) + 1))
对于大数,您不能简单地天真地检查候选数N是否可被除sqrt(N)之外的任何数整除。还有更多可扩展的测试,例如Miller-Rabin素数测试。下面有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。
参加聚会太晚了,但希望对您有所帮助。如果您要寻找大的素数,则这是相关的:
要测试较大的奇数,您需要使用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的机会是不是(这很可能是您的硬件出现故障...)。
我有一个素数函数可以工作到(2 ^ 61)-1在这里:
from math import sqrt
def isprime(num): num > 1 and return all(num % x for x in range(2, int(sqrt(num)+1)))
说明:
该all()
函数可以重新定义为:
def all(variables):
for element in variables:
if not element: return False
return True
该all()
函数只是通过一系列布尔值/数字,然后返回False
0或False
。
该sqrt()
函数只是做一个数字的平方根。
例如:
>>> from math import sqrt
>>> sqrt(9)
>>> 3
>>> sqrt(100)
>>> 10
该num % x
部分返回num / x 的余数。
最后,range(2, int(sqrt(num)))
意味着它将创建一个列表,该列表以2开始,以3结尾int(sqrt(num)+1)
有关范围的更多信息,请访问此网站!
该num > 1
部分只是检查变量num
是否大于1,因为1和0不被视为素数。
我希望这可以帮助:)
the best
算法,甚至是一个好的算法。
素数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
}
质数是只能被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。
simplest
是对best的一种有效解释:)问题是检查数字是否为质数的最佳算法是什么?:检查除数是否number / 2 < i < number
有利?那number < i*i
呢 其他3³答案中可以理解的是什么?
让我为您建议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
}
最小的内存?这不是最小的,但是是朝着正确方向迈出的一步。
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
。
我认为最快的方法之一就是我的方法。
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;
}
与提到的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;
}
#!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.
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))
您可以尝试这样的事情。
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()
None
。
先前的大多数答案都是正确的,但这是测试数字是否为质数的另一种方法。作为复习,素数是整数大于1的唯一因素是1和它本身。(来源)
解:
通常,您可以建立一个循环并开始测试您的数字,以查看数字是否可以被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")
我们可以使用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");
在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))。也许有人觉得它有用。
这是我对答案的看法:
def isprime(num):
return num <= 3 or (num + 1) % 6 == 0 or (num - 1) % 6 == 0
如果以下任何属性为True,则该函数将返回True。这些属性在数学上定义了素数。
>>> isprime(25)
返回True
。您正在检查一个非常简单的必要条件(除以2或3),但这还不够。
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;
}