找不到黄金一代/有限一代的时间

Not Finding Times of Prime Generation / Limited Generation

本文关键字：一代 时间 找不到 黄金      更新时间：2023-10-16

这个程序是一个c++程序，它使用eratosthenes的筛子来计算素数。然后假设存储执行此操作所需的时间，并重新进行100次计算，每次存储时间。在这个程序中有两件事我需要帮助：

首先，我只能测试高达4.8亿的数字，我想得到更高的数字。

其次，当我给程序计时时，它只得到第一个计时，然后打印0作为时间。这是不对的，我不知道时钟出了什么问题。-谢谢的帮助

这是我的密码。

#include <iostream>
#include <ctime>
using namespace std;
int main ()
{

    int long MAX_NUM = 1000000;
    int long MAX_NUM_ARRAY = MAX_NUM+1;
    int long sieve_prime = 2;
    int time_store = 0;
    while (time_store<=100)
    {
        int long sieve_prime_constant = 0;
        int *Num_Array = new int[MAX_NUM_ARRAY];
        std::fill_n(Num_Array, MAX_NUM_ARRAY, 3);
        Num_Array [0] = 1;
        Num_Array [1] = 1;

        clock_t time1,time2;
        time1 = clock();
        while (sieve_prime_constant <= MAX_NUM_ARRAY)
        {
            if (Num_Array [sieve_prime_constant] == 1)  
            {
                sieve_prime_constant++;
            }
            else
            {
                Num_Array [sieve_prime_constant] = 0;  
                sieve_prime=sieve_prime_constant; 
                while (sieve_prime<=MAX_NUM_ARRAY - sieve_prime_constant)  
                {
                    sieve_prime = sieve_prime + sieve_prime_constant;
                    Num_Array [sieve_prime] = 1;
                }
                if (sieve_prime_constant <= MAX_NUM_ARRAY)
                {
                    sieve_prime_constant++;
                    sieve_prime = sieve_prime_constant;
                }
            }
        }
        time2 = clock();
        delete[] Num_Array;
        cout << "It took " << (float(time2 - time1)/(CLOCKS_PER_SEC)) << " seconds to    execute    this loop." << endl;
        cout << "This loop has already been executed " << time_store << " times." << endl;
        float Time_Array[100];
        Time_Array[time_store] = (float(time2 - time1)/(CLOCKS_PER_SEC));
        time_store++;
    }

    return 0;
}

我认为问题是你没有重置起始素数：

int long sieve_prime = 2;

目前，这超出了你的循环。转念一想。。。这不是问题所在。这段代码是否经过编辑，将建议纳入Mats Petersson的答案中？我刚刚纠正了错误的压痕。

不管怎样，对于你问题的另一部分，我建议你用char而不是int来代替Num_Array。使用int来存储布尔值是没有用的。通过使用char，您应该能够在相同数量的内存中存储大约4倍的值（假设您的int是32位的，可能是32位）。

这意味着你可以处理多达20亿的数字。由于您使用signed long而不是unsigned long作为类型，因此这已接近计算的数字限制。

如果您想使用更少的内存，可以使用std::bitset，但要注意性能可能会严重受损。

顺便说一下，您应该在main:的顶部声明您的定时数组

float Time_Array[100];

在使用之前把它放在循环中有点奇怪。

哦，为了以防万一你感兴趣，这是我自己实现的筛子，就我个人而言，我觉得它比你的更容易阅读。。。。

std::vector<char> isPrime( N, 1 );
for( int i = 2; i < N; i++ )
{
    if( !isPrime[i] ) continue;
    for( int x = i*2; x < N; x+=i ) isPrime[x] = 0;
}

这段代码应该进入您的循环：

int *Num_Array = new int[MAX_NUM_ARRAY];
std::fill_n(Num_Array, MAX_NUM_ARRAY, 3);
Num_Array [0] = 1;
Num_Array [1] = 1;

编辑：这个也需要在循环中：

int long sieve_prime_constant = 0;

当我在我的机器上运行这个程序时，每个循环需要0.2秒。如果我给MAX_NUM_ARRAY加两个零，每次迭代需要4.6秒（直到第20个循环，我厌倦了等待超过1.5分钟）

同意前面的评论。如果你真的想让事情变得更有活力，你不需要存储所有可能值的数组（如int或char），而是只保留素数。然后，你通过迄今为止发现的所有素数来测试每个后续数字的可整除性。现在你只受你能存储的素数的限制。当然，这并不是你想要实现的算法。。。但由于它将使用整数除法，所以速度相当快。类似这样的东西：

int myPrimes[MAX_PRIME];
int pCount, ii, jj;
ii = 3;
myPrimes[0]=2;
for(pCount=1; pCount<MAX_PRIME; pCount++) {
    for(jj = 1; jj<pCount; jj++) {
        if (ii%myPrimes[jj]==0) {
            // not a prime
            ii+=2; // never test even numbers...
            jj = 1; // start loop again
        }
    }
    myPrimes[pCount]=ii;
}

这并不是你想要的，但也许它很有用。

相关文章：