在一个范围内查找素数的直观方法

Intitutive method to find prime numbers in a range

本文关键字：直观 方法 查找 范围内 一个      更新时间：2023-10-16

试图在一个范围内找到素数时，我遇到了以下代码:

<子>(代码取自在) 

// For each prime in sqrt(N) we need to use it in the segmented sieve process.
for (i = 0; i < cnt; i++) {
    p = myPrimes[i]; // Store the prime.
    s = M / p;
    s = s * p; // The closest number less than M that is composite number for this prime p.
    for (int j = s; j <= N; j = j + p) {
        if (j < M) continue; // Because composite numbers less than M are of no concern.
        /* j - M = index in the array primesNow, this is as max index allowed in the array
           is not N, it is DIFF_SIZE so we are storing the numbers offset from.
           while printing we will add M and print to get the actual number. */
        primesNow[j - M] = false;
    }
}
// In this loop the first prime numbers for example say 2, 3 are also set to false.
for (int i = 0; i < cnt; i++) { // Hence we need to print them in case they're in range.
    if (myPrimes[i] >= M && myPrimes[i] <= N) // Without this loop you will see that for a
                                              // range (1, 30), 2 & 3 doesn't get printed.
        cout << myPrimes[i] << endl;
}
// primesNow[] = false for all composite numbers, primes found by checking with true.
for (int i = 0; i < N - M + 1; ++i) {
    // i + M != 1 to ensure that for i = 0 and M = 1, 1 is not considered a prime number.
    if (primesNow[i] == true && (i + M) != 1)
        cout << i + M << endl; // Print our prime numbers in the range.
}

然而，我觉得这段代码并不直观，不是容易理解。

    有人能解释一下上述算法背后的大致思想吗?
  • 在一个范围内标记非素数有哪些替代算法?

这太复杂了。让我们从埃拉托色尼的基本筛开始，用伪代码，它输出小于或等于n的所有质数:

function primes(n)
    sieve := makeArray(2..n, True)
    for p from 2 to n
        if sieve[p]
            output(p)
            for i from p*p to n step p
                sieve[p] := False

这个函数在每个素数p上调用output;output可以打印质数，或者对质数求和，或者计数，或者做任何你想做的事情。外for环依次考虑每个候选素数;筛分发生在for内环中，电流素数p的倍数从筛中除去。

一旦你理解了它是如何工作的，去这里讨论埃拉托色尼在一个范围内的分段筛。

您是否考虑过位级别上的筛选，它可以提供更大数量的素数，并且使用缓冲区，您可以修改它，例如通过重用相同的缓冲区，使用64位整数查找2到2^60之间的素数，同时保留已经发现的素数的偏移量。下面的代码将使用一个整数数组。

此话 

#include <math.h>         // sqrt(), the upper limit need to eliminate
#include <stdio.h>        // for printing, could use <iostream>

宏操作位，下面将使用32位整型

#define BIT_SET(d, n)   (d[n>>5]|=1<<(n-((n>>5)<<5)))      
#define BIT_GET(d, n)   (d[n>>5]&1<<(n-((n>>5)<<5)))
#define BIT_FLIP(d, n)  (d[n>>5]&=~(1<<(n-((n>>5)<<5))))
unsigned int n = 0x80000;   // the upper limit 1/2 mb, with 32 bits each 
                            // will get the 1st primes upto 16 mb    
int *data = new int[n];     // allocate
unsigned int r = n * 0x20;  // the actual number of bits avalible

可以使用0来节省时间但是，在(1)为素数时，更直观一些

for(int i=0;i<n;i++)
    data[i] = 0xFFFFFFFF;
unsigned int seed = 2;           // the seed starts at 2  
unsigned int uLimit = sqrt(r);   // the upper limit for checking off the sieve
BIT_FLIP(data, 1);      // one is not prime

发现质数的时间不到半秒

// untill uLimit is reached
while(seed < uLimit) {
    // don't include itself when eliminating canidates
    for(int i=seed+seed;i<r;i+=seed) 
        BIT_FLIP(data, i);
    // find the next bit still active (set to 1), don't include the current seed
    for(int i=seed+1;i<r;i++) {
        if (BIT_GET(data, i)) {
            seed = i;
            break;
        }
    }
}

现在对于输出，这将消耗最多的时间

unsigned long bit_index = 0;      // the current bit
int w = 8;                        // the width of a column
unsigned pc = 0;                  // prime, count, to assist in creating columns
for(int i=0;i<n;i++) {
    unsigned long long int b = 1;  // double width, so there is no overflow
    // if a bit is still set, include that as a result
    while(b < 0xFFFFFFFF) {
        if (data[i]&b) {
            printf("%8.u ", bit_index);
            if(((pc++) % w) == 0)
                putchar('n');   // add a new row                
        }
        bit_index++;
        b<<=1;                       // multiply by 2, to check the next bit    
    }
}

清理

delete [] data;
相关文章：