Question

简便易举:

for (int i=2; i<=N; i++){
    if (sieve[i]==0){
        cout << i << " is prime" << endl;
        for (int j = i; j<=N; j+=i){
            sieve[j]=1;
        }
    }
    cout << i << " has " << sieve[i] << " distinct prime factors
";
}

But what about when N is very large and I can t hold that kind of array in memory? I ve looked up segmented sieve approaches and they seem to involve finding primes up until sqrt(N) but I don t understand how it works. What if N is very large (say 10^18)?

我的目标是为大N购买每升至N的每升一千个独一无二的主要系数。

Answer 1

部分电离层的基本想法是选择低于n的平方根的微粒体,选择一个相当庞大的面积,但适于记忆,然后从最小的开始,将每一部分推向上。在第一部分中,每一微量元素中最小的数倍是按部分计算的,然后以正常方式将微量元素的多面标记为复合物;当使用所有微粒时,该部分的其余未加说明的数字是首要的。接着,就下部分而言,就每一灭的主言而言,你已经知道本部分的头几个方面(这是在上部分结束该主人的的多面),因此,你会逐个si升,直到你完成。

n 确实如此,但更大的n将比较小的n>更需要更长时间;其规模是该部分的大小,而该部分的大小应与方便程度一样大(例如,机器上的主要记忆层的大小)。

您可以简单地看到一个分部分的电离层here。请注意,分部分的电离层速度将大大快于另一个答复中提到的O Neill s priority-queue sieve;如果你有兴趣的话,将执行here。

<>光线> 我是出于不同目的撰写的,但我在此表示,这或许是有用的:

尽管埃托斯群岛的Sieve非常快,但它需要O(n)空间。这可以通过在连续几段进行si蒸,降低到O(sqrt(n))和O(1)的双射线。在第一部分,每一微粒体内的微粒体积最小,然后按正常方式计算出多粒体;当使用所有微粒时,该部分的其余未加标数是主要数字。接着,在下半部分,每一灭 prime素中最小的多半是结束前几段灭的多面,因此积持续到尾声。

Consider the example of sieve from 100 to 200 in segments of 20. The five sieving primes are 3, 5, 7, 11 and 13. In the first segment from 100 to 120, the bitarray has ten slots, with slot 0 corresponding to 101, slot k corresponding to 100+2k+1, and slot 9 corresponding to 119. The smallest multiple of 3 in the segment is 105, corresponding to slot 2; slots 2+3=5 and 5+3=8 are also multiples of 3. The smallest multiple of 5 is 105 at slot 2, and slot 2+5=7 is also a multiple of 5. The smallest multiple of 7 is 105 at slot 2, and slot 2+7=9 is also a multiple of 7. And so on.

职衔范围包括争辩、hi和 del; lo和hi必须等到处;hi和 lo必须大于rt。部分面积为两倍。 Ps是一份相关清单,其中含有比rt(hi)低的微粒,其中2个被删除,因为甚至数字被忽略。 Q是一份相关清单,其中载列在相应微粒的目前部分中最小的多环线中的害虫。在每一部分之后,预支款为两倍,因此与单列单指数一相对应的数字为+2i+1。

function primesRange(lo, hi, delta)
    function qInit(p)
        return (-1/2 * (lo + p + 1)) % p
    function qReset(p, q)
        return (q - delta) % p
    sieve := makeArray(0..delta-1)
    ps := tail(primes(sqrt(hi)))
    qs := map(qInit, ps)
    while lo < hi
        for i from 0 to delta-1
            sieve[i] := True
        for p,q in ps,qs
            for i from q to delta step p
                sieve[i] := False
        qs := map(qReset, ps, qs)
        for i,t from 0,lo+1 to delta-1,hi step 1,2
            if sieve[i]
                output t
        lo := lo + 2 * delta

当称为MastersRange(100、200、10)时, prime的素材为[3、5、7、11、13];qs最初为[2、2、3、2、10、8],相当于最小的多重体105、105、105、121和117,其第二段重新编号为[1、2、6、0、11],相当于最小的多重体123、125、133、121和143。

可在上看到这一方案。 http://ideone.com/iHYr1f。除上述链接外,如果你有兴趣按主要数字编制方案,我会在我的博客上提出这一建议:essay。

Answer 2

It s just that we are making segmented with the sieve we have. The basic idea is let s say we have to find out prime numbers between 85 and 100. We have to apply the traditional sieve,but in the fashion as described below:

