C语言求第N个素数答案

【问题标题】：Finding the Nth prime number in C languageC语言求第N个素数
【发布时间】：2015-11-23 16:11:24
【问题描述】：

代码运行得很好，但不是使用“for循环”来迭代到 200000 ，我认为可以有更好的选择，但我很难找到它。我需要帮助来优化这个解决方案。这个解决方案目前花费的时间是 56 毫秒。

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

int isPrime(long long int number)
{
    int i;
    for (i=2; i*i<=number; i++) {
        if (number % i == 0) return 0;
    }
    return 1;
}
int returnNPrime(int N)
{
    int counter = 0;
    int i ;
    if(N == 1) return 2;
    for(i=3;i<200000;i+=2)
    {
        if(isPrime(i))
        {
            counter++;
            if(counter == (N-1))
             return i;
        }
    }
    return 0;
}
   int main(int argc, char *argv[]) 
   {
       printf("%d",returnNPrime(10001));
       return 0;
   }

【问题讨论】：

谷歌“埃拉托色尼筛”
另外搜索“prime number”，你会发现上千个以前的问题。
提示：不要测试大量整数i 和for (i=2; i*i<=number; i++) { if (number % i == 0) return 0;，只需测试一个较小的素数列表。 IOW，随时跟踪他们。
相关：Which is the fastest algorithm to find prime numbers?

标签： c project number-theory

【解决方案1】：

不要设置任意的停止条件。你知道素数列表是无限的，循环最终会停止。像这样写：

int returnNPrime (int N)
{
    int counter = 0;
    int i;
    if (N == 1) return 2;
    for (i = 3; ; i += 2)
    {
        if (isPrime(i))
        {
            counter++;
            if (counter == (N - 1))
                return i;
        }
    }
}

话虽如此，这个解决方案效率低下，因为您不存储以前找到的素数。

试试这样的：

#include <stdio.h>
#include <stdbool.h>

#define N 10001

int primes[N] = { 2, 3 };

int main ()
{
    for (int n = 2; n < N; n++) {
        for (int x = primes[n - 1] + 2; ; x += 2) {
            bool prime = true;
            for (int i = 0; i < n; i++) {
                int p = primes[i];
                if (p * p > x) {
                    break;
                }
                if (x % p == 0) {
                    prime = false;
                    break;
                }
            }
            if (prime) {
                primes[n] = x;
                break;
            }
        }
    }

    printf ("%d\n", primes[N - 1]);
}

【讨论】：

不同意“这种方法被称为 Erathostenes 筛子”。见en.wikipedia.org/wiki/Sieve_of_Eratosthenes
我用你的算法打败了一个朋友，他用 10 秒获得了 200 万个素数，而你的则在 5 秒左右 :D thx，如果你知道更快的方法，请告诉我 - 我已经用谷歌搜索了很多，你的是我发现的最快的（我没有用特殊的库尝试过）。
你能告诉我为什么我们需要使用#define for N而不是简单地初始化N只要N = 10001;
其实我想用户输入N

【解决方案2】：

阅读这篇论文http://cr.yp.to/bib/1996/deleglise.pdf，它描述了如何计算 O (n^(2/3)) 中的质数找到任何素数，而只是计算有多少素数。

有根据地猜测第 n 个素数有多大。假设猜测是 x。使用上面的算法找出有多少个质数

借助一些不错的硬件和足够的耐心，您可以找到最多 n = 10^22 左右的解决方案。

【讨论】：

【解决方案3】：

OP 的方法消耗大量时间，因为它没有利用如果i 不是素数则无需确定余数。

for (i=2; i*i<=number; i++) {
  if (number % i == 0) return 0;

Sieve_of_Eratosthenes 可能更快，但与 OP 的代码相比发生了巨大变化。

怀疑这段代码对于 OP 来说还是太慢了。

以下通过仅尝试针对先前找到的素数进行测试来调整 OP 的代码。它还使用pcandidate / plist[index] 作为终止条件的一部分。一旦计算出pcandidate % plist[index]，优化的编译器通常可以以较低的成本提供此功能。

bool prime_test(const unsigned long *plist, unsigned long long pcandidate) {
  if (pcandidate <= 2) return pcandidate == 2;
  for (size_t index = 0; ; index++) {
    unsigned long long remainder = pcandidate % plist[index];
    if (remainder == 0) return false;
    unsigned long long quotient = pcandidate / plist[index];
    if (quotient < plist[index]) return true;
  }
  assert(0);
  return true;
}

unsigned long long prime_nth(size_t n) {
  unsigned long plist[n+1];
  plist[0] = 2;
  unsigned long long pcandidate = plist[0];
  for (size_t index = 0; index <= n; index++) {
    while (!prime_test(plist, pcandidate)) pcandidate++;
    plist[index] = (unsigned long) pcandidate;
    pcandidate++;
  }
  return plist[n];
}

经典的简化只涉及在奇数中寻找新的素数。还将所有数学更改为unsigned。留给 OP。

【讨论】：