C++ 素数从 3 到 n

Question

I wrote this code to print all prime numbers between 3 and 'n' inputted by the user, but upon running, it produces nothing.

Can you please help?

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;

    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x < n; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
            }
        }

        if (isPrime)
        {
            cout << n << "";
        }
    }
}

Answer 1

One thing you should know. For checking whether n is prime if we start checking by division operation then you shouldn't check more than sqrt(n) .

    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x*x < candidate; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
                break;
            }
        }

        if (isPrime)
        {
            cout << candidate << "";
        }
    }

Better way is to use Sieve of Eratosthenes for this:

isPrime: initialize with all true
for(int i=2;i*i<=n;i++)
  for(int j =i*i;j<=n;j+=i)
    isPrime[j]=false;   // the if was not needed.

Now you know which are primes between 3 and n .

Answer 2

There are several efficiency savings possible in your code. The most efficient method (apart from using a pre-calculated look-up table for small (<1000) n ) is the sieve of Erastosthenes .

A very naive version of this algorithm (see also the answer by coderredoc )

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
            is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

essentially reverses the loops over candidate s and divisor s compared to your original algorithm, but only tests for divisor s satisfying divisor*divisor<=candidate .

This algorithm can be substantially improved by realizing that we only need to test for prime divisors (which is the main trick of the sieve)

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        if(is_prime[divisor])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
                is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

which cuts down on the testing for large n . A further efficiency saving (by a factor ~2 in space and time) is possible by avoiding even candidate s and divisor s:

std::vector<int> primes(int n)
{
    if(n<2) return {};
    if(n==2) return {2};
    std::vector<bool> is_prime((n+1)>>1,true);
    for(auto divisor=3; divisor*divisor <= n; divisor+=2)
        if(is_prime[divisor>>1])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=2*divisor)
                is_prime[candidate>>1]=false;
    std::vector<int> result(1,2);
    for(auto candidate=3; candidate <= n; candidate+=2)
        if(is_prime[candidate>>1]) result.push_back(candidate);
    return result;
}

This algorithm has a poor memory access pattern (into the is_prime[] ), which becomes a problem for very large n . A more sophisticated method, segmented sieve , can avoid that, see the above link.

Answer 3

Change your inner loop from

    for (int x = 2; x < n; x++)
    {
        if (candidate % x == 0)
        {
            isPrime = false;
        }
    }

to

    for (int x = 2; x < candidate; x++)
    {
        if (candidate % x == 0)
        {
            isPrime = false;
            break;
        }
    }

otherwise x would eventually become candidate itself and candidate%candidate is 0 which would cause isPrime to become false .

The break statement is used because after being sure that the number is not prime, there's no need of further iterations.

And since you consider only numbers from 3 , you could change your outer loop to save some iterations like

for (int candidate = 3; candidate < n; candidate+=2)

This would increment candidate by 2 each time. This is okay because no even numbers greater than 2 are not prime.

Also, if the range of numbers you are considering is inclusive of n , you may modify the outer for loop to

for (int candidate = 3; candidate < n; candidate+=2)

to consider n as well.

Answer 4

1. It's not recommended to use using namespace std; — because this imports all of the identifiers from std. See this question on Stack Overflow .

2. Should the end condition of the second loop be candidate instead of n , ie

   for (int x = 2; x < candidate; x++)//not before N prime numbers divine up to them { if (candidate % x == 0) isPrime = false; }

3. Shouldn't you put out candidate instead of n

Answer 5

I think this should work

#include <iostream>
#include <vector>


int main()
{
    //setup start parameters
    //test sequence
    std::vector<int> test_sequence {2};




    int end_number, start_number;
    start_number = 3;
    //take wished end number
    std::cin >> end_number;

    // test is wished number smaler than start number
    if (start_number < end_number)
    {
        // loop which goes trough every number between start and end number
        for (start_number; start_number <= end_number; start_number++)
        {
            bool isPrime = true;
            //test is this number prime
            for (int n = 0; n < test_sequence.size(); n++)
            {
                if (start_number % test_sequence[n] == 0 && start_number != test_sequence[n] )
                {
                isPrime = false;
                }
            }

            if (isPrime)
            {
                std::cout << start_number << std::endl;
                //hold result for next test
                test_sequence.push_back(start_number);
            }
        }

    }
    else
    {
    std::cout << "Wrong input";
    }

}

Result for first 200