Der Schnellste Weg zu finden, alle Primzahlen unter 4 Mrd.

Ich versuche zu drucken jede Primzahl unter 2**32. Bis jetzt bin ich mit einem bool-Vektor zu bauen, die ein Sieb und dann drucken Sie die Primzahlen nach dem Sieb. Es dauert 4 Minuten, nur um drucken Sie die Primzahlen bis 1 Milliarde. Gibt es einen schnelleren Weg, dies zu tun?? Hier ist mein code

#include <iostream>
#include <cstdlib>
#include <vector>
#include <math.h>

using namespace std;

int main(int argc, char **argv){
  long long limit = atoll(argv[1]);
  //cin >> limit;
  long long sqrtlimit = sqrt(limit);

  vector<bool> sieve(limit+1, false);

  for(long long n = 4; n <= limit; n += 2)
    sieve[n] = true;

  for(long long n=3; n <= sqrtlimit; n = n+2){
    if(!sieve[n]){
      for(long long m = n*n; m<=limit; m=m+(2*n))
        sieve[m] = true;
    }
  }

  long long last;
  for(long long i=limit; i >= 0; i--){
    if(sieve[i] == false){
      last = i;
      break;
    }
  }
  cout << last << endl;

  for(long long i=2;i<=limit;i++)
  {
    if(!sieve[i])
      if(i != last)
        cout<<i<<",";
      else
        cout<<i;
  }
  cout<<endl;

Sollte Sie waaaaay mehr als 4 Minuten zum drucken der ersten Milliarde Primzahlen.
Ich denke, der Schnellste Weg wäre, zu überspringen, alle zahlen, die Sie wissen, arent prime, zum Beispiel, zahlen endend mit 2,4,5 (Nach 5), 6, 8, 0
Ich Stimme mit @Mysticial sollte es dauern viel länger als 4 Minuten (es sei denn, Sie haben ein super-computer).
Nein, was ich meinte war, alle Primzahlen unter 1 Milliarde sorry bearbeitet
wenn es dauert 4 min. für 1 Milliarden, dauert es 16 min. für 4 Milliarden Euro, und das ist nicht so schlimm im Vergleich zu der Wartezeit für eine Antwort auf SO. und sobald Sie berechnet haben Sie Sie nie brauchen, um zu berechnen, Sie wieder. heck nur bekommen aus dem web und mit ihm getan werden!
richtig, aber ich brauche, um die Ausgabe in weniger als 10 Sekunden. seine für einen Wettbewerb
Um die Speicheranforderungen zu senken, die Informationen über prime oder nicht prime wurde gespeichert für 30 ganze zahlen in jedem byte. Nur ein bit benötigt wird, zu speichern, prime oder nicht prime für eine ganze Zahl. Der Wert der integer ist bekannt durch den Standort des bit. In jeweils 30 zahlen, für N >= 1, die zahlen, die möglicherweise prime N*30+1, N*30+7, N*30+11, N*30+13, N*30+17, N*30+19, N*30+23, N*30+29 rsok.com/~jrm/printprimes.html
Ist es ein Wettbewerb, wer kann am besten die google-Suche? 😉
auch trennen sich Ihre Zeiten für die generation vs ausdrucken. es gibt nichts, was Sie tun können, zu drucken und können weder Ihre Mitbewerber. konzentrieren Sie sich nur auf die Zeit der Erstellung.
Wettbewerb ist das falsche Wort. seine Herausforderung online. nicht wirklich im Wettbewerb mit jedermann.
Wenn Sie diese Antwort in 10 Sekunden, dann wirst du über die Dinge der falsche Weg. Man kann Sie nicht berechnen, dass viele zahlen, die schnell. Was tun Sie wirklich brauchen, zu finden?
10s für die Berechnung der Primzahlen ist nicht so weit Weg. Mit Rad-Faktorisierung ist es möglich, die Berechnung der Primzahlen bis zu einer Milliarde in den 20er Jahren, auf einer einzigen 1,83 GHz core in Java.
in der Regel der Weg zu gehen, ist ein segmentiertes Sieb mit Rad-Faktorisierung. die Antwort präsentiert eine offset-Sieb auf Quoten, etwas zu beginnen.

InformationsquelleAutor ordinary | 2013-09-21

algorithm c++primes sieve-of-eratosthenes

4

Ich diskutieren das problem der Erzeugung großer zahlen von Prime an meinem blog, wo finde ich die Summe der ersten Milliarde Primzahlen ist 11138479445180240497. Ich beschreibe vier verschiedene Methoden:
1. Brute-force -, Prüf-jede Zahl ab 2 mit trial-division.
2. Generieren Kandidaten mit einem 2,3,5,7-Rad, dann primality test mit strong pseudoprime tests zu den Basen 2, 7 und 61; diese Methode funktioniert nur bis 2^32, das war nicht ausreichend für mich, um die Summe der ersten Milliarde Primzahlen, aber ausreichend für Sie.
3. Einen Algorithmus aufgrund von Melissa O ' Neill verwendet, Sieb, eingebettet in eine priority-queue, die ist ziemlich langsam.
4. Einer segmentierten Sieb des Eratosthenes, das ist sehr schnell, aber erfordert Speicherplatz zum speichern des Sieb-Primzahlen und das Sieb selbst.
InformationsquelleAutor user448810

Dies wird wahrscheinlich beschleunigen ein bisschen:

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

int main()
{
    std::vector<unsigned long long> numbers;
    unsigned long long maximum = 4294967296;
    for (unsigned long long i = 2; i <= maximum; ++i)
    {
        if (numbers.empty())
        {
            numbers.push_back(i);
            continue;
        }

        if (std::none_of(numbers.begin(), numbers.end(), [&](unsigned long long p)
        {
            return i % p == 0;
        }))
        {
            numbers.push_back(i);
        }

    }

    std::cout << "Primes:  " << std::endl;
    std::copy(numbers.begin(), numbers.end(), std::ostream_iterator<int>(std::cout, " "));

    return 0;
}

Es ist eine Art Umkehrung des Sieb des Eratosthenes (statt beginnend mit jeder Zahl unter der Grenze und die Beseitigung der vielfachen, es fängt bei 2 an und ignoriert Vielfache bis zu dem limit).

Ja. Es kompiliert und läuft (aber mal aus) auf ideone. Kompilieren und ausführen es mit VS2010 und VS2012 dauert etwa 2 Minuten auf meinem Rechner.

InformationsquelleAutor Zac Howland

0

Der Schnellste Weg wäre wohl eine vorgenerierte Liste.

http://www.bigprimes.net/ hat die ersten 1,4 Milliarden Primzahlen zum download zur Verfügung, die sollte jede Primzahl unter 30 Milliarden oder so.

Ich nehme an, das laden des binären könnte zu lange dauern, wenn es ein paar Gigabyte groß.
- online-Wettbewerb-sites akzeptieren in der Regel nur source-code und source-code-size-limit, das dies verhindern würde.
- Es wird allgemein angenommen, unter Programmierern, die sich regelmäßig mit Primzahlen, die schneller generieren von Primzahlen als Sie zu Lesen von einer Festplatte.
InformationsquelleAutor Yakk - Adam Nevraumont
0

Haben Sie getestet, was die meiste Zeit? Ist es das Sieb selbst, oder das schreiben der Ausgabe?

Einem schnellen Weg, um die Geschwindigkeit des Siebes ist zu stoppen, sich Gedanken über alle geraden zahlen. Es gibt nur eine gerade Zahl, die eine Primzahl, und Sie können schwer-code. Größe die Größe der Arrays in der Hälfte, die immens helfen, wenn Sie stoßen an die Grenzen des physischen Speichers.
```
vector<bool> sieve((limit+1)/2, false);
...
  for(long long m = n*n/2; m<=limit/2; m=m+n)
    sieve[m] = true;
```
Als für die Produktion selbst, cout ist notorisch ineffizient. Es könnte effizienter sein, rufen Sie itoa oder entsprechende selbst, dann verwenden Sie cout.write ausgegeben werden. Sie könnte sogar gehen alte Schule und nutzen fwrite mit stdout.

InformationsquelleAutor Mark Ransom

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.