int main(void) { FindPrimes find_primes(10001); list_of_primes primes = find_primes(); std::cout << "Number of primes: " << primes.size() << std::endl; std::cout << "10001st number: " << primes.back() << std::endl; }
int main(int argc, char** argv) { int plen, diff, k, i_l, j_l, k_l; int* i_s; int* j_s; int* k_s; int* primes = find_primes(10000, &plen); for (int i = 0; i < plen; ++i) { for (int j = i + 1; j < (plen-1); ++j) { if (primes[i] < 1000 || primes[j] < 1000 || primes[i] == 1487) continue; // primes[j] > primes[i] diff = primes[j] - primes[i]; k = primes[j] + diff; if (k < 10000 && is_prime(primes, plen, k)) { i_s = split_number(primes[i], &i_l); j_s = split_number(primes[j], &j_l); if (are_perms49(i_s, j_s)) { k_s = split_number(k, &k_l); if (are_perms49(j_s, k_s)) { printf("%d %d %d\n", primes[i], primes[j], k); free(k_s); free(j_s); free(i_s); return 0; } free(k_s); } free(j_s); free(i_s); } } } return 0; }
list_of_primes operator()(void) const { list_of_primes primes; primes.push_back(2); primes.push_back(3); return find_primes(primes, 5); }
list_of_primes find_primes(const list_of_primes &primes, const number start) const { if (primes.size() < _max_number_of_primes) { if (is_prime(primes, start, 1, (number) (sqrt((double) start) + 0.5))) { list_of_primes new_list = primes; new_list.push_back(start); return find_primes(new_list, start+2); } else return find_primes(primes, start+2); } else return primes; }
int main() { int n, m, i; find_primes(100); scanf("%d %d", &n, &m); for(i=0; prime[i]<=n; i++); printf("%s", prime[i]==m ? "YES" : "NO"); return 0; }
int main(){ find_primes(600851475143); return 0; }
int main (int argc, char *argv[]) { char *progname = argv[0]; mpz_t fr, to; mpz_t fr2, to2; unsigned long sieve_lim; unsigned long est_n_primes; unsigned char *s; mpz_t tmp; mpz_t siev_sqr_lim; while (argc != 1) { if (strcmp (argv[1], "-c") == 0) { flag_count = 1; argv++; argc--; } else if (strcmp (argv[1], "-p") == 0) { flag_print = 2; argv++; argc--; } else if (strcmp (argv[1], "-g") == 0) { flag_maxgap = 1; argv++; argc--; } else break; } if (flag_count || flag_maxgap) flag_print--; /* clear unless an explicit -p */ mpz_init (fr); mpz_init (to); mpz_init (fr2); mpz_init (to2); if (argc == 3) { mpz_set_str (fr, argv[1], 0); if (argv[2][0] == '+') { mpz_set_str (to, argv[2] + 1, 0); mpz_add (to, to, fr); } else mpz_set_str (to, argv[2], 0); } else if (argc == 2) { mpz_set_ui (fr, 0); mpz_set_str (to, argv[1], 0); } else { fprintf (stderr, "usage: %s [-c] [-p] [-g] [from [+]]to\n", progname); exit (1); } mpz_set (fr2, fr); if (mpz_cmp_ui (fr2, 3) < 0) { mpz_set_ui (fr2, 2); report (fr2); mpz_set_ui (fr2, 3); } mpz_setbit (fr2, 0); /* make odd */ mpz_sub_ui (to2, to, 1); mpz_setbit (to2, 0); /* make odd */ mpz_init (tmp); mpz_init (siev_sqr_lim); mpz_sqrt (tmp, to2); #define SIEVE_LIMIT 10000000 if (mpz_cmp_ui (tmp, SIEVE_LIMIT) < 0) { sieve_lim = mpz_get_ui (tmp); } else { sieve_lim = SIEVE_LIMIT; mpz_sub (tmp, to2, fr2); if (mpz_cmp_ui (tmp, sieve_lim) < 0) sieve_lim = mpz_get_ui (tmp); /* limit sieving for small ranges */ } mpz_set_ui (siev_sqr_lim, sieve_lim + 1); mpz_mul_ui (siev_sqr_lim, siev_sqr_lim, sieve_lim + 1); est_n_primes = (size_t) (sieve_lim / log((double) sieve_lim) * 1.13) + 10; primes = malloc (est_n_primes * sizeof primes[0]); make_primelist (sieve_lim); assert (est_n_primes >= n_primes); #if DEBUG printf ("sieve_lim = %lu\n", sieve_lim); printf ("n_primes = %lu (3..%u)\n", n_primes, primes[n_primes - 1].prime); #endif #define S (1 << 15) /* FIXME: Figure out L1 cache size */ s = malloc (S/2); while (mpz_cmp (fr2, to2) <= 0) { unsigned long rsize; rsize = S; mpz_add_ui (tmp, fr2, rsize); if (mpz_cmp (tmp, to2) > 0) { mpz_sub (tmp, to2, fr2); rsize = mpz_get_ui (tmp) + 2; } #if DEBUG printf ("Sieving region ["); mpz_out_str (stdout, 10, fr2); printf (","); mpz_add_ui (tmp, fr2, rsize - 2); mpz_out_str (stdout, 10, tmp); printf ("]\n"); #endif sieve_region (s, fr2, rsize); find_primes (s, fr2, rsize / 2, siev_sqr_lim); mpz_add_ui (fr2, fr2, S); } free (s); if (flag_count) printf ("Pi(interval) = %lu\n", total_primes); if (flag_maxgap) printf ("max gap: %lu\n", maxgap); return 0; }
/* * Run multi-process prime finder program. */ int main(int argc, char **argv) { /* check if enough command line args have been supplied and exit on error if not */ if (argc <= 1) { printf("usage: ./primes <increasing positive integers>\n"); exit(-1); } int num_args = argc - 1; /* number of arguements provided (number of numbers provided to check) */ int nums[num_args]; /* array to hold the integer command line args */ int fds[num_args][2]; /* file descriptor arrays for pipe */ int read_fds[num_args]; /* file descriptors to read from */ int max_fd; /* max fd to select */ int bottom; /* bottom of range */ int top; /* top of range */ int child_count; /* number of children for parent to keep track of */ int read_buff; /* int buffer for reading primes from children */ int i, n; pid_t pid; /* pid of the parent/child processes */ pid_t pid_array[num_args]; /* array of child pids */ char fifo_name[20]; /* buffer for creating the names for the FIFO's */ /* get the integers that the user entered */ for (i = 1 ; i < argc ; i++) { nums[i - 1] = atoi(argv[i]); } /* create pipes and FIFO's */ for (i = 0 ; i < num_args ; i++) { if ((i + 1) % 2 != 0) { /* create pipes for odd children */ if (pipe(fds[i]) < 0) { /* pipe error */ perror("pipe"); exit(-1); } /* load file descriptor to read from into read_fds */ read_fds[i] = fds[i][0]; } else { /* create FIFO's for even children */ memset(fifo_name, '\0', 20 * sizeof(char)); sprintf(fifo_name, "fifo%d", i); if (mkfifo(fifo_name, 0666) < 0) { /* fifo error */ perror("mkfifo"); exit(-1); } /* open fifo on parent end and load file descriptor to read from into read_fds */ if ((read_fds[i] = open(fifo_name, O_RDONLY | O_NONBLOCK)) < 0) { perror("open"); exit(-1); } } } /* create child processes and setup pipes/FIFO */ for (i = 0, child_count = 0 ; i < num_args ; i++) { /* odd child case - use pipe */ if ((i + 1) % 2 != 0) { if ((pid = fork()) < 0) { /* fork error */ printf("\nERROR: Unable to fork.\n"); exit(-1); } else if (pid == 0) { /* child */ /* close read side of pipe for child */ if (close(fds[i][0]) < 0) { printf("\nERROR: child unable to close fd %d\n", fds[i][0]); exit(-1); } if (i == 0) { bottom = 2; } else { bottom = nums[i - 1] + 1; } top = nums[i]; int num_primes = find_primes(bottom, top, fds[i][1]); /* printf("child %d: exiting with %d\n", (int)getpid(), num_primes); */ /* exit with number of primes found */ exit(num_primes); } else { /* parent */ pid_array[i] = pid; child_count++; /* close write side of pipe for parent */ if (close(fds[i][1]) < 0) { printf("\nERROR: parent unable to close fd %d\n", fds[i][1]); exit(-1); } } /* even child case - use FIFO */ } else { if ((pid = fork()) < 0) { /* error */ printf("\nERROR: Unable to fork.\n"); exit(-1); } else if (pid == 0) { /* child */ if (i == 0) { bottom = 2; } else { bottom = nums[i - 1] + 1; } top = nums[i]; memset(fifo_name, '\0', 20 * sizeof(char)); sprintf(fifo_name, "fifo%d", i); /* open fifo on child end and get the fd to write to */ int write_fd; if ((write_fd = open(fifo_name, O_APPEND | O_WRONLY | O_NONBLOCK)) < 0) { perror("open"); exit(-1); } int num_primes = find_primes(bottom, top, write_fd); /* printf("child %d: exiting with %d\n", (int)getpid(), num_primes); */ /* exit with number of primes found */ exit(num_primes); } else { /* parent */ pid_array[i] = pid; child_count++; } } } /* set max fd to read from */ for (i = 0, max_fd = 0 ; i < num_args ; i++) { if (max_fd < read_fds[i]) max_fd = read_fds[i]; } /* setup select */ fd_set read_set; struct timeval timeout; timeout.tv_sec = 5; timeout.tv_usec = 0; int ret; pid_t exited_child; int exit_status; while (child_count) { FD_ZERO(&read_set); for (i = 0 ; i < num_args ; i++) { if (read_fds[i] != -1) FD_SET(read_fds[i], &read_set); } ret = select(max_fd + 1, &read_set, NULL, NULL, &timeout); /* no activity */ if (ret == 0) { continue; } /* error */ else if (ret < 0) { perror("select"); exit(-1); } /* activity on some fds */ else { /* check which fds were written to */ for (i = 0 ; i < num_args; i++) { /* if the file descriptor associated with the child is set, read from it */ if (FD_ISSET(read_fds[i], &read_set)) { /* read all primes from child and print to screen if there are any */ while (1) { if ((n = read(read_fds[i], &read_buff, sizeof(int))) < 0) { /* if failed read is just because the file is being used by a child, ignore it */ if (errno != 11) { perror("read"); exit(-1); } } else if (n > 0) { printf("%d is prime from %d\n", read_buff, pid_array[i]); } else { break; } } /* check if child has exited if it hasn't already been confirmed exited */ if ((exited_child = waitpid(pid_array[i], &exit_status, WNOHANG)) != 0) { if (exited_child < 0) { perror("waitpid"); exit(-1); } else { /* remove fifo file if even child */ if ((i + 1) % 2 == 0) { memset(fifo_name, '\0', 20 * sizeof(char)); sprintf(fifo_name, "fifo%d", i); if (remove((const char*)fifo_name) < 0) { perror("remove"); exit(-1); } } /* decrement child count, "remove" child's pid from pid_array, and print exit status */ child_count--; close(read_fds[i]); read_fds[i] = -1; printf("child %d exited correctly and found %d primes\n", (int)exited_child, WEXITSTATUS(exit_status)); } } } } } } return 0; }