Question

在尝试查找某个范围内的素数时（请参阅problem description），我遇到了以下代码：

_{（代码取自here）}

// 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.
}

但是，我没有发现这个代码直观，而且很容易理解。

有人可以解释上述算法背后的一般想法吗？
有哪些替代算法可以标记范围内的非素数？

Answer 1

这太复杂了。让我们从一个基本的Eratosthenes Sieve开始，用伪代码输出所有小于或等于 n 的素数：

width

此函数在每个素数 p 上调用html, body, main, section { height: 100%; width: 100%; }; 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可以打印素数，或对素数求和，或计算它们，或做任何你想做的事情。外output循环依次考虑每个候选素数;筛分发生在内部output循环中，其中当前主要 p 的多个从筛子中移除。

一旦你理解了它是如何工作的，就去here讨论一个范围内分段的Eratosthenes筛子。

Answer 2

你有没有考虑过一个级别的筛，它可以提供更多的素数，并且使用缓冲区，你可以修改它以找到例如2到2 ^ 60之间的素数，使用64位整数，重用相同的缓冲区，同时保留已经发现的素数的偏移量。以下将使用整数数组。

<强> Declerations

public int ex;
public int test(){
    if(ex == 1){
        return 1;
    }
    if(ex == 2){
        return 2;
    }
    // and so on
}

操作位的

宏，以下将使用32位整数

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

可以使用零来节省时间但是，在（1）上使用素数时，会更直观一些

#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

时间发现素数这需要不到半秒

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    
    }

}

在

2 个答案: