Vector GetPrimes(u64 number) {
std::vector<char> is_prime(number + 1, 1);
is_prime[0] = false;
is_prime[1] = false;
for (u64 x = 2; x <= number; ++x) {
if (is_prime[x] && x * x <= number) {
for (u64 i = x * x; i <= number; i += x) {
is_prime[i] = false;
}
}
}
Vector result;
for (u64 i = 0; i < is_prime.size(); ++i) {
if (is_prime[i]) {
result.push_back(i);
}
}
return result;
}
int decompose(xint n, xint *f)
{
pint p = 0;
int i = 0;
/* check small primes: not strictly necessary */
if (n <= MAX_PRIME && is_prime(n)) {
f[0] = n;
return 1;
}
while (n >= (xint)p * p) {
if (!(p = next_prime(p))) break;
while (n % p == 0) {
n /= p;
f[i++] = p;
}
}
if (n > 1) f[i++] = n;
return i;
}
int
common(unsigned long b, unsigned long a){
unsigned long i;
for (i=2; i<min(a,b); i++)
if(is_prime(i)){
int ax, bx;
ax = divides(i,a);
bx = divides(i,b);
//printf (" %lu %lu %d %lu %lu %d ", a, i, ax, b, i, bx);
if ( ax & bx) {
//printf(" true, common \n");
return 1;
}
//printf("\n");
}
//printf(" false, no common \n");
return 0;
}
void prime_mul(unsigned int num)
{
unsigned int i;
printf("%u = 1", num);
i = 2;
while (i <= num)
{
if (is_prime(i) && num % i == 0)
{
printf(" * %d", i);
num /= i;
}
else
{
i++;
}
}
}
int main()
{
std::vector<bool> prime_numbers(1000000,true);
prime_soe(prime_numbers);
for(unsigned int i = 2; i < 100; ++i)
{
if(prime_numbers[i] == true)
{
if(is_prime(i))
{
std::cout << i << " is a prime \n";
}
else
{
std::cout << i << " is not a prime \n";
}
}
}
// prime_soe(prime_numbers);
// // print_primes(prime_numbers);
// int largest_left_trunc_prime = 0;
// int largest_right_trunc_prime = 0;
// for(unsigned int i = 2; i < prime_numbers.size();++i)
// {
// if(prime_numbers[i] == true)
// {
// if(is_left_trunc_prime(i))
// {
// largest_left_trunc_prime = i;
// }
// if(is_right_trunc_prime(i))
// {
// largest_right_trunc_prime = i;
// }
// }
// }
// std::cout << "largest left trunc prime: " << largest_left_trunc_prime << '\n';
// std::cout << "largest right trunc prime: " << largest_right_trunc_prime << '\n';
}
void Sieve::_extend(unsigned limit)
{
#ifdef HAVE_CSYMPY_PRIMESIEVE
if (_primes.back() < limit)
primesieve::generate_primes(_primes.back() + 1, limit, &_primes);
#else
const unsigned sqrt_limit = static_cast<unsigned>(std::sqrt(limit));
unsigned start = _primes.back() + 1;
if (limit <= start)
return;
if (sqrt_limit >= start) {
_extend(sqrt_limit);
start = _primes.back() + 1;
}
unsigned segment = _sieve_size;
std::valarray<bool> is_prime(segment);
for (; start <= limit; start += 2 * segment) {
unsigned finish = std::min(start + segment * 2 + 1, limit);
is_prime[std::slice(0, segment, 1)] = true;
//considering only odd integers. An odd number n corresponds to n-start/2 in the array.
for (unsigned index = 1; index < _primes.size() &&
_primes[index] * _primes[index] <= finish; ++index) {
unsigned n = _primes[index];
unsigned multiple = (start / n + 1) * n;
if (multiple % 2 == 0)
multiple += n;
if (multiple > finish)
continue;
std::slice sl = std::slice((multiple-start)/ 2, 1 + (finish - multiple) / (2 * n), n);
//starting from n*n, all the odd multiples of n are marked not prime.
is_prime[sl] = false;
}
for (unsigned n = start + 1; n <= finish; n += 2) {
if (is_prime[(n - start) / 2])
_primes.push_back(n);
}
}
#endif
}
int main(void)
{
e_coreid_t id = e_get_coreid();
unsigned row, col;
unsigned long number;
// Get the row, column coordinates of this core
e_coords_from_coreid(id, &row, &col);
// Assign the starting value for each core (3,5,7,..33)
// Each core starts with a unique odd number (2 is the only even prime number)
number = 2 + ((2*row*4) + (2*col+1));
// Initialize this core iteration count for stats
(*count) = 0;
// Initialize the number of found primes counter
(*primes) = 0;
while(*count < *max_tests)
{
if(is_prime(number))
(*primes)++;
// Skip to the next odd number for this core to test, assuming total of 16 cores
// Core (0,0) started with 3 on the first iteration, and next test 35
// Core (0,1) started with 5 on the first iteration, and next test 37
// etc
number += (2*16);
*sq = sqrt(number);
*num = number;
(*count)++;
}
return EXIT_SUCCESS;
}
int checkNumbers(int min, int max, FILE* fd){
register int num;
register int prime_count = 0;
char buffer[BUFFER_SIZE];
memset(buffer, 0, BUFFER_SIZE);
char* buffer_ptr = buffer;
// if min is even, skip it
if( (min & 0x01) == 0)
{
min +=1;
}
for(num = min; num < max; num+=2) {
if (is_prime(num))
{
prime_count++;
//printf("%d\n", num);
itoa(num, buffer_ptr);
int len = strlen(buffer_ptr);
buffer_ptr[len] = '\n';
buffer_ptr[len+1] = '\0';
buffer_ptr += len+1;
//fwrite(buffer, 1, len+1, fd);
if (buffer_ptr > buffer + BUFFER_SIZE - 32)
{
fwrite(buffer, 1, buffer_ptr - buffer, fd);
memset(buffer, 0, BUFFER_SIZE);
buffer_ptr = buffer;
}
}
}
fwrite(buffer, 1, buffer_ptr - buffer, fd);
return prime_count;
}
int main(int argc, char **argv)
{
int n_in = 0;
int x_in = 0;
for (int c; (c = getopt(argc, argv, "n:x:")) != -1;) {
switch(c) {
case 'n':
n_in = atoi(optarg);
break;
case 'x':
x_in = atoi(optarg);
break;
}
}
uint64_t result = 0;
uint64_t i,k;
uint32_t ptable[10000] = {};
btable_set(ptable, 2);
for(i = 3; i < 10000 * 32; i+=2) {
if(is_prime(i)) {
btable_set(ptable, i);
} else {
if(check(ptable, i, &k)) {
printf("%llu = %llu + 2 * %llu^2\n", i, i - 2 * k * k, k);
} else {
result = i;
break;
}
}
}
DUMPL(result);
return 0;
}
inline vector<mpz_class> sieve_of_eratosthenes_factorization(const mpz_class& n)
{
mpz_class remaining = n;
vector<mpz_class> factors;
unsigned int limit = pow(2, 26);
mpz_class tmp;
mpz_sqrt(tmp.get_mpz_t(), n.get_mpz_t());
tmp++;
if (tmp.fits_uint_p() && tmp < limit)
{
limit = tmp.get_ui();
}
vector<bool> is_prime (limit, true);
is_prime[0] = false;
is_prime[1] = false;
for (int i = 2; i < limit; i++)
{
if (is_prime[i])
{
while (remaining % i == 0)
{
remaining /= i;
factors.push_back(i);
}
for (int j = i*i; j < limit; j += i)
{
is_prime[j] = false;
}
}
}
// Don't forget the last factor if one exists.
if (remaining > 1) factors.push_back(remaining);
return factors;
}
int main(int argc, char **argv)
{
static unsigned long bignumber = 600851475143;
unsigned int sqrt_nb = sqrt(bignumber), res=0;
std::vector<unsigned int> prime_list;
for (unsigned int i=2; i<sqrt_nb; i++)
if ( is_prime(i) )
prime_list.push_back(i);
for (std::vector<unsigned int>::iterator j = prime_list.begin();
j != prime_list.end(); j++)
{
if ( (bignumber % *j) == 0 )
res = *j;
}
std::cout << "\n" << res << std::endl;
return 0;
}
/*
* DL_Group Constructor
*/
DL_Group::DL_Group(RandomNumberGenerator& rng,
PrimeType type, size_t pbits, size_t qbits)
{
if(pbits < 1024)
throw Invalid_Argument("DL_Group: prime size " + std::to_string(pbits) +
" is too small");
if(type == Strong)
{
m_p = random_safe_prime(rng, pbits);
m_q = (m_p - 1) / 2;
m_g = 2;
}
else if(type == Prime_Subgroup)
{
if(!qbits)
qbits = dl_exponent_size(pbits);
m_q = random_prime(rng, qbits);
BigInt X;
while(m_p.bits() != pbits || !is_prime(m_p, rng))
{
X.randomize(rng, pbits);
m_p = X - (X % (2*m_q) - 1);
}
m_g = make_dsa_generator(m_p, m_q);
}
else if(type == DSA_Kosherizer)
{
qbits = qbits ? qbits : ((pbits <= 1024) ? 160 : 256);
generate_dsa_primes(rng, m_p, m_q, pbits, qbits);
m_g = make_dsa_generator(m_p, m_q);
}
m_initialized = true;
}
void fuzz(const uint8_t in[], size_t len)
{
if(len % 2 != 0)
return;
const BigInt a = BigInt::decode(in, len / 2);
const BigInt n = BigInt::decode(in + len / 2, len / 2);
try {
BigInt a_sqrt = ressol(a, n);
if(a_sqrt > 0)
{
/*
* If n is not prime then the result of ressol will be bogus. But
* this function is exposed to untrusted inputs (via OS2ECP) so
* should not hang or crash even with composite modulus.
* If the result is incorrect, check if n is a prime: if it is
* then z != a is a bug.
*/
BigInt z = (a_sqrt * a_sqrt) % n;
BigInt a_redc = a % n;
if(z != a_redc)
{
if(is_prime(n, system_rng(), 64))
{
std::cout << "A = " << a << "\n";
std::cout << "Ressol = " << a_sqrt << "\n";
std::cout << "N = " << n << "\n";
std::cout << "Z = " << z << "\n";
abort();
}
}
}
}
catch(Botan::Exception& e) {}
return;
}
int main()
{
unsigned long long a;
unsigned long long p;
while(scanf("%lld %lld",&p,&a) != EOF)
{
if(p == 0 && a == 0)
break;
if(is_prime(p))
printf("no\n");
else
{
if(mod_exp(a,p,p) == a)
printf("yes\n");
else
printf("no\n");
}
}
return 0;
}
void main() {
ULONG i = NUMBER / 2;
ULONG half = NUMBER / 2;
if(i % 2 == 0)
i++;
for(i = 1; i < half; i += 2)
{
//printf("number: %lu\n",i);
if(is_factor(i, NUMBER))
{
printf("factor number: %lu\n",i);
if(is_prime(i))
{
printf("\tprime number: %lu\n",i);
//break;
}
}
}
printf("largest prime factor=%lu\n",i);
}
int main()
{
cout << "Program will find all prime numbers between 1 and max. Enter max: ";
int max;
cin >> max;
if (max > 0) {
vector<int> found_primes;
// Get prime numbers in range(1,100).
for (int i = 2; i <= max; ++i)
if (is_prime(i) == 1)
found_primes.push_back(i);
// Print primes found.
for (int i = 0; i < found_primes.size(); ++i)
cout << found_primes[i] << endl;
}
else
cout << "Max must be > 0" << endl;
return 0;
}
int main() {
int i, j, s;
char p[21];
char l[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
while (scanf("%s", p) != EOF) {
s = 0;
for (i = 0; i < strlen(p); i++) {
for (j = 0; j <= 51; j++) {
if (p[i] == l[j]) {
s += j + 1;
break;
}
}
}
if (is_prime(s)) {
printf("It is a prime word.\n");
} else {
printf("It is not a prime word.\n");
}
}
return 0;
}
inline vector<int> sieve_of_eratosthenes(unsigned int B)
{
vector<int> primes;
vector<bool> is_prime (B, true);
is_prime[0] = false;
is_prime[1] = false;
for (int i = 2; i < B; i++)
{
if (is_prime[i])
{
primes.push_back(i);
for (int j = i*i; j < B; j += i)
{
is_prime[j] = false;
}
}
}
return primes;
}
int main()
{
long cas,i;
long n,temp,prime;
scanf("%ld",&cas);
for(i=1;i<=cas;i++)
{
scanf("%ld",&n);
temp=(n/2)+1;
while(1)
{
prime=is_prime(temp);
if(prime==1)
{
printf("%ld\n",temp);
break;
}
temp++;
}
}
return 0;
}
int main()
try
{
prime.push_back(2); // consider the smallest prime
for (int i = 3; i<=100; ++i) // test all integers [3:100]
if (is_prime(i)) prime.push_back(i); // add new prime to vector
cout << "Primes: ";
for (int p = 0; p<prime.size(); ++p)
cout << prime[p] << '\n';
keep_window_open("~"); // For some Windows(tm) setups
}
catch (runtime_error e) { // this code is to produce error messages; it will be described in Chapter 5
cout << e.what() << '\n';
keep_window_open("~"); // For some Windows(tm) setups
}
catch (...) { // this code is to produce error messages; it will be described in Chapter 5
cout << "exiting\n";
keep_window_open("~"); // For some Windows(tm) setups
}
int main()
{
int k = 0, sum_primes = 0, num = 9;
while (k < TOTAL_TRUNCABLE_PRIMES)
{
if (is_prime(num))
{
if (is_left_truncable(num) && is_right_truncable(num))
{
printf("Truncatable prime: %d\n", num);
sum_primes += num;
k++;
}
}
num += 2;
}
printf("\nTotal: %d\n", sum_primes);
return 0;
}
int main(){
int i,j;
int pk=0;
for(i=2;i<=100;i++){
if(is_prime(i)){
pk++;
kth_prime[i]=pk;
}
else kth_prime[i]=0;
}
for(i=1;i<=100;i++)for(j=1;j<=pk;j++)map[i][j]=0;
for(i=2;i<=100;i++){
for(j=1;j<=pk;j++)map[i][j]=map[i-1][j];
int x=i;
for(j=1;j<=100;j++){
if(kth_prime[j]){
if(x!=0&&x!=1&&x%j==0){
x/=j;
map[i][ kth_prime[j] ]++;
j--;
}
}
if(x==1)break;
}
}
int n;
while(scanf("%d",&n)!=EOF&&n>1){
printf("%3d! =",n);
for(j=1;j<=pk;j++){
if(map[n][j]){
if(j==16)printf("\n ");
printf("%3d",map[n][j]);
}
else break;
}
printf("\n");
}
return 0;
}
int main() {
int n = __VERIFIER_nondet_int();
if (n < 1 || n > 46340) {
return 0;
}
int result = is_prime(n);
int f1 = __VERIFIER_nondet_int();
if (f1 < 1 || f1 > 46340) {
return 0;
}
int f2 = __VERIFIER_nondet_int();
if (f1 < 1 || f1 > 46340) {
return 0;
}
if (result == 1 && mult(f1, f2) == n && f1 > 1 && f2 > 1) {
ERROR:
__VERIFIER_error();
} else {
return 0;
}
}
}
void get_primes(std::vector<int> & output, const int max)
{
// Clear the output vector, if passed not empty.
// Another option would be to throw exception, but not sure if they are
// allowed here according to guidelines
if (!output.empty())
{
output.clear();
}
// Reserve enough memory for the output vector, to avoid further
// reallocations in case of very big max
output.reserve(max);
// Check all numbers from 2 to max for primality. Append all prime numbers
// to output vector
for (int i = 2; i <= max; i += (i == 2 ? 1 : 2))
{
if (is_prime(i))
{
output.push_back(i);
}
uint_fast64_t nth(std::size_t index) {
if (0 == index) {
throw std::domain_error("Seriously? You want the zero-th prime?");
}
if (1 == index) {
return 2;
}
uint_fast64_t possible_prime = 3;
std::size_t i = 1;
while (i < index) {
if (is_prime(possible_prime)) {
++i;
}
possible_prime += 2;
}
return possible_prime - 2;
}
int main()
{
int prime[100];
int count = 0;
for(int i = 2; i <=100; i ++ ) {
if(is_prime(i)) {
prime[count] = i;
count++;
}
}
int input_num;
while(scanf("%d", &input_num) == 1) {
int list[100];
memset(list, 0, sizeof(list));
int num = 1;
int total = 0;
for(int i = input_num; i > 0; i --) {
num = num * i;
for(int i = 0; i < count; i ++) {
int time = 0;
while((num % prime[i]) == 0) {
num = num / prime[i];
time ++;
}
list[i] += time;
if(i > total) total = i;
if(prime[i] > num) break;
}
}
for(int i = 0; i <= total; i ++)
printf("%d ", list[i]);
printf("\n");
}
return 0;
}
int main( int argc, char* argv[] ) {
// Check we have the right arguments and read them in.
if ( argc != 3 ) { printf("Usage: ./hw2a MAX_NUM NUM_THREADS"); return 1; }
int N = atoi( argv[1] );
int T = atoi( argv[2] );
// Set number of threads according to argument.
omp_set_dynamic(0);
omp_set_num_threads(T);
// Create a priority queue to hold the thread's output in a sensible manner.
std::priority_queue<int, std::vector<int>, std::greater<int> > pq;
// Deal with 2 as a special case, to simplify and speed up the loop.
int i;
#pragma omp parallel private(i) shared(pq)
{
#pragma omp for schedule(dynamic,16) nowait
for ( i = 3; i <= N; i += 2 ) {
bool prime = is_prime(i);
if ( prime ) {
#pragma omp critical
{
pq.push(i);
}
}
}
}
bool output = ( N >= 2 );
if ( output ) printf("2");
while ( !pq.empty() ) {
printf( ", %d", pq.top() );
pq.pop();
}
if ( output ) printf("\n");
return 0;
}
uint64_t next_prime(std::vector<uint64_t> & preceding)
{
if (preceding.empty())
{
preceding.push_back(2);
return preceding.back();
}
if (preceding.back() == 2)
{
preceding.push_back(3);
return preceding.back();
}
for (uint64_t n = preceding.back() + 2; ; n += 2)
{
if (is_prime(n, preceding))
{
preceding.push_back(n);
return preceding.back();
}
}
}
int main()
{
unsigned int last = 2000000;
unsigned int *primes = (unsigned int *) calloc(1, sizeof(unsigned int));
*primes = 2;
unsigned int numprimes = 1;
unsigned long long sum = 2;
unsigned int test;
for (test = 3; test < last; test+=2)
{
if (is_prime(test, numprimes, primes))
{
primes = realloc(primes, sizeof(int)*(numprimes+1));
primes[numprimes++] = test;
sum += test;
}
}
printf("%llu\n", sum);
free(primes);
exit(0);
}
/* Main routine. */
int main(int argc, char* argv[])
{
int i;
int count = 0;
double t1, t2;
t1 = get_time_sec();
for (i=1; i<=FINAL_NUM; i++) {
if (is_prime(i)) {
//printf("%d: %d is prime\n",id,i);
count++;
}
}
t2 = get_time_sec();
int denom = FINAL_NUM;
printf("There are %d prime numbers <= %d\n",count,FINAL_NUM);
printf("That is a ratio of %f, which should be about %f\n",
(double)count/(double)denom,
1.0/log((double)denom));
printf("It took %f seconds for the whole thing to run\n",t2-t1);
return 0;
} // end main
