Care este cel mai rapid algoritm pentru a afla numerele prime folosind C++? Am folosit sita's algoritm, dar eu încă mai doresc să fie mai repede!
Un foarte rapid punerea în aplicare a Sită de Atkin Dan Bernstein's nrim. Această sită este mai eficientă decât Sita lui Eratostene. Pagina lui are unele informații de referință.
Dacă trebuie să fie foarte rapid, puteți include o listă de numere prime:
http://www.bigprimes.net/archive/prime/
Dacă trebuie doar să știu dacă un anumit număr este un număr prim, există diverse prim-teste listate pe wikipedia. Acestea sunt, probabil, cea mai rapidă metodă pentru a determina dacă un număr mare sunt numere prime, mai ales pentru că ei vă pot spune dacă un număr este nu o prim.
El, el știu că am'm o întrebare necromant răspunde la întrebări vechi, dar am'am găsit această întrebare căutare pe net pentru moduri de a pune în aplicare eficientă numere prime teste.
Până acum, cred că cel mai rapid număr prim de testare algoritm este Puternic Probabile Prim (SPRP). Citez de la Nvidia CUDA forumuri:
Una dintre cele mai practice nișă probleme din teoria numerelor are de-a face cu identificarea unor numere prime. Dat N, cum poți eficient determina dacă este prim sau nu? Aceasta nu este doar o thoeretical problema, aceasta poate fi una reală necesare în cod, poate atunci când aveți nevoie pentru a dinamic găsi un prim tabel hash dimensiune în anumite intervale. Dacă N este ceva de ordinul a 2^30, chiar vrei să faci 30000 divizia de teste pentru a căuta orice factori? Evident că nu.
comună soluție practică la această problemă este un test simplu, numit un Euler probabile prim test, și un mai puternic generalizare numit un Puternic Probabile Prim (SPRP). Acesta este un test pentru o număr întreg N poate probabilistic clasifica ca prim sau nu, și teste repetate pot crește corectitudinea probabilitate. Partea lentă de testul în sine cea mai mare parte implică calcul o valoare similară cu A^(N-1) modulo N. Oricine implementarea RSA de criptare cu cheie publică variante a folosit acest algoritm. L's util atât pentru numere întregi (cum ar fi de 512 biți), precum și normală 32 sau 64 de biți int.
testul poate fi schimbat de la o probabilistice de respingere într-o dovada de primality de precomputing anumite testul de intrare parametrii care sunt cunoscute pentru a reuși întotdeauna pentru intervale de N. din Păcate, descoperirea acestor "cel mai cunoscut teste" este eficient căutare de un imens (de fapt infinit) de domeniu. În 1980, o primă listă de utile teste a fost creat de Carl Pomerance (renumit pentru a fi cel a-factor RSA-129 cu Pătratice Filtrării algoritm.) Mai Târziu Jaeschke îmbunătățit rezultatele în mod semnificativ în 1993. În 2004, Zhang și Tang îmbunătățirea teoriei și limitele domeniului de căutare. Greathouse și Livingstone au lansat cel mai modern rezultatele de până acum pe web, la http://math.crg4.com/primes.html cele mai bune rezultate de o mare căutare de domeniu.
Vezi aici pentru mai multe informatii: http://primes.utm.edu/prove/prove2_3.html și http://forums.nvidia.com/index.php?showtopic=70483
Dacă aveți nevoie doar de o modalitate de a genera foarte mari numere prime și don't grijă pentru a genera toate numerele prime < un număr întreg n, puteți utiliza Lucas-Lehmer test pentru a verifica numere prime Mersenne. Un număr prim Mersenne este în formă de 2^p-1. Cred că Lucas-Lehmer test este cel mai rapid algoritm descoperit de numere prime Mersenne.
Și dacă nu doriți să utilizați numai cel mai rapid algoritm, dar, de asemenea, cel mai rapid hardware-ul, încercați să-l pună în aplicare folosind tehnologia Nvidia CUDA, scrie un kernel pentru CUDA și rulați-l pe GPU.
Puteți chiar câștiga niște bani, dacă ai descoperi suficient de mari numere prime, FEP este de a da premii de la $50 la $250K: https://www.eff.org/awards/coop
Acolo este un 100% matematică test care va verifica dacă un număr de " P " este prim sau compus, numit AKS Primality Test.
Conceptul este simplu: dat fiind un număr "P", dacă toți coeficienții de (x-1)^P - (x^P-1)
sunt divizibile cu "P", apoi " P " este un număr prim, în caz contrar acesta este un număr compus.
De exemplu, dat P = 3
, ar da polinomului:
(x-1)^3 - (x^3 - 1)
= x^3 + 3x^2 - 3x - 1 - (x^3 - 1)
= 3x^2 - 3x
Și coeficienții sunt atât divizibil cu 3
, prin urmare, numărul este prim.
Și de exemplu, unde P = 4`, care NU este prim ar randament:
(x-1)^4 - (x^4-1)
= x^4 - 4x^3 + 6x^2 - 4x + 1 - (x^4 - 1)
= -4x^3 + 6x^2 - 4x
Și aici putem vedea că coeficienții 6
nu este divizibil cu 4 `a, prin urmare NU este prim.
Polinomului (x-1)^P
va P+1 termeni și pot fi găsite cu ajutorul combinație. Deci, acest test va rula în
O(n)` runtime, așa că don't știu cât de util ar fi, deoarece puteți pur și simplu repeta peste " i "de la 0 la" p " și testare pentru restul.
Este problema ta pentru a decide dacă un anumit număr este prim? Atunci ai nevoie de un primality test (ușor). Sau ai nevoie de toate numerele prime până la un număr dat? În acest caz, prim-sitele sunt bune (ușor, dar necesită memorie). Sau ai nevoie de factori primi a unui număr? Acest lucru ar necesita factorizare (dificil pentru un număr mare, dacă doriți cu adevărat cele mai eficiente metode). Cat de mari sunt numere se uita la? 16 bits? 32 de biți? mai mare?
Unul inteligent și eficient mod este de a pre-calcula tabele de numere prime și păstrați-le într-un fișier folosind un nivel de bit codificare. Fișierul este considerat unul lung bit vector întrucât pic n reprezintă numărul întreg n. Dacă n este prim, sa de bit este setat la unu și zero în caz contrar. Căutare este foarte rapid (ai calcula octeților și o mască de biți) și nu are nevoie de încărcare fișier în memorie.
Rabin-Miller este un standard probabilistic primality test. (îl rulați K ori, iar numărul de intrare este cu siguranta compozit, sau este probabil prim, cu o probabilitate de eroare de 4-K. (câteva sute de iterații și it's aproape sigur vă spun adevărul)
Acolo este un non-probabilistice (deterministe) varianta de Rabin Miller.
De Great Internet Mersenne Prime Search (PROȘTI), care a descoperit lumea's recordul pentru cel mai mare dovedit prime (274,207,281 - 1 iunie 2017), foloseste mai multe algoritmi, dar acestea sunt numere prime în forme speciale. Cu toate acestea, AMĂRÂȚILOR pagina de mai sus nu include unele generale deterministe primality teste. Ele par a indica faptul că ceea ce algoritm este "mai" depinde de dimensiunea de număr pentru a fi testate. Dacă numărul tău se potrivește în 64 de biți, atunci probabil că ar trebui't folosi o metodă destinată să lucreze la numerele de mai multe milioane de cifre.
Aceasta depinde de cererea dumneavoastră. Există unele considerații:
Miller-Rabin și analog teste sunt doar mai repede decât o sită pentru numere peste o anumită dimensiune (undeva în jur de câteva milioane de euro, cred). Mai jos, folosind un proces de diviziune (dacă aveți doar câteva numere) sau o sită este mai rapid.
Eu vă va permite să decidă dacă-l's cel mai rapid sau nu.
using System;
namespace PrimeNumbers
{
public static class Program
{
static int primesCount = 0;
public static void Main()
{
DateTime startingTime = DateTime.Now;
RangePrime(1,1000000);
DateTime endingTime = DateTime.Now;
TimeSpan span = endingTime - startingTime;
Console.WriteLine("span = {0}", span.TotalSeconds);
}
public static void RangePrime(int start, int end)
{
for (int i = start; i != end+1; i++)
{
bool isPrime = IsPrime(i);
if(isPrime)
{
primesCount++;
Console.WriteLine("number = {0}", i);
}
}
Console.WriteLine("primes count = {0}",primesCount);
}
public static bool IsPrime(int ToCheck)
{
if (ToCheck == 2) return true;
if (ToCheck < 2) return false;
if (IsOdd(ToCheck))
{
for (int i = 3; i <= (ToCheck / 3); i += 2)
{
if (ToCheck % i == 0) return false;
}
return true;
}
else return false; // even numbers(excluding 2) are composite
}
public static bool IsOdd(int ToCheck)
{
return ((ToCheck % 2 != 0) ? true : false);
}
}
}
Este nevoie de aproximativ 82 de secunde pentru a găsi și de imprimare numere prime într-un interval de 1 la 1.000.000, pe Core 2 Duo laptop cu o 2.40 GHz. Și a găsit 78,498 numere prime.
Intotdeauna mi-am folosi această metodă pentru calcularea numere prime numerele următoare cu sită algoritm.
void primelist()
{
for(int i = 4; i < pr; i += 2) mark[ i ] = false;
for(int i = 3; i < pr; i += 2) mark[ i ] = true; mark[ 2 ] = true;
for(int i = 3, sq = sqrt( pr ); i < sq; i += 2)
if(mark[ i ])
for(int j = i << 1; j < pr; j += i) mark[ j ] = false;
prime[ 0 ] = 2; ind = 1;
for(int i = 3; i < pr; i += 2)
if(mark[ i ]) ind++; printf("%d\n", ind);
}
Eu nu't știu despre orice predefinite algoritm, dar am creat propriul meu care este foarte rapid. Se poate procesa 20 de cifre numere în mai puțin de 1 secunde. Max capacitate de acest program este 18446744073709551615. Programul este :
#include <iostream>
#include <cmath>
#include <stdlib.h>
using namespace std;
unsigned long long int num = 0;
bool prime() {
if (num % 2 == 0 || num == 1) {
return false;
}
unsigned long int square_root = sqrt(num);
for (unsigned long int i = 3; i <= square_root; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
int main() {
do {
system("cls");
cout << "Enter number : ";
cin >> num;
if (prime()) {
cout << "The number is a prime number" << endl << endl << endl << endl;
} else {
cout << "The number is not a prime number" << endl << endl << endl << endl;
}
system("pause");
} while (1);
return 0;
}
#include<stdio.h>
main()
{
long long unsigned x,y,b,z,e,r,c;
scanf("%llu",&x);
if(x<2)return 0;
scanf("%llu",&y);
if(y<x)return 0;
if(x==2)printf("|2");
if(x%2==0)x+=1;
if(y%2==0)y-=1;
for(b=x;b<=y;b+=2)
{
z=b;e=0;
for(c=2;c*c<=z;c++)
{
if(z%c==0)e++;
if(e>0)z=3;
}
if(e==0)
{
printf("|%llu",z);
r+=1;
}
}
printf("|\n%llu outputs...\n",r);
scanf("%llu",&r);
}
Știu că's ceva mai târziu, dar acest lucru ar putea fi util pentru persoanele care sosesc aici din căutări. Oricum, aici's un JavaScript care se bazează pe faptul că numai factori trebuie să fie testate, astfel încât mai devreme numere prime generate de cod sunt re-utilizate ca test factori pentru cele de mai târziu. Desigur, toate, chiar și de mod 5 valori sunt filtrate mai întâi. Rezultatul va fi în matrice P, și acest cod poate crunch 10 milioane de numere prime în sub 1.5 secunde pe un i7 PC (sau 100 de milioane de euro în aproximativ 20). Rescris în C ar trebui să fie foarte rapid.
var P = [1, 2], j, k, l = 3
for (k = 3 ; k < 10000000 ; k += 2)
{
loop: if (++l < 5)
{
for (j = 2 ; P[j] <= Math.sqrt(k) ; ++j)
if (k % P[j] == 0) break loop
P[P.length] = k
}
else l = 0
}
#include <iostream>
using namespace std;
int set [1000000];
int main (){
for (int i=0; i<1000000; i++){
set [i] = 0;
}
int set_size= 1000;
set [set_size];
set [0] = 2;
set [1] = 3;
int Ps = 0;
int last = 2;
cout << 2 << " " << 3 << " ";
for (int n=1; n<10000; n++){
int t = 0;
Ps = (n%2)+1+(3*n);
for (int i=0; i==i; i++){
if (set [i] == 0) break;
if (Ps%set[i]==0){
t=1;
break;
}
}
if (t==0){
cout << Ps << " ";
set [last] = Ps;
last++;
}
}
//cout << last << endl;
cout << endl;
system ("pause");
return 0;
}
#include<iostream>
using namespace std;
void main()
{
int num,i,j,prime;
cout<<"Enter the upper limit :";
cin>>num;
cout<<"Prime numbers till "<<num<<" are :2, ";
for(i=3;i<=num;i++)
{
prime=1;
for(j=2;j<i;j++)
{
if(i%j==0)
{
prime=0;
break;
}
}
if(prime==1)
cout<<i<<", ";
}
}