Eratosthenes的筛子数量高达一百万c ++

Question

So I need help with my code. For some reason it keeps crashing when I enter a number past 500,000. Here is the exact assignment.

Implement the Sieve of Eratosthenes and use it to find all prime numbers less than or equal to one million. Use the result to prove Goldbach's Conjecture for all even integers between four and one million, inclusive.

Implement a function with the following declaration:

 void sieve(int array[], int num); 

This function takes an integer array as its argument. The array should be initialized to the values 1 through 1000000. The function modifies the array so that only the prime numbers remain; all other values are zeroed out.

This function must be written to accept an integer array of any size. You must should output for all primes numbers between 1 and 1000000, but when I test your function it may be on an array of a different size.

Implement a function with the following declaration:

 void goldbach(int array[], int num); 

This function takes the same argument as the previous function and displays each even integer between 4 and 1000000 with two prime numbers that add to it.

The goal here is to provide an efficient implementation. This means no multiplication, division, or modulus when determining if a number is prime. It also means that the second function must find two primes efficiently.

Output for your program:

All prime numbers between 1 and 1000000 and all even numbers between 4 and 1000000 and the two prime numbers that sum up to it.

DO NOT provide output or a session record for this project!

And here is what I have so far. If anyone could help me that would be great.

#include <iostream>
using namespace std;

void sieve (int array[], int num);

int main()
{
    int num;
    cout << "Enter a number to calculate up to." << endl;
    cin>> num;
    if ( num < 2 )
        return 0;

    int array[num];
    array[0]= array[1]= 0;
    for ( int i= 2; i < num; ++i )
        array[i]= i;
    sieve(array,num);
    for (int i=0; i<num; i++)
        if (array[i] > 0)
            cout << array[i] <<" "<<endl;
    cout<<endl;

    return 0;
}

void sieve( int array[], int num )
{
    for ( int i= 0; i < num; ++i )
    {
        if ( array[i] != 0 )
        {
            for ( int j= i+i; j < num; j += i )
            {
                array[j]= 0;
            }
        }
    }
}

Answer 1

The reason why your code crashes is that you're using VLA allocation for the array here

int array[num];

It's used to allocate num int elements of the stack, which is most probably too small to hold a million of int values.

You should note it's not a standard c++ feature, but an extension provided by a number of compiler implementations.

To fix this there are three alternatives:

1. You configure the stack size used for your program to be big enough to hold the number of int elements (this is OS dependend)
2. You use a std::vector<int> array(num); instead, that allocates these elements on the heap memory
3. You allocate the necessary memory on the heap yourself using int* array = new int[num]; and delete [] array; at the end of your program (I wouldn't recommend this solution, because it's prone to make silly mistakes regarding the proper memory management)

Answer 2

As I see this is an assignment, you need to write your own code, but I have a few ideas to reduce the amount of memory significantly.

Why don't you use array of bits instead ?

Do something like

#define IS_SET(x) (arr[(x)>>3] & (0x01 << ((x) & 0x07)))
#define SET(x) (arr[(x)>>3] |= (0x01 << ((x) & 0x07)))

and define arr as an array of char . This will make the memory utilization 8 folds down. For C++ you can use bool might not get you the lowest possible memory usage.

First clear out all the char elements. Then for each number set bits using SET(x) an once all marking is done. If IS_SET(x) evaluates false then x is prime.

Saves large amount of memory.

EDIT1:

Another trick to cut 50% of the memory required is not to retain space for the even numbers. Start with i=3 and always increment using i+=2 and mark the bit arrays. While reading do the same.

EDIT2:

If you can find a series which skips the integers which are multiple of two or three or both, then you can save around 30% more memory. In fact you can make such a series and skip storing and marking for the multiples of two and three or both.