Algorithm 如何找到最近的素数？

有什么好的算法可以找到与给定的

实数

最近的素数吗？我只需要搜索前100个素数

---

目前，我有一组素数存储在一个数组中，我正在一次检查一个数的差（O（n）？。

最简单的方法是将素数存储在一个排序列表中，并修改算法以进行二进制搜索

---

标准的二进制搜索算法会为未命中返回null，但出于您的目的，应该直接修改它。

您应该在数组中对数字进行排序，然后才能使用。在最坏的情况下，该算法的性能为O（logn）。

如果只需要搜索前100个左右的素数，只需创建这些素数的排序表，然后进行二进制搜索。这会让你找到一个质数，或者两个质数之间的一个点，然后你检查哪一个更接近

---

编辑：给定该范围内的素数分布，您可能可以通过使用插值搜索来加快速度（一点点）——而不是总是从表的中间开始，使用线性插值来猜测更准确的起点。第100个素数应该在250左右（猜测一下——我没有检查），因此如果（例如）您想要最接近50的一个，您可以从数组的1/5开始，而不是从一半开始。你几乎可以将素数视为从1开始，因此只需将你想要的数字除以你范围内的最大值，就可以猜到起始点。

相对于素数的排序列表，给定相对较小的目标范围，数组由范围内的所有奇数索引（你知道除了2的特例外，没有偶数素数）并且包含最接近的素数。找到解就变成了O（1）时间方面的问题

我认为第100个素数大约是541。一个270[小]整数的数组就是所需要的

---

鉴于素数密度相对较高（特别是相对于奇数），在1000以下的范围内，这种方法特别有效。（因为这会影响二叉树的大小）

最快的算法？创建一个p[100]=541个元素的查找表，并返回floor（x）的结果，在[2,3]上使用x的特殊逻辑.那就是O（1）.

考虑到手头的任务，到目前为止，答案相当复杂。前100个素数。我将创建一个大小为600的数组，并在每个数组中放置与该数字最接近的素数的值。然后，给定一个要测试的数字，我将使用

floor

和

ceil

函数对其进行上下取整，以获得一个或两个candidate答案。对这些数字的距离进行简单的比较会给你一个非常快速的答案。

如果你想写一个算法，维基百科搜索的结果让我看了另一篇关于的文章。这个算法看起来有点简单，我想递归函数在我看来很适合。（我可能错了。）

如果数组解决方案对您来说不是有效的解决方案（它是适合您的场景的最佳解决方案），您可以尝试下面的代码。在“2或3”情况下，它将检查起始值以外的每个奇数，直到找到素数为止

static int NearestPrime（双原值）
{
高于整数=（整数）数学上限（原件）；
以下整数=（整数）数学地板（原件）；
if（大于查找表，大小为100字节；（无符号字符）
四舍五入实数并使用查找表。
最简单的答案-
每个素数都可以表示为（6*x-1和6*x+1）（2和3除外）。
设数字为N，除以6。
t=N/6；
现在
a=（t-1）*6
b=（t+1）*6
并检查哪一个更接近N。
公共静态布尔值p（int N）{
public static boolean p(int n){

    for(int i=3;i*i<=n;i+=2) {
        if(n%i==0)
            return false;
    }
    return n%2==0? false: true; }

public static void main(String args[]){
    String n="0";
    int x = Integer.parseInt(n);
    int z=x;
    int a=0;
    int i=1;
    while(!p(x)){

      a = i*(int)Math.pow(-1, i);
      i++;
      x+=a;
    }

    System.out.println( (int) Math.abs(x-z));}

对于python中的（int i=3；i*i=2.
：

>>> def nearest_prime(n):
    incr = -1
    multiplier = -1
    count = 1
    while True:
        if prime(n):
            return n
        else:
            n = n + incr
            multiplier = multiplier * -1
            count = count + 1
            incr = multiplier * count

>>> nearest_prime(3)
3
>>> nearest_prime(4)
3
>>> nearest_prime(5)
5
>>> nearest_prime(6)
5
>>> nearest_prime(7)
7
>>> nearest_prime(8)
7
>>> nearest_prime(9)
7
>>> nearest_prime(10)
11

也许我们可以找到左右两个最接近的素数，然后比较得到最接近的一个。（我假设下一个素数在接下来的10次出现中出现）

def leftnearestprimeno（n）：
n1=n-1
而（n1>=0）：
如果是iPrime（n1）：
返回n1
其他：
n1-=1
返回-1
def右侧最接近的基本编号（n）：
n1=n+1
而（n1<（n+10））：
如果是iPrime（n1）：
返回n1
其他：
n1+=1
返回-1
n=int（输入（））
a=最左边的素数（n）
b=最右边的素数（n）
如果（n-a）<（b-n）：
打印（“最近的：”，a）
elif（不适用）>（不适用）：
打印（“最近：”，b）
其他：
打印（“最近的：，a）#如果差值相等，请选择最小值
#价值观
很明显，当值超出int的范围时，它将中断；此外，我希望我没有为您做功课……并且确保在平局的情况下，lut中的值是两个候选值中较大的一个。例如，4->5，而不是3，因此4.1->4->5。不“准确”但这是一个寻找素数的算法。我认为，您可以轻松实现一些Linq到SQL（如果在.NET中）来获取集合中两个数字之间的数字。
>>> def nearest_prime(n):
    incr = -1
    multiplier = -1
    count = 1
    while True:
        if prime(n):
            return n
        else:
            n = n + incr
            multiplier = multiplier * -1
            count = count + 1
            incr = multiplier * count

>>> nearest_prime(3)
3
>>> nearest_prime(4)
3
>>> nearest_prime(5)
5
>>> nearest_prime(6)
5
>>> nearest_prime(7)
7
>>> nearest_prime(8)
7
>>> nearest_prime(9)
7
>>> nearest_prime(10)
11

<?php
$N1Diff = null;
$N2Diff = null;

$n1 = null;
$n2 = null;

$number = 16;

function isPrime($x) {

    for ($i = 2; $i < $x; $i++) {
        if ($x % $i == 0) {
            return false;
        }
    }

    return true;
}


for ($j = $number; ; $j--) {

    if( isPrime($j) ){
       $N1Diff = abs($number - $j);
       $n1 = $j;
       break;
    }
}


for ($j = $number; ; $j++) {

    if( isPrime($j) ){
       $N2Diff = abs($number - $j);
       $n2 = $j;
       break;
    }

}

if($N1Diff < $N2Diff) {

    echo $n1;

} else if ($N1Diff2 < $N1Diff ){
    echo $n2;
}

def leftnearestprimeno(n):
    n1 = n-1
    while(n1 >= 0):
        if isprime(n1):
            return n1
        else:
            n1 -= 1
    return -1

def rightnearestprimeno(n):
    n1 = n+1
    while(n1 < (n+10)):
        if isprime(n1):
            return n1
        else:
            n1 += 1

    return -1


n = int(input())
a = leftnearestprimeno(n)
b = rightnearestprimeno(n)
if (n - a) < (b - n):
    print("nearest: ", a)
elif (n - a) > (b - n):
    print("nearest: ", b)
else: 
    print("nearest: ", a)        #in case the difference is equal, choose min 
                                 #value