打印 n 对质数，C++

Question

我需要编写一个程序来打印 n 对质数，这些对是：

pq

其中 p 和 q 是素数，q = p+2。

输入示例：

n = 3

3 5 // 5 7 // 11 13 //

我几乎无处可去......所以，有人吗？

#include <iostream>
#include <cmath>

int twins(int n)
{
    for (int i = 0; i < n; i++)
    {
        ???
     }
}

int main()

{
    std::cout<<twins(5);
    return 0;
}

Answer 1

这是这种野兽的顶级简单伪代码：

def printTwinPrimes(count):
    currNum = 3
    while count > 0:
        if isPrime(currNum) and isPrime(currNum + 2):
            print currnum, currnum + 2
            count = count - 1
        currNum = currNum + 2

它只是从3开始（因为我们知道2,4作为双质数对是不可能的，因为4是合数）。 对于每种可能性，它检查它是否构成双质数对，如果是，则打印它。

所以你需要做的（除了将它翻译成真正的代码）就是创建isPrime() ，网上有无数的例子。

为了完整起见，这里有一个简单的，绝不是最有效的，但对于初学者来说已经足够了：

def isPrime(num):
    if num < 2:
        return false
    root = 2
    while root * root <= num:
        if num % root == 0:
            return false
        root = root + 1
    return true

尽管您可以通过使用除两个或三个以外的所有素数都具有6n±1, n >= 1 ^(a)形式这一事实来提高效率：

def isPrime(num):
    if num < 2: return false
    if num == 2 or num == 3: return true
    if num % 2 == 0 or num % 3 == 0: return false
    if num % 6 is neither 1 nor 5: return false

    root = 5
    adder = 2                   # initial adder 2, 5 -> 7
    while root * root <= num:
        if num % root == 0:
            return false
        root = root + adder     # checks 5, 7, 11, 13, 17, 19, ...
        adder = 6 - adder       # because alternate 2, 4 to give 6n±1
    return true

---

实际上，您可以使用这种可整除技巧来查看存储为字符串的任意大数是否可能是素数。 你只需要检查它下面或上面的数字是否能被六整除。 如果不是，这个数肯定不是素数。 如果是这样，则需要更多（更慢）的检查来完全确定素性。

只有能被二和三整除的数才能被六整除。 前者很容易分辨，偶数以偶数结尾。

但是也很容易判断它是否可以被3整除，因为在这种情况下，单个数字的总和也可以被 3 整除。 例如，让我们使用31415926535902718281828459 。

所有这些数字的总和是118 。 我们如何判断这是否是三的倍数？ 为什么，递归使用完全相同的技巧：

118: 1 + 1 + 8 = 10
 10: 1 + 0     = 1

一旦你减少到一位数，如果原始数字是三的倍数，它将是0 、 3 、 6或9 。 任何其他数字意味着它不是（例如在这种情况下）。

---

^(a)如果将任何非负数除以 6，余数为 0、2 或 4，则它是偶数，因此是非质数（此处 2 是例外情况）：

6n + 0 = 2(3n + 0), an even number.
6n + 2 = 2(3n + 1), an even number.
6n + 4 = 2(3n + 2), an even number.

如果余数是 3，那么它可以被 3 整除，因此是非质数（3 是这里的例外情况）：

6n + 3 = 3(2n + 1), a multiple of three.

只剩下余数 1 和 5，这些数字都是6n±1形式。

Answer 2

可能不是最有效的，但您可以计算所有素数，直到 n，将它们存储在一个向量中，然后只打印那些差异为 2 的素数

#include <iostream>
#include<vector>
using namespace std;

void pr(int n, vector<int>& v)
{
    for (int i=2; i<n; i++) 
    {
        bool prime=true;
        for (int j=2; j*j<=i; j++)
        {
            if (i % j == 0) 
            {
                prime=false;
                break;    
            }
        }   
        if(prime) v.push_back(i);
    }
}
int main()
{
   vector<int> v;
   pr(50, v);
   for(int i = 0;i < v.size()-1; i++) {
       if(v[i+1]-v[i] == 2) {
           cout << v[i+1] << " " << v[i] << endl;
       }
   }

   return 0;
}

Answer 3

我认为这是您的有效算法并且易于理解。 您可以根据您的约束更改 k 的值。

#include <iostream>
#include <cstring>
using namespace std;

int n,p=2,savePrime=2,k=100000;

void printNPrime(int n)
{
    bool prime[k];
    memset(prime, true, sizeof(prime));

   while(n>0)
   {
        if (prime[p] == true)
        {
            if(p-savePrime == 2)
            {
                cout<<savePrime<<" "<<p<<endl;
                n--;
            }
            // Update all multiples of p
            for (int i=p*2; i<=k; i += p)
                prime[i] = false;
            savePrime=p;    
        }
      p++;  
   }

}   

int main() {
    cin>>n;
    printNPrime(n);
    return 0;
}