C++ Prime Numbers from 3 to n - c++

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 candidates and divisors compared to your original algorithm, but only tests for divisors 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 candidates and divisors:
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

It's not recommended to use using namespace std; — because this imports all of the identifiers from std. See this question on Stack Overflow.
Should the end condition of the second loop be candidate instead of n, i.e.
for (int x = 2; x < candidate; x++)//not before N prime numbers divine up to them
{
if (candidate % x == 0)
isPrime = false;
}
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