Mit diesem kurzen Programm lassen sich in kürzester Zeit sehr hohe Primzahlen er,itteln.
Die Bestimmung von z.B einem Intervall von 2 bis in den Milliardenbereich dauert sicher Stunden oder Tage, je nach
Leistung des Computers.
Mit einem Trick ist die Bestimmung von sehr hohen Primzahlen in Sekunden erledigt.
Beispiel:
Untergrenze 1000000500
Obergrenze 1000000700
Ergebnis :
1000000513
1000000531
1000000579
1000000607
1000000637
1000000637
1000000663
Diese Zahlen -( sind sie vollständig ??, das könnte mandurch Veränderung des Intervalls nachprüfen) wurdenalle durch ein Primfaktorenzerlegungsprogramm bestätigt.
kleine Mathe-Spielereien
Wie sind die Primzahlen bei sehr hohen Zahlenwerten verteilt ?
Der Versuch zeigt das Ergebnis der Auswertung:
10500 bis 10600 10 Primzahlen
100500 100600 7
1000500 1000600 4
10000500 10000600 5
100000500 100000600 3
1000000500 1000000600 5
10000000500 10000000600 3
100000000500 100000000600 4
ein Vergleich dazu mit größeren Intervallen :
1000000000500 100000000800 10
hier auch die Primzahlen dazu
1000000000519
567 3
579
621
631 4
637
669
703
739 3
747
ergibt sich auch bei größeren ein gleiches Veetewilunsmuster.
Kann daraus ein Verteilungsmuster auf die gesamten Primzahlen geschlossen werden?
Eine Vermutung könnte wohl aufgestellt werden, etwa so wie bereits oben im Plot gezeigt ?
Oswald
Der Versuch zeigt das Ergebnis der Auswertung:
10500 bis 10600 10 Primzahlen
100500 100600 7
1000500 1000600 4
10000500 10000600 5
100000500 100000600 3
1000000500 1000000600 5
10000000500 10000000600 3
100000000500 100000000600 4
ein Vergleich dazu mit größeren Intervallen :
1000000000500 100000000800 10
hier auch die Primzahlen dazu
1000000000519
567 3
579
621
631 4
637
669
703
739 3
747
ergibt sich auch bei größeren ein gleiches Veetewilunsmuster.
Kann daraus ein Verteilungsmuster auf die gesamten Primzahlen geschlossen werden?
Eine Vermutung könnte wohl aufgestellt werden, etwa so wie bereits oben im Plot gezeigt ?
Oswald
Über Primzahlzwillinge ist eigentlich alles bekannt.
Es gibt komplizierte Programme tzur Ermittlung derselben.
Durch eine kleine Ergänzung meines vorliegendes Programm
konnte ich zwar nicht die kompletten Twillingspaare identifizieren,
aber doch zumindest kennzeichnen
Dabei wird jedes Zwillingspaar durch ein 'Z' erkannt. Der zweite Teil
des Zwillingspaares ist bekannt( n, n+2).
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #
for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):
print(i)
print("Z ") # und auch hier #
Dieses kieine Programm zeigt wie mächtig Python ist. Und das machtr einfach Spaß.
Oswald
Es gibt komplizierte Programme tzur Ermittlung derselben.
Durch eine kleine Ergänzung meines vorliegendes Programm
konnte ich zwar nicht die kompletten Twillingspaare identifizieren,
aber doch zumindest kennzeichnen
Dabei wird jedes Zwillingspaar durch ein 'Z' erkannt. Der zweite Teil
des Zwillingspaares ist bekannt( n, n+2).
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #
for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):
print(i)
print("Z ") # und auch hier #
Dieses kieine Programm zeigt wie mächtig Python ist. Und das machtr einfach Spaß.
Oswald
Der erste Test für einen hohen Zahlenbereich for Primzahlzwillinge.
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============= RESTART: C:\Python310\Beispiele\PRIMZASHLZwillinge.py ============
Anfangswert :5000000000100
Maximalwert eingeben: 5000000000900
5000000000447
Z
5000000000729
Z
################
Mit 4 GB Hauptspeicher schafft mein Pc diesen hohen Bereich noch ganz gut.
5 Trillonen schaffte er in 30 min nicht mehr. (Abbruch)
Mit mehr Hauptspeicher sollten 1000fach höhere Bereiche geschafft werden.
Der Test beweist die Seltenheit von Primzahlzwillingen in hohen Zahlenbereichen( chin. Mathematiker)
(Wie hoch ist der ekannteste Prim.Zahl.UZw. ?)
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============= RESTART: C:\Python310\Beispiele\PRIMZASHLZwillinge.py ============
Anfangswert :5000000000100
Maximalwert eingeben: 5000000000900
5000000000447
Z
5000000000729
Z
################
Mit 4 GB Hauptspeicher schafft mein Pc diesen hohen Bereich noch ganz gut.
5 Trillonen schaffte er in 30 min nicht mehr. (Abbruch)
Mit mehr Hauptspeicher sollten 1000fach höhere Bereiche geschafft werden.
Der Test beweist die Seltenheit von Primzahlzwillingen in hohen Zahlenbereichen( chin. Mathematiker)
(Wie hoch ist der ekannteste Prim.Zahl.UZw. ?)
Endlich ist es mir gelungen: Das Programm zur Berechnung aller Primzahlen im Bereich von Unter- bis Obergrenze.
Es war eigentlich einfacher als zunächst angenommen.
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: "))
pzahl = list
pzahl = []
for i in range(unten,oben+1):
if prim(i) == True :
pzahl == pzahl.append (i)
print(" Anzahl Primzahlen von Anfangswert ", unten, "bis Maximalwert", oben )
print(len(pzahl))
########################################
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert : 2
Maximalwert eingeben: 10000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 10000000
664579
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
Hier zwei Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
#######################################################
Hier zwei erste Ergenisse. Bearbewitungsdauer wenige Sec.
Ein weiterer Versuch mit 100, 000,000 Zahlen musste nach 20 20 min beendet werden. Mein Pc mit 4 GB (LENOVO)
leistet offenbar nicht mehr.
Als nächstes verde ich versuchen , die Anzahl von Primzahlzwillingen in diversen Interavallen zu berechnen.
Zum Ende meiner 'Spielereien bin ich erstaunt , was Python im Vergeich zu anderen Programmiersprachen
aber mit relativ geringem Aufwand zu leisten vermag.
Oswald
Es war eigentlich einfacher als zunächst angenommen.
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: "))
pzahl = list
pzahl = []
for i in range(unten,oben+1):
if prim(i) == True :
pzahl == pzahl.append (i)
print(" Anzahl Primzahlen von Anfangswert ", unten, "bis Maximalwert", oben )
print(len(pzahl))
########################################
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert : 2
Maximalwert eingeben: 10000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 10000000
664579
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
Hier zwei Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\AnzahlPrimzahlen.py =============
Anfangswert :2
Maximalwert eingeben: 1000000
Anzahl Primzahlen von Anfangswert 2 bis Maximalwert 1000000
78498
#######################################################
Hier zwei erste Ergenisse. Bearbewitungsdauer wenige Sec.
Ein weiterer Versuch mit 100, 000,000 Zahlen musste nach 20 20 min beendet werden. Mein Pc mit 4 GB (LENOVO)
leistet offenbar nicht mehr.
Als nächstes verde ich versuchen , die Anzahl von Primzahlzwillingen in diversen Interavallen zu berechnen.
Zum Ende meiner 'Spielereien bin ich erstaunt , was Python im Vergeich zu anderen Programmiersprachen
aber mit relativ geringem Aufwand zu leisten vermag.
Oswald
Die Ausgabe von P-Zwillingen wird jetzt verbessert
#################Primzahlwillinge anzeigen
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
Z =" "
unten = int(input ("Anfangswert :" , ))
oben = int(input("Maximalwert eingeben: " ,))
for i in range(unten,oben+1):
if prim(i) == True or prim(i+1) == 'Z' :
print('Z',i )
print(i+2)
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
=========== RESTART: C:\Python310\Beispiele\PrimwillingeAnzeigenn.py ===========
Anfangswert :2
Maximalwert eingeben: 50
Z 2
4
Z 3
5
Z 5
7
Z 7
9
Z 11
13
Z 13
15
Z 17
19
Z 19
21
Z 23
25
Z 29
31
Z 31
33
Z 37
39
Z 41
43
Z 43
45
Z 47
49
#################Primzahlwillinge anzeigen
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
Z =" "
unten = int(input ("Anfangswert :" , ))
oben = int(input("Maximalwert eingeben: " ,))
for i in range(unten,oben+1):
if prim(i) == True or prim(i+1) == 'Z' :
print('Z',i )
print(i+2)
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
=========== RESTART: C:\Python310\Beispiele\PrimwillingeAnzeigenn.py ===========
Anfangswert :2
Maximalwert eingeben: 50
Z 2
4
Z 3
5
Z 5
7
Z 7
9
Z 11
13
Z 13
15
Z 17
19
Z 19
21
Z 23
25
Z 29
31
Z 31
33
Z 37
39
Z 41
43
Z 43
45
Z 47
49
Mit "verbessert" meinst Du, dass jede Primzahle ein Zwilling ist. `prim` liefert nie als Rückgabewert den String "Z".
Die Funktion `prim` liefert immer noch falsche Werte.
Ein `pzahl = list` macht keinen Sinn, wenn die Variable eh gleich danach an eine leere Liste gebunden wird.
Was soll der Vergleich von pzahl mit dem Rückgabewert von append (der immer None ist)?
Die Funktion `prim` liefert immer noch falsche Werte.
Ein `pzahl = list` macht keinen Sinn, wenn die Variable eh gleich danach an eine leere Liste gebunden wird.
Was soll der Vergleich von pzahl mit dem Rückgabewert von append (der immer None ist)?
Offenbar habe ich mich mißverständlich ausgdrückt.
Natürlich ist nicht jede Primzahl ein Zwilling, aber es sind immer 2 Primzahlen, aus denen
ein Zwilling besteht und genau diese wollte ich anzeigen.
Wenn die Funktion prim() immer noch falsche Werte liefert, sind dann alle hier gezeigten Primzahlen falsch ?
Ist damit das ganze Projekt Quatsch ?
Sollte man niemals versuchen Python als A utodidakt zu erlernen?
Natürlich ist nicht jede Primzahl ein Zwilling, aber es sind immer 2 Primzahlen, aus denen
ein Zwilling besteht und genau diese wollte ich anzeigen.
Wenn die Funktion prim() immer noch falsche Werte liefert, sind dann alle hier gezeigten Primzahlen falsch ?
Ist damit das ganze Projekt Quatsch ?
Sollte man niemals versuchen Python als A utodidakt zu erlernen?
Ich sehe da oben eine ganze Reihe von falschen Primzahlen. Nicht alle, aber 15, 21, 25, 33, 39, 45 zb sind nicht prim. Wenn du die hier also als Primzahlen postest, möchtest du dann keinen Hinweis darauf, dass das falsch ist?
Natürlich kannst Du Python selbst lernen. Aber Du postest ja hier, um Rückmeldung zu bekommen, ob das so richtig ist. Ist es nicht, die Gründe hab ich Dir genannt. Lernen heißt ja nicht, sofort alles richtig zu machen, sondern Fehler erkennen und verbessern.
Statt 'Verbesserungen' also Bockmist.
Es tut mir leid und ich danke für Ihre Korrekturen.
Darf ich davon ausgehen und hoffe n, dass sich die Fehler auf die Programme mit
P-Zwillingen bezogen und nicht auf die 'einfachen ' Primzahlen ?
Jedenfalls herzlichen Dank für Eure Hinweise.
Es tut mir leid und ich danke für Ihre Korrekturen.
Darf ich davon ausgehen und hoffe n, dass sich die Fehler auf die Programme mit
P-Zwillingen bezogen und nicht auf die 'einfachen ' Primzahlen ?
Jedenfalls herzlichen Dank für Eure Hinweise.
Hi Oswald,
falls du diese Webseite noch nicht kennst, kann ich sie dir nur empfehlen: https://primes.utm.edu/
Dort findest du auch Links zu Webseiten, wo man sich Dateien mit -verifizierten- Primzahlen runter laden kann.
Mit diesen Daten kannst du dann einfach überprüfen, ob dein Code richtige Primes liefert oder nicht.
falls du diese Webseite noch nicht kennst, kann ich sie dir nur empfehlen: https://primes.utm.edu/
Dort findest du auch Links zu Webseiten, wo man sich Dateien mit -verifizierten- Primzahlen runter laden kann.
Mit diesen Daten kannst du dann einfach überprüfen, ob dein Code richtige Primes liefert oder nicht.
Ich bin Pazifist und greife niemanden an, auch nicht mit Worten.
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
Das war quatsch, ich weiss nicht, wieso ich das uebersehen habe, aber du testest ja mit den Divisoren bis sqrt(zahl), und damit passt das natuerlichAlso so wie ich das sehe ist nicht die Zwillingsberechnung das Problem. Sondern die Primzahlen selbst. Du prüfst im Grunde nur auf ungerade. Das ist notwendige, aber nicht hinreichende Bedingung für eine Primzahl.
@OSWALD: prim liefert fast immer richtige Ergebnisse. Nur prim(1) ist falsch. Die Prüfung auf Primzahlzwillinge war bei Dir in der ersten Version auch richtig, ich kann mir aber nicht erklären, was Du Dir bei `prim(i) == True or prim(i+1) == 'Z'` gedacht hast. Die einfachste Prüfung wäre `prim(i) and prim(i + 2)`.
@Sirius3: aber prim(1) liefert doch True, und 1 ist eine Primzahl.
Code: Alles auswählen
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = 1
oben = 50
for zahl in range(unten, oben+1):
print(zahl, prim(zahl))
Ich bin nur nach der simplen Definition gegangen. Aber du hast wohl recht. https://de.wikipedia.org/wiki/Primzahl - alles zu lange her.
### Programm zur Darstellung von Primzahlzwillingen in beliebigen Intervall###
### fertiggestellt am 21.04.2022 von OSWALD ##
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #
for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):
print(i ,"/",( i+2))
####################################################
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\YZwillingemit Z.py ==============
Anfangswert : 200
Maximalwert eingeben: 500
227 / 229
239 / 241
269 / 271
281 / 283
311 / 313
347 / 349
419 / 421
431 / 433
461 / 463
### fertiggestellt am 21.04.2022 von OSWALD ##
import math
def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: ")) # hier der Zusatz #
for i in range(unten,oben+1):
if prim(i) == True and prim(i) == prim(i+2):
print(i ,"/",( i+2))
####################################################
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
============== RESTART: C:\Python310\Beispiele\YZwillingemit Z.py ==============
Anfangswert : 200
Maximalwert eingeben: 500
227 / 229
239 / 241
269 / 271
281 / 283
311 / 313
347 / 349
419 / 421
431 / 433
461 / 463
21.02.2022
Prüfung der Zahl von " Primzahzwillingen im hohen Billionenbereich"
Nach einer Laufzeit von genau 30 min wurde abgebrochen.
Bitte nachprüfen, ob die Werte in Ordnung gehen.
Mit einem starken PC ( mit mehr als 4GB Haupt- Speicher dürften sicher noch größere Z-Werte in kürzeren Zeit
erreicht werden.
Ich wage anhand der Ergebnisse fast zu behaupten, dass die PriemzahlZwillinge sich gegen Unendlich stark auf NULL
bewegen könnte.
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
=========== RESTART: C:\Python310\Beispiele\ZwillingeV9vBis2020OK.py ===========
Anfangswert : 1000000000000100
Maximalwert eingeben: 10000000000001000
1000000000002371 / 1000000000002373
1000000000002767 / 1000000000002769
1000000000002797 / 1000000000002799
1000000000003001 / 1000000000003003
1000000000004249 / 1000000000004251
1000000000005077 / 1000000000005079
1000000000007147 / 1000000000007149
1000000000008629 / 1000000000008631
1000000000009139 / 1000000000009141
1000000000010717 / 1000000000010719
##################
OSWALD
Prüfung der Zahl von " Primzahzwillingen im hohen Billionenbereich"
Nach einer Laufzeit von genau 30 min wurde abgebrochen.
Bitte nachprüfen, ob die Werte in Ordnung gehen.
Mit einem starken PC ( mit mehr als 4GB Haupt- Speicher dürften sicher noch größere Z-Werte in kürzeren Zeit
erreicht werden.
Ich wage anhand der Ergebnisse fast zu behaupten, dass die PriemzahlZwillinge sich gegen Unendlich stark auf NULL
bewegen könnte.
Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
=========== RESTART: C:\Python310\Beispiele\ZwillingeV9vBis2020OK.py ===========
Anfangswert : 1000000000000100
Maximalwert eingeben: 10000000000001000
1000000000002371 / 1000000000002373
1000000000002767 / 1000000000002769
1000000000002797 / 1000000000002799
1000000000003001 / 1000000000003003
1000000000004249 / 1000000000004251
1000000000005077 / 1000000000005079
1000000000007147 / 1000000000007149
1000000000008629 / 1000000000008631
1000000000009139 / 1000000000009141
1000000000010717 / 1000000000010719
##################
OSWALD
Die Primzahlermittlung ist immer noch falsch. Alle Zahlen durchzuprobieren ist ziemlich langsam, da hilft auch nicht mehr Speicher.
Normalerweise benutzt man ein Sieb, das ziemlich schnell viele Primzahlen aussiebt.
Das geht aus Hauptspeichergründen im Billiardenbereich nicht mehr.
Deshalb nimmt man ein mehrstufiges Sieb. Erst nimmt man ein klassisches Sieb bis zur Wurzel der oberen Grenze des Zahlenbereichs, den man untersuchen will.
Das sind in Deinem Fall nur ein paar Millionen.
Dann siebt man mit diesen Primzahlen den gewünschten Bereich durch:
Normalerweise benutzt man ein Sieb, das ziemlich schnell viele Primzahlen aussiebt.
Das geht aus Hauptspeichergründen im Billiardenbereich nicht mehr.
Deshalb nimmt man ein mehrstufiges Sieb. Erst nimmt man ein klassisches Sieb bis zur Wurzel der oberen Grenze des Zahlenbereichs, den man untersuchen will.
Das sind in Deinem Fall nur ein paar Millionen.
Dann siebt man mit diesen Primzahlen den gewünschten Bereich durch:
Code: Alles auswählen
import array
def initialize_primes(max_value):
sieve = array.array('b', [1]) * (max_value // 2)
null = array.array('b', [0])
for i in range(int(max_value ** 0.5) // 2):
if sieve[i]:
j = i * 2 + 3
start = j * j // 2 - 1
sieve[start :: j] = null * len(range(start, len(sieve), j))
return [2] + [2 * i + 1 for i, v in enumerate(sieve, 1) if v]
def sieve(start, stop):
primes = initialize_primes(int(stop**0.5) + 1)
if start % 2 == 0:
start += 1
sieve = array.array('b', [1]) * ((stop - start) // 2)
null = array.array('b', [0])
for p in primes[1:]:
s = - (start % -p)
if s % 2 == 1:
s += p
s //= 2
sieve[s :: p] = null * len(range(s, len(sieve), p))
return [start + i * 2 for i, v in enumerate(sieve) if v]
def main():
start = 1000000000000000
stop = 1000000001000000
primes = sieve(start, stop)
last_prime = 0
for prime in primes:
if last_prime + 2 == prime:
print(last_prime, '/', prime)
last_prime = prime
if __name__ == "__main__":
main()