因此,我们用第2号第数,将起始数与2号(85/2)分开,把我们获得的编号为42的四舍五入到小数,现在又再乘2美元,从此开始增加2至最后数目。因此,我们所做的是,我们消除了范围上2(86,88,90,92,94,96,98,100)的所有因素。

接下来的第3号是3号,把起始数分成3号(85/3),把我们从现在起的28号增加到小数,现在又再乘3份,从这里开始增加3至最后数目。因此,我们所做的是,我们消除了范围3 (87,90,93,96,99)的所有因素。

Take the next prime number=5 and so on.................. Keep on doing the above steps.You can get the prime numbers (2,3,5,7,...) by using the traditional sieve upto sqrt(n).And then use it for segmented sieve.

Answer 3

根据优先事项,Sieve有一个版本,它产生与你要求相同的许多主要产品,而不是全部达到上限。传统文件The Genuine Sieve of Eratosthenes" 和googling for “sievetosthenes priority queue”用各种方案语言提出了许多执行建议。

Answer 4

如果有人想看到C++的实施,这里就是:

void sito_delta( int delta, std::vector<int> &res)
{

std::unique_ptr<int[]> results(new int[delta+1]);
for(int i = 0; i <= delta; ++i)
    results[i] = 1;

int pierw = sqrt(delta);
for (int j = 2; j <= pierw; ++j)
{
    if(results[j])
    {
        for (int k = 2*j; k <= delta; k+=j)
        {
            results[k]=0;
        }
    }
}

for (int m = 2; m <= delta; ++m)
    if (results[m])
    {
        res.push_back(m);
        std::cout<<","<<m;
    }
};
void sito_segment(int n,std::vector<int> &fiPri)
{
int delta = sqrt(n);

if (delta>10)
{
    sito_segment(delta,fiPri);
   // COmpute using fiPri as primes
   // n=n,prime = fiPri;
      std::vector<int> prime=fiPri;
      int offset = delta;
      int low = offset;
      int high = offset * 2;
      while (low < n)
      {
          if (high >=n ) high = n;
          int mark[offset+1];
          for (int s=0;s<=offset;++s)
              mark[s]=1;

          for(int j = 0; j< prime.size(); ++j)
          {
            int lowMinimum = (low/prime[j]) * prime[j];
            if(lowMinimum < low)
                lowMinimum += prime[j];

            for(int k = lowMinimum; k<=high;k+=prime[j])
                mark[k-low]=0;
          }

          for(int i = low; i <= high; i++)
              if(mark[i-low])
              {
                fiPri.push_back(i);
                std::cout<<","<<i;
              }
          low=low+offset;
          high=high+offset;
      }
}
else
{

std::vector<int> prime;
sito_delta(delta, prime);
//
fiPri = prime;
//
int offset = delta;
int low = offset;
int high = offset * 2;
// Process segments one by one 
while (low < n)
{
    if (high >= n) high = n;
    int  mark[offset+1];
    for (int s = 0; s <= offset; ++s)
        mark[s] = 1;

    for (int j = 0; j < prime.size(); ++j)
    {
        // find the minimum number in [low..high] that is
        // multiple of prime[i] (divisible by prime[j])
        int lowMinimum = (low/prime[j]) * prime[j];
        if(lowMinimum < low)
            lowMinimum += prime[j];

        //Mark multiples of prime[i] in [low..high]
        for (int k = lowMinimum; k <= high; k+=prime[j])
            mark[k-low] = 0;
    }

    for (int i = low; i <= high; i++)
        if(mark[i-low])
        {
            fiPri.push_back(i);
            std::cout<<","<<i;
        }
    low = low + offset;
    high = high + offset;
}
}
};

int main()
{
std::vector<int> fiPri;
sito_segment(1013,fiPri);
}

Answer 5

根据Sapnil Kumar的答复,我在C做了以下算法,用ming威32-make.exe建造。

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    const int MAX_PRIME_NUMBERS = 5000000;//The number of prime numbers we are looking for
    long long *prime_numbers = malloc(sizeof(long long) * MAX_PRIME_NUMBERS);
    prime_numbers[0] = 2;
    prime_numbers[1] = 3;
    prime_numbers[2] = 5;
    prime_numbers[3] = 7;
    prime_numbers[4] = 11;
    prime_numbers[5] = 13;
    prime_numbers[6] = 17;
    prime_numbers[7] = 19;
    prime_numbers[8] = 23;
    prime_numbers[9] = 29;
    const int BUFFER_POSSIBLE_PRIMES = 29 * 29;//Because the greatest prime number we have is 29 in the 10th position so I started with a block of 841 numbers
    int qt_calculated_primes = 10;//10 because we initialized the array with the ten first primes
    int possible_primes[BUFFER_POSSIBLE_PRIMES];//Will store the booleans to check valid primes
    long long iteration = 0;//Used as multiplier to the range of the buffer possible_primes
    int i;//Simple counter for loops
    while(qt_calculated_primes < MAX_PRIME_NUMBERS)
    {
        for (i = 0; i < BUFFER_POSSIBLE_PRIMES; i++)
            possible_primes[i] = 1;//set the number as prime

        int biggest_possible_prime = sqrt((iteration + 1) * BUFFER_POSSIBLE_PRIMES);

        int k = 0;

        long long prime = prime_numbers[k];//First prime to be used in the check

        while (prime <= biggest_possible_prime)//We don t need to check primes bigger than the square root
        {
            for (i = 0; i < BUFFER_POSSIBLE_PRIMES; i++)
                if ((iteration * BUFFER_POSSIBLE_PRIMES + i) % prime == 0)
                    possible_primes[i] = 0;

            if (++k == qt_calculated_primes)
                break;

            prime = prime_numbers[k];
        }
        for (i = 0; i < BUFFER_POSSIBLE_PRIMES; i++)
            if (possible_primes[i])
            {
                if ((qt_calculated_primes < MAX_PRIME_NUMBERS) && ((iteration * BUFFER_POSSIBLE_PRIMES + i) != 1))
                {
                    prime_numbers[qt_calculated_primes] = iteration * BUFFER_POSSIBLE_PRIMES + i;
                    printf("%d
", prime_numbers[qt_calculated_primes]);
                    qt_calculated_primes++;
                } else if (!(qt_calculated_primes < MAX_PRIME_NUMBERS))
                    break;
            }

        iteration++;
    }

    return 0;
}

它设定了最大数量的主数,然后开始使用已知的2、3、5.29等主要数字。因此,我们作出缓冲,储存可能的主要部分,这一缓冲可能比最初步的主要部分的力量大,在这种情况下是29个。

我确信,为了改进业绩,可以做大量优化工作,例如将部门分析过程和高频数字相平行,而这两个数字是2、3和5的,但却是低记忆消耗的一个实例。

Answer 6

A number is prime if none of the smaller prime numbers divides it. Since we iterate over the prime numbers in order, we already marked all numbers, who are divisible by at least one of the prime numbers, as divisible. Hence if we reach a cell and it is not marked, then it isn t divisible by any smaller prime number and therefore has to be prime.

www.un.org/spanish/ecosoc 注意这些要点:

// Generating all prime number up to  R
 
// creating an array of size (R-L-1) set all elements to be true: prime && false: composite
     

#include<bits/stdc++.h>

using namespace std;

#define MAX 100001

vector<int>* sieve(){
    bool isPrime[MAX];

    for(int i=0;i<MAX;i++){
        isPrime[i]=true;
    }
 for(int i=2;i*i<MAX;i++){
     if(isPrime[i]){
         for(int j=i*i;j<MAX;j+=i){
             isPrime[j]=false;
         }
     }
 }

 vector<int>* primes = new vector<int>();
 primes->push_back(2);
 for(int i=3;i<MAX;i+=2){
     if(isPrime[i]){
     primes->push_back(i);
     }
}

 return primes;
}

void printPrimes(long long l, long long r, vector<int>*&primes){
      bool isprimes[r-l+1];
      for(int i=0;i<=r-l;i++){
          isprimes[i]=true;
      }

      for(int i=0;primes->at(i)*(long long)primes->at(i)<=r;i++){

          int currPrimes=primes->at(i);
          //just smaller or equal value to l
          long long base =(l/(currPrimes))*(currPrimes);
      

          if(base<l){
              base=base+currPrimes;
          }
    
    //mark all multiplies within L to R as false

          for(long long j=base;j<=r;j+=currPrimes){
              isprimes[j-l]=false;
          }

   //there may be a case where base is itself a prime number

          if(base==currPrimes){
              isprimes[base-l]= true;
          }
    }

          for(int i=0;i<=r-l;i++){
              if(isprimes[i]==true){
                  cout<<i+l<<endl;
              }
          

      }
}
int main(){
    vector<int>* primes=sieve();
   
   int t;
   cin>>t;
   while(t--){
       long long l,r;
       cin>>l>>r;
       printPrimes(l,r,primes);
   }

    return 0;

}

友情链接