打印n对质数，C

Printing n pairs of prime numbers, C++

本文关键字：打印      更新时间：2023-10-16

我需要编写一个正在打印n对数字的程序，而这些对是：

：

p q

其中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;
}

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

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是复合的）。对于每种可能性，它检查它是否构成双票对并在此打印。

因此，您需要做的所有事情（除了将其转换为 real 代码）是创建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

实际上，您可以使用此划界技巧来查看是否将大量存储为字符串的大量数量可能是素数。您只需要检查下面还是以上的数字除以六个。如果没有，这个数字绝对不是素数。如果是这样，将需要更多（较慢）的检查以充分确定原始性。

只有在两个和三个都可以将数字排除时，一个数字才能排除六个。很容易告诉前者，甚至数字以偶数数字结束。

但是，很容易确定它是否可以由三个排除，因为在这种情况下，单个数字的总和也将也可以由三个排除。例如，让我们使用31415926535902718281828459。

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

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

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

（a）如果将任何非负号除以六，其余的是0、2或4，则均匀，因此非prime（在这里有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，因此非prime（3是此处的例外情况）：

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

仅留下剩余1和5，这些数字都是 6n±1。

可能不是最有效的，但是您可以计算所有素数直到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;
}

我认为是您的有效算法，易于理解。您可以根据约束更改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;
}
相关文章：