从 3 到 n 的 C++ 素数

Question

我编写了这段代码来打印用户输入的所有介于 3 和 'n' 之间的素数，但在运行时，它什么也没产生。

你能帮忙吗？

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;

    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x < n; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
            }
        }

        if (isPrime)
        {
            cout << n << "";
        }
    }
}

Answer 1

你应该知道的一件事。如果我们开始通过除法运算检查 n 是否为素数，那么检查的次数不应超过 sqrt(n)。

    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x*x < candidate; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
                break;
            }
        }

        if (isPrime)
        {
            cout << candidate << "";
        }
    }

更好的方法是为此使用Sieve of Eratosthenes：

isPrime: initialize with all true
for(int i=2;i*i<=n;i++)
  for(int j =i*i;j<=n;j+=i)
    isPrime[j]=false;   // the if was not needed.

现在您知道了 3 和 n 之间的质数。

Answer 2

在您的代码中可以节省多种效率。最有效的方法（除了对小型 (n 使用预先计算的查找表）是 sieve of Erastosthenes。

这个算法的一个非常幼稚的版本（另见answer by coderredoc）

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
            is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

与您的原始算法相比，基本上反转了candidates 和divisors 上的循环，但仅测试满足divisor*divisor<=candidate 的divisors。

通过意识到我们只需要测试素数除数（这是筛子的主要技巧），可以大幅改进该算法

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        if(is_prime[divisor])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
                is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

这减少了对大型 n 的测试。甚至避免candidates 和divisors 也可以进一步节省效率（空间和时间减少约2 倍）：

std::vector<int> primes(int n)
{
    if(n<2) return {};
    if(n==2) return {2};
    std::vector<bool> is_prime((n+1)>>1,true);
    for(auto divisor=3; divisor*divisor <= n; divisor+=2)
        if(is_prime[divisor>>1])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=2*divisor)
                is_prime[candidate>>1]=false;
    std::vector<int> result(1,2);
    for(auto candidate=3; candidate <= n; candidate+=2)
        if(is_prime[candidate>>1]) result.push_back(candidate);
    return result;
}

该算法的内存访问模式很差（进入is_prime[]），这对于非常大的n 来说是个问题。一种更复杂的方法，分段筛，可以避免这种情况，请参见上面的链接。

Answer 3

改变你的内部循环

    for (int x = 2; x < n; x++)
    {
        if (candidate % x == 0)
        {
            isPrime = false;
        }
    }

到

    for (int x = 2; x < candidate; x++)
    {
        if (candidate % x == 0)
        {
            isPrime = false;
            break;
        }
    }

否则x 最终将成为candidate 本身，而candidate%candidate 是0，这将导致isPrime 成为false。

使用break 语句是因为在确定数字不是素数之后，就不需要进一步的迭代了。

由于您只考虑来自 3 的数字，您可以更改外部循环以节省一些迭代，例如

for (int candidate = 3; candidate < n; candidate+=2)

这将使candidate 每次增加2。这没关系，因为没有大于 2 的偶数不是素数。

另外，如果您考虑的数字范围包括n，您可以将外部for循环修改为

for (int candidate = 3; candidate < n; candidate+=2)

也可以考虑n。

Answer 4

1. 不建议使用 using namespace std; — 因为这会从 std.xml 导入所有标识符。请在 Stack Overflow 上查看此问题。

2. 第二个循环的结束条件应该是candidate而不是n，即

   for (int x = 2; x < candidate; x++)//not before N prime numbers divine up to them
   {
       if (candidate % x == 0)
           isPrime = false;
   }
   

3. 你不应该发出candidate而不是n

Answer 5

我认为这应该可行

#include <iostream>
#include <vector>


int main()
{
    //setup start parameters
    //test sequence
    std::vector<int> test_sequence {2};




    int end_number, start_number;
    start_number = 3;
    //take wished end number
    std::cin >> end_number;

    // test is wished number smaler than start number
    if (start_number < end_number)
    {
        // loop which goes trough every number between start and end number
        for (start_number; start_number <= end_number; start_number++)
        {
            bool isPrime = true;
            //test is this number prime
            for (int n = 0; n < test_sequence.size(); n++)
            {
                if (start_number % test_sequence[n] == 0 && start_number != test_sequence[n] )
                {
                isPrime = false;
                }
            }

            if (isPrime)
            {
                std::cout << start_number << std::endl;
                //hold result for next test
                test_sequence.push_back(start_number);
            }
        }

    }
    else
    {
    std::cout << "Wrong input";
    }

}

前 200 名的结果