程序中查找素数的循环问题

Question

Hi I have been having a problem working out how to get this to work. It's intended to find the first x number of prime numbers using a user input to set x. It will then place any in an array before printing the results. I think I have made an issue with the loops as once the user input is entered nothing will happen. I'd be grateful if anyone could maybe point out where I have gone wrong and provide suggestions on how to fix it. Thanks

static void Main(string[] args)
    {
        int max, i, count;
        i = 0; // this is used to keep trck of how many primes have been added to the array
        count = 0; // this is used to test each number
        Console.WriteLine("This will work out the first x prime numbers with x being the number of prime numbers you want");
        Console.WriteLine("Enter the number of prime numbers you want.");
        max = Convert.ToInt32(Console.ReadLine());

        int[] primes = new int[max];

        while (i <= max)
        {
         while (count <= 9999)
         {
             if (count % 2 == 0 || count % 3 == 0 || count % 5 == 0 || count % 7 == 0 ) // tests if count number is a prime 
             {
                 if (count == 2 || count == 3 ||count == 5 ||count == 7 ) // ensures 2,3,5,7 are added to primes if neccesarry
                 {

                     primes[count] = count; //add to array
                     i++; // increments the count on the number of prime numbers
                 }
                 count ++; // increments the count 
                 break;
             }
             else
             {
                 primes[count] = count;
                 i++;
                 count ++;
             }
         }
        }

        Console.WriteLine("The first {0} prime numbers are ... ", max);
        foreach(var item in primes)
        {
            Console.Write(item.ToString() + ", ");
        }
    }

Answer 1

First of all, that's not the way to test if a number is a prime number, but then again, the cycle is all wrong.

If you put a max which is higher that the number of prime numbers less than 9999 it will cycle in the outer loop forever.

Check the wiki for some first insights: http://en.wikipedia.org/wiki/Primality_test

To check my statement you could add some console output in the outer loop and see for yourself

Answer 2

In the spirit of trying to keep to your original code, here is an adjusted take on your algorithm, modified to use the Sieve of Eratosthenes :

• The Sieve can iteratively determine all primes, with only the knowledge that 2 is a prime.
• The exit condition on the inner loop should be when the we exceed the square root of the number we are testing, with our list of known primes (not 9999 and break ). Because of the definition of a prime number, with a list of prime numbers up to X, we can resolve all other prime numbers up to X * X. (So we can stop testing if we exceed the square root eg 2 can resolve 3 and 4, 2 and 3 can resolve up to 9, etc). This is also because our primes are already ordered in ascending order.
• I've kept the original variables, ie count is the next tested candidate prime, i is the current index of the prime, max is upper bound to populate.
• The first prime, 2, needs to be hard coded (ie primes[0] = 2 , the next prime index i will be 1, and the first candidate number we need to check thereafter will be 3.

// We do need to hard code that 2 is a prime number. Everything else can be derived
primes[0] = 2;
i = 1;
count = 3;

// i.e. stop when we get the required number of primes
while (i < max)
{
    // Indicator to stop testing this candidate if we find a factor
    bool foundFactor = false;
    // Start off each primality test from the start of our primes array
    var primeIndex = 0;

    // Try and find a factor of 'count' with our known primes
    while (!foundFactor && primeIndex < i)
    {
        // We can stop after the square root. Multiplication is faster than sqrt
        if (primes[primeIndex]*primes[primeIndex] > count)
            break;
        // If the candidate number
        if (count % primes[primeIndex] == 0)
            foundFactor = true;
        primeIndex++;
    }
    if (!foundFactor)
    {
        primes[i] = count;
        i++;
    }

    count++;
}

As per @Massimo's link, the above brute force mechanism is terribly inefficient. An improvement is the 'wheel of 6' referenced in the Wiki article - after count=6 , the wheel of 6 takes each candidate set of numbers to test in batches of 6, and all multiples of 2 and 3 can immediately be eliminated. Other larger wheels are also possible.