Primzahlen sind das Thema des Projecteuler-Problems Nummer 10. Nach dem 3. und 7. Problem befasst sich nun auch das 10. Problem mit den beliebten Zahlen, die durch beinahe nichts teilbar sind. In diesem Artikel wird, wie gewohnt, das Problem eingegrenzt und mit Python gelöst.

Problemvorstellung

Wer die Probleme 3 und 7 bereits gelöst hat, wird mit dem 10. Projecteuler-Problem keine Mühe haben. Wieder geht es um Primzahlen und wieder kann der Sieb des Eratosthenes verwendet werden, um die Lösung zu finden.

Ins Deutsche übersetzt lautet die Aufgabenstellung:

Finde die Summe aller Primzahlen, die kleiner als zwei Millionen sind.

Mit dem Hintergrundwissen aus den bereits gelösten Problemen, bräuchte ich eigentlich keinen zusätzlichen Artikel mehr zu verfassen. Es sind bereits alle Mittel, die hierzu benötigt werden, bereits vorgestellt und mit Erfolg verwendet worden.

Aus diesem Grund lässt es sich nicht wirklich nachvollziehen, warum zum heutigen Zeitpunkt lediglich 47699 der insgesamt 114874 Projecteuler-Teilnehmer eine richtige Lösung zu diesem Problem einreichen konnten. Wahrscheinlich sind sie zeitlich verhindert gewesen !

Problemeingrenzung

Obwohl alle Tipps und Tricks zur vollständigen und erfolgreichen Lösung des Problems bereits im Rahmen dieser Artikelserie genannt und beschrieben wurden, möchte ich einige Tatsachen dennoch der Vollständigkeit wegen wiederholen.

In erster Linie ist das wichtiges Werkzeug, welches bei bisher allen Problemen mit Primzahlen bei mir zum Einsatz kam und es auch diesmal tut das Siebes von Eratosthenes. Hierbei handelt es sich um eine Methode, mit welcher man alle Primzahlen bis zu einer gegebenen Zahl N relativ effizient finden kann.

Das Sieb des Eratosthenes

Die Vorgehensweise beim Sieben ist recht simpel und schnell erklärt, dabei geht man am besten grafisch vor: Um alle Zahlen bis N mit dem Sieb zu finden, schreibt man die Zahlen, bildlich gesprochen, alle auf. Dann fängt man mit der ersten bekannten Primzahl, also der 2, an und streicht alle Vielfachen dieser Zahl wieder aus der Liste. Hat man das erledigt, so geht es mit der nächsten nicht gestrichenen Zahl weiter, die nun eine Primzahl sein sollte.

Wenn nichts schief gegangen ist, so bleiben am Ende alle Primzahlen bis N übrig.

Um einige Rechenoperationen, Vergleiche und Abfragen zu sparen, kann die Methode etwas verfeinert werden. Zum einen ist es bekannt, dass es keine geraden Primzahlen gibt. Also können diese sofort aus der Betrachtung ausgeschlossen werden. Zum anderen ist während des Siebens ebenfalls bekannt, dass alle Vielfachen der Primzahl 5 bereits gestrichen sind, wenn die Primzahl 11 an der Reihe ist. Das gilt auch für alle Primzahlen zwischen 5 und 11. Somit kann die nächste zu streichende Vielfache frühstens 11*11 sein.

Aus der zuletzt angestellten Betrachtung folgt sogleich, dass die größte zu prüfende Primzahl maximal die Wurzel aus N sein kann.
x*x <= N

Werden die Verfeinerungen im Code angewendet, erhält man einen relativ effizienten Sieb, der mit den vorgegebenen zwei Millionen mühelos fertig werden sollte.

Problemlösung

Wie versprochen, brauchen wir zur Lösung des zehnten Projecteuler-Problem nur den Sieb des Eratosthenes und eine Summe aller gefundenen Primzahlen, das war es schon!
Im folgenden die kompakte Lösung:

import time as t
import numpy as np

def eratosthenes_vect(N):
    primes = np.arange(3,N+1,2)  # only uneven figures
    primes = np.insert(primes,0,2,0) # ... and two

    nUneven = np.size(primes) - 1.0

    for i in np.arange(3,np.ceil(np.sqrt(N))+2,2):
        primes[(i*i+1)/2-1:nUneven+1.0:i] = 0;

    return np.trim_zeros(np.sort(primes))

def solver(N):
    Primes = eratosthenes_vect(N)

    erg = 0;

    for i in Primes:
        erg = erg + i

    return erg

N = 2000000

t0 = t.clock()
Prim = solver(N)
tn = t.clock() - t0

print("Benoetigte Zeit: %15.6f" %tn)
print("Gefundene Summe: %i" %Prim)

Die Ausgabe des Codes zeigt die benötigt Zeit und die gesuchte Summe:
Benoetigte Zeit: 5.940000
Gefundene Summe: 142913828922


Sechs Sekunden Rechenzeit für alle Primzahlen, die kleiner als zwei Millionen sind, und die Summe daraus ist, denke ich, annehmbar.

Schlusswort

Nach einer etwas langwierigen Zeit, während der nur wenige Artikel in der Serie "Lösungen zu Projecteuler-Problemen mit Python" erschienen sind, gleich zwei Lösungen nach einander. Das ist schon ein Wort und sollte eigentlich mit einem dritten Artikel zum 11. Problem gefeiert werden. Vielleicht lasse ich mich dazu hinreißen !

Deine Stadt - Dein Preis
Mit CityDeal und vielen Anderen den Preis drücken!

© Muvik for muvik-multigrid, 2010. | Permalink | keine Kommentare | Teile es mit deinen Freunden: del.icio.us MisterWong Twitter
Tags: Eratosthenes, Primzahlen, Projecteuler, Python

Diese Woche geht es gleich weiter mit der Lösung des siebten Projecteuler-Problems mit Python. Die guten Vorsätze von letzter Woche scheinen noch nicht abgelegt zu sein, deswegen beschäftigen wir uns in diesem Artikel wieder etwas mit Primzahlen und dem Sieb des Eratosthenes. Natürlich wird das Problem mit der Programmiersprache Python angegangen und gelöst!

Problemvorstellung

Das siebte Projecteuler-Problem ist ein sehr kurzes Problem! Zumindest was die textliche Beschreibung angeht. Laut dem Motto “In der Kürze liegt die Würze” lautet die Aufgabenstellung folgendermaßen:

Finde die 10001.Primzahl!

Also kann mit drei Worten, einer Zahl und zwei Satzzeichen etwas formuliert werden, was jedes Grüblerherz höher schlagen lässt.

Diejenigen Leser, die meine Serie “Projecteuler: Lösungen mit Python und C++” bisher mitverfolgt haben, auch ohne aktives Eingreifen in Form von Kommentaren im Blog oder auch ohne die Probleme selber gelöst zu haben, werden wissen, dass es bereits eine Aufgabe gab, die Primzahlen zum Thema hatte.

Im Rahmen der Lösung zum dritten Problem, wo es um eine Primfaktorenzerlegung ging, finden wir wichtige Werkzeuge auch zur Lösung des siebten Problems. Doch dazu später mehr, zuvor etwas Statistik:

Ganz aktuell gemessen, haben von insgesamt 112279 registrierten Projecteuler-Nutzern genau 57841 das Problem mit Bravour gelöst. Das entspricht ziemlich genau der Hälfte der Nutzer. Und wir sind dabei !

Problemeingrenzung

Die Schwierigkeiten bei dieser Fragestellung liegen auf der Hand:

1. Zunächst ist es nett zu wissen, welche Zahlen denn nun überhaupt Primzahlen sind. Denn nur dann können sie auch gezählt werden. Also ist die erste Herausforderung das Filtern von Primzahlen.
2. Da nicht alle Primzahlen bis zu einer bestimmten ganzen Zahl gesucht sind, sondern eine bestimmte Anzahl an Primzahlen, sind die gängigsten Werkzeuge erst mal nicht zu gebrauchen, oder besser: sind zu überdenken. Es müssen weiterhin alle Primzahlen gesucht und gezählt werden, ein Limit ist jedoch nicht gegeben.

Wie eingangs bereits angedeutet, können wir uns aus der Lösung zu Problem 3 eines ganz nützlichen Werkzeugs bedienen: dem Sieb des Eratosthenes.

Mit diesem Sieb lassen sich alle Primzahlen bis zu einer gegebenen ganzen Zahl N bestimmen. Wie im verlinkten Wikipedia-Artikel erläutert, müssen hierbei einfach alle Zahlen bis N “aufgeschrieben” werden. Dann werden mit der 2 beginnend alle Vielfachen wieder gestrichen. Hat man das für die 2 erledigt, so geht es in der Reihenfolge mit der nächsthöheren Zahl weiter, also der 3, dann 5, 7, 11, …

Das Sieb des Eratosthenes liefert uns also alle Primzahlen, die kleiner oder gleich N sind. Gesucht ist jedoch die 10001.Primzahl. Somit kommen wir mit dem Sieb des Eratosthenes nicht direkt zum Ziel.

Sollen nun im Zahlenbereich bis N noch keine 10001 Primzahlen identifiziert sein, so muss der Bereich erweitert und die Suche fortgesetzt werden. Wie das realisiert werden kann, steht unter der Überschrift:

Problemlösung

Der erste Teil der Lösung ist klar und bereits aus der Lösung zum Problem 3 bekannt:

def eratosthenes_vect(N):
    primes = np.arange(3,N+1,2)  # only uneven figures
    primes = np.insert(primes,0,2,0) # ... and two

    nUneven = np.size(primes) - 1.0

    for i in np.arange(3,np.ceil(np.sqrt(N))+2,2):
        primes[(i*i+1)/2-1:nUneven+1.0:i] = 0;

    return np.trim_zeros(np.sort(primes))

Damit erhalten wir alle Primzahlen bis zur Zahl N.

Die einfachste Lösung wäre nun, einfach einen großes N vorzugeben und zu hoffen, dass es mindestens 10001 Primzahlen im Sieb hängen bleiben. Ist man in der Lage, ein gut passendes N abzuschätzen, so hat man mit dem Sieb des Eratosthenes eine sehr effiziente Lösungsmethode gefunden.

Diese Tatsache möchten wir im Folgenden ausnutzen und durch eine Erweiterung etwas absichern:

def eratosthenes_limits(StartN, EndN, Primes):
    """
    Rechnet alle Primzahlen im Zahlenraum StartN, EndN.
    Primes: alle Primzahlen bis StartN.
    """
    if (StartN%2 == 0):
        SearchField = np.arange(StartN+1,EndN+1,2)
        limitleft = StartN+1
        limitright = EndN
    else:
        SearchField = np.arange(StartN,EndN+1,2)
        limitleft = StartN
        limitright = EndN

    for item in Primes:
        itemQ = item*item
        if itemQ <= limitright:
            for i in range(0,SearchField.size,1):
                if (SearchField[i]%item == 0):
                    SearchField[i] = 0

            SearchField = np.trim_zeros(np.sort(SearchField))
            limitleft   = SearchField[0]
            limitright  = SearchField[-1]

    return np.append(Primes,SearchField)

def solver(N,NEra):
    Primes = eratosthenes_vect(NEra)

    while (Primes.size < N):
        Primes = eratosthenes_limits(NEra+1, NEra*2, Primes)
        NEra = NEra*2

    print("Suchbereich bis N=%i" %NEra)
    return Primes[N-1]

Der gegebene Vorschlag ist wahrscheinlich nicht die eleganteste Methode, aber er funktioniert für das Problem recht ordentlich.

Die Funktion eratosthenes_limits kommt zum Einsatz, wenn der Zahlenbereich, den wir geschätzt haben, zu klein ist. Sie geht im Grunde genau nach dem Prinzip des Siebes von Eratosthenes vor. Es werden alle Zahlen in einem Bereich zwischen StartN und EndN auf Teilbarkeit durch die Primzahlen bis zur Zahl StartN untersucht. Da wir davon ausgehen, dass der zu Beginn geschätzte Zahlenbereich nicht sehr stark vergrößert werden muss, steigern wir in der solver-Funktion den Suchbereich um das doppelte, wenn nicht genug Primzahlen gefunden wurden.
Auf diese Weise kann es nicht vorkommen, dass die Funktion eratosthenes_limits ins Stocken gerät, weil Primzahlen aus dem aktuellen neuen Suchbereich benötigt werden, um alle Vielfachen zu streichen. Dafür müsste der Suchbereich schon quadratisch vergrößert werden: StartN = N, EndN=N*N.

Schätzen des Suchbereichs zu Beginn

Das Schätzen des richtigen Suchbereichs ist das A und O bei der vorgeschlagenen Lösung. Dazu lohnt sich ein Blick auf die Statistik. Betrachtet man bereits die Häufigkeit von Primzahlen im Bereich von 1-10 und von 20-30, so stellt man fest, dass die Anzahl abnimmt. Diese Tatsache lässt sich mathematisch beweisen, was wir hier aber nicht machen wollen.

In dem Zahlenbereich, der für das siebte Projecteuler-Problem interessant ist, treten laut der Analyse auf maerku69.ch Primzahlen mit einer Häufigkeit von etwas unter 10% auf.

Daraus schließen wir, dass eine Schätzung des Suchbereichs mit etwas mehr als dem zehnfachen von 10001 ganz ordentlich sein sollte.

Lösungsanalyse

Genug der trockenen Theorie, nun kommt die Analyse:

import time as t
import numpy as np

def eratosthenes_vect(N):
    ...

def eratosthenes_limits(StartN, EndN, Primes):
    ...

def solver(N,NEra):
    ...

N = 10001

N1 = 11*N

t0 = t.clock()
Prim = solver(N,N1)
tn = t.clock() - t0

print("Benoetigte Zeit: %15.6f" %tn)
print("Gefundene Primzahl: %i" %Prim)

Mit einem derart optimierten Suchbereich (11*10001) ist eine Erweiterung nicht nötig, die Lösung wird allein durch das Sieb des Eratosthenes gefunden (Ausgabe):
Suchbereich bis N=110011
Benoetigte Zeit: 0.320000
Gefundene Primzahl: 104743

Unterschätzt man den Suchbereich etwas (10*10001), dann dauert die Suche schon etwas länger:
Suchbereich bis N=200020
Benoetigte Zeit: 2.810000
Gefundene Primzahl: 104743

Hierbei wurde der Suchbereich ein mal vergrößert.

Wird dagegen der Suchbereich überschätzt (12*10001), dann dauert die Suche nur unwesentlich länger:
Suchbereich bis N=120012
Benoetigte Zeit: 0.350000
Gefundene Primzahl: 104743


Schlusswort

Primzahlen sind immer wieder gut für Knobel-Spielchen geeignet, so auch diesmal.

Das Lösen des siebte Problem hat mir persönlich viel Spass bereitet. Ich hoffe, dass es meinen Lesern nicht anders ging oder noch gehen wird und freue mich auf andere Lösungsvorschläge in den Kommentaren oder vielleicht als Reaktion im eigenen Blog.

Meinungen, Anregungen, Verbesserungen sind immer willkommen.

Deine Stadt - Dein Preis
Mit CityDeal und vielen Anderen den Preis drücken!

© Muvik for muvik-multigrid, 2010. | Permalink | keine Kommentare | Teile es mit deinen Freunden: del.icio.us MisterWong Twitter
Tags: Eratosthenes, Primzahlen, Projecteuler, Python

In langsamen Schritten mehren sich die Lösungsvorschläge zu den projecteuler.net Problemen in dieser Serie. Nun sind es fünf an der Zahl. Zur Feier des Tages werden heute eine ganz simple, handschriftliche Lösung vorgestellt und die dazu äquivalente Implementierung in Python gezeigt.

Problemvorstellung

Die Probleme von projecteuler.net sind aufgrund des meist recht hohen Rechenaufwands nicht nur durch Überlegen mit Bleistift und Papier zu lösen. Zumindest nicht in einem vertretbaren zeitlichen Rahmen. Ebenso häufig, wie die Probleme nicht ohne weiteres mit Bleistift und Papier lösbar sind, helfen diese Mittel das Problem besser zu verstehen und eine elegante Lösung zu erarbeiten.

Wie bereits bei der Lösung des vierten Problems, lassen sich auch hier einige Gedanken machen, die schnell zur Lösung führen. Diesmal geht es sogar soweit, dass eine rein schriftliche Lösung ohne großen Aufwand eingereicht werden kann.

Obwohl das Problem an sich keine Herausforderung mehr darstellt, wenn die Probleme 1 bis 4 gelöst sind, habe von derzeit 1802789 Projecteuler-Mitgliedern nur 64072 es auch gelöst.

Doch worum handelt das Problem, welches spätestens auf den zweiten Blick einfach erscheint?

Finde die kleinste Zahl, welche durch alle Zahlen von 1 bis 20 gerade teilbar ist!

Als Beispiel zu dieser Fragestellung haben die Macher hinter Projecteuler.net das gleiche Problem mit den Zahlen von 1 bis 10 gelöst. Hiernach ergibt sich als Lösung: 2520.

Problemeingrenzung

Spätestens seit der Lösung des dritten Projecteuler-Problems wissen wir, dass alle Zahlen eine eindeutige Primfaktorenzerlegung besitzen. Ebenfalls aus dem dritten Problem ist bekannt, wie wir eine Primfaktorenzerlegung durchführen können, dieses Wissen hilft uns an dieser Stelle weiter.

Wie können wir das bereits erworbene Wissen auf dieses Problem übertragen?

Gesucht ist eine Zahl, die durch alle Zahlen von 1 bis 20 ohne Rest teilbar ist. Gleichwertig kann auch eine Zahl gefunden werden, welche durch alle Primfaktoren der Zahlen 1 bis 20 ohne Rest teilbar ist. Also suchen wir erst einmal eine Menge an Primzahlen, welche die Zahlen 1 bis 20 abbilden kann. Dabei ist es nicht wichtig, dass alle 21 Zahlen gleichzeitig aus der Menge heraus gebildet werden können.

In Kürze ergibt sich aus den Überlegungen und dem bereits vorhandenen Wissen folgendes Vorgehen:

1. Suchen aller Primzahlen bis 20 entweder im Kopf oder mit dem Sieb des Eratosthenes.
2. Suchen der Primfaktorenzerlegung aller Zahlen von 1 bis 20 und zusammenfassen aller Primfaktoren mit ihren Häufigkeiten in einer Menge.
3. Reduzieren der Häufigkeiten, damit jede Zahl mindestens ein Mal aus den Primfaktoren gebildet werden kann.

Also beschränkt sich die Herausforderung der Aufgabe lediglich auf eine Primfaktorenzerlegung und etwas Abzählen der Häufigkeiten. Gehen wir es an!

Problemlösung

Wie bereits in der Einleitung angedroht, versuche ich mich zum ersten Mal in dieser Serie mit einer einfachen, handschriftlichen Rechnung. Dazu gehe ich zielführenden nach den Punkten 1-3 aus dem vorangegangenen Abschnitt vor:

1. Die Primzahlen bis 20 inkl. der 1:1 2 3 5 7 11 13 17 19
2. Primfaktoren aller Zahlen außer der Primzahlen von 1 bis 20:
   4: 2 2
6: 2 3
8: 2 2 2
9: 3 3
10: 2 5
12: 2 2 3
14: 2 7
15: 3 5
16: 2 2 2 2
18: 2 3 3
20: 2 2 2 5
   Daraus ergibt sich die folgende Gesamtverteilung:
   
   

   Häufigkeitsverteilung der Primfaktoren

   
   Zur Lösung des Problems ist eine solche Darstellung nicht nötig. Um jedoch zu verdeutlichen, wie viel kleiner die gesuchte Zahl ist, wenn alle Faktoren, die zu viel sind, gestrichen werden, eignet sie sich hervorragend.
3. Jetzt bleibt nur noch die einzelnen Primfaktorzerlegungen durch zu gehen und die Häufigkeiten der Primfaktoren zu zählen. Daraus ergibt sich folgende Verteilung:
   
   

   reduzierte Häufigkeitsverteilung

   
   Das war es schon! Das Multiplizieren aller verbleibenden Faktoren führt zu der gesuchten Zahl:
   1*2*2*2*2*3*3*5*7*11*13*17*19 = 232792560

Alternative Lösung

Als alternative Lösung verkaufe ich heute einfach die Python-Implementierung des zuvor beschriebenen handschriftlichen Lösungswegs:

import numpy as np

def eratosthenes(N):
    """liefert alle Primzahlen bis N"""
    primes = np.arange(1,N+1,1)

    for i in np.arange(2,np.ceil(np.sqrt(N))+1,1):
        primes[i*i-1:N:i] = 0;

    return primes

def prime_fact_counter(N,testPrimes):
    nPrimes = np.size(testPrimes)
    countPrimes = np.zeros_like(testPrimes)

    for i in range(1,nPrimes,1):
        actPrime = testPrimes[i]
        while ((N%actPrime == 0) & (N >= actPrime)):
            N = N / actPrime;
            countPrimes[i] = countPrimes[i] + 1
        countPrimes[0] = 1
    return countPrimes

def solver(N):
    searchProduct = 1.0
    testPrimes = np.trim_zeros(np.sort(eratosthenes(N)))

    freq = np.zeros_like(testPrimes) # array of prime occurance for each factor 1..20
    totFreq = np.zeros_like(testPrimes) # array of total prime occurance

    print(testPrimes)

    for i in range(1,N+1,1):
        freq = prime_fact_counter(i,testPrimes)
        for j in range(0,freq.size,1):
            if (freq[j] > totFreq[j]):
                totFreq[j] = freq[j]

    print(totFreq)

    for j in range(0,totFreq.size,1):
        searchProduct = searchProduct * (testPrimes[j])**(totFreq[j])

    return searchProduct

N = 20

print(solver(N))

Insgesamt habe ich drei Funktionen definiert. Die erste Funktion ist der bereits bekannte Sieb des Eratosthenes. Sie berechnet alle Primzahlen bis zu einer Zahl N, oder anders ausgedrückt, alle in der Primfaktorenzerlegung vorkommenden Primzahlen der Zahl N.

Die zweite Funktion zählt die Anzahl der Primfaktoren einer bestimmten Zahl N. Das ist wichtig, um die maximale Häufigkeit eines Faktors in einer Zahl festzustellen. Zum Beispiel enthält die 16 genau vier mal die 2 als Faktor: 2*2*2*2 = 16

Die solver-Funktion durchläuft alle Zahlen von 1 bis 20, berechnet die Primfaktorenzerlegung und überprüft die Häufigkeiten. Am Ende wird aus der reduzierten Häufigkeitsverteilung die gesuchte Zahl errechnet.

Damit wäre das fünfte Problem von Projecteuler gelöst!

Schlusswort

Aufgrund des niedrigen Schwierigkeitsgrades des fünften Problems konnte zum ersten Mal in dieser Serie eine rein handschriftliche Lösung präsentiert werden. Alternativ dazu wurde auch eine Python-Implementierung aufgeführt, welche auch für Zahlen größer als N=20 geeignet ist.

In der Hoffnung, dass die simple Idee, die hinter dem Lösungsvorschlag steckt, klar geworden ist, freue ich mich wie immer auf Kommentare und Verbesserungsvorschläge.

Deine Stadt - Dein Preis
Mit CityDeal und vielen Anderen den Preis drücken!

© Muvik for muvik-multigrid, 2010. | Permalink | keine Kommentare | Teile es mit deinen Freunden: del.icio.us MisterWong Twitter
Tags: Primzahlen, Projecteuler, Python

Nach einer etwas längeren Pause geht es heute mit der Projecteuler-Serie weiter. In diesem Artikel stelle ich meine Lösung des dritten Problems dar. Wie bereits bei den vorangehenden Teilen gibt es auch hier wieder alternative Ansätze.

Problemvorstellung

Das dritte Problem von Projecteuler.net dreht sich allgemein gesprochen um die Primfaktorzerlegung. Aus grauer Schulzeit wissen wir, dass jede natürliche Zahl in Primfaktoren zerlegt werden kann. Des Weiteren haben Primzahlen die berüchtigte Eigenschaft nur durch sich selber und durch die Eins teilbar zu sein. Danach hat jede natürliche Zahl mindestens zwei Faktoren, wobei die Eins als trivialer Faktor beinahe vernachlässigt werden kann. Nicht-Primzahlen, also die zusammengesetzten Zahlen, können folglich in ihre kleinsten Bestandteile, die Primzahlen getrennt werden.

Ich muss zugeben, dass es nun wirklich keine wissenschaftliche Erklärung und kein Beweis für die Existenz einer exakten Primfaktorzerlegung ist, was ich aufgeführt habe. Den Zweck einer netten Einführung erfüllt es jedoch und ich bin glücklich . Sollte jemand weiterführende Informationen benötigen, so möge Er oder Sie sich im Web umschauen oder einen Hinweis in den Kommentaren hinterlassen, dann lässt sich sicher noch etwas machen.

Also wir wissen nun, wohin das dritte Problem führen wird, doch wie lautet die Aufgabenstellung genauer? Die Auflösung:

Finde den größten Primfaktor der Zahl 600851475143.

Ja, das war es schon! Hört sich doch ganz machbar an, oder? Das haben sich 56838 der derzeit 100370 Hobbymathematiker auch gedacht und die Aufgabe erfolgreich gelöst. Im Vergleich zum ersten und zweiten Problem entspricht dies schon deutlich weniger eingereichten Lösungen. Bisher sind es grob abgeschätzt etwa 50% aller Projecteuler.net Aktivisten. Schlussendlich kann diese Entwicklung auf einen steigenden Schwierigkeitsgrad oder einen sinkenden Motivationsgrad hindeuten, also ein typisches Glas-halb-leer bzw. Glas-halb-voll Problem, welches auf in einem anderen Artikel gelöst wird .

Problemeingrenzung

Kommen wir nun zum Kern der Geschichte: Das erste Durchlesen dieses Problems hinterließ bei mir zwei Gedanken. Der erste Gedanke war, wie finde ich raus, ob eine Zahl nun eine Primzahl ist oder nicht und der zweite Gedanke beschäftigte sich mit dem Prüfen des größten Teilers.

Das erste Teilproblem gehe ich im folgenden mit dem Sieb des Erathosthenes (Wikipedia) an.

Das zweite Teilproblem wird ganz simpel gelöst, indem die gegebene Zahl auf Teilbarkeit durch die gefundenen Primzahlen untersucht wird.

Problemlösung

Das Sieb des Erathostenes ist eine recht einfache Methode alle Primzahlen bis zu einer bestimmten Zahl N zu finden. Wie im verlinkten Wiki-Artikel schön dargestellt ist, schreibt man alle Zahlen bis einschließlich N auf und beginnt das Sieben. Dazu fängt man mit der kleinsten bekannten Primzahl, also der zwei, an und streicht alle Vielfachen dieser Zahl, dann macht man dasselbe mit der nächsten nicht gestrichenen Zahl nach der Zwei weiter. Auf diese Weise bleiben am Ende alle Primzahlen bis N übrig.

Der langen Rede kurzer Sinn ist in Python-Code im Folgenden dargestellt.

import time as t
import numpy as np
from math import ceil, sqrt

def eratosthenes_direct(N):
    """
    Berechnet alle Primzahlen bis N mit dem Sieb des Eratosthenes
    """
    primes = np.arange(3,N+1,2)  # only uneven figures
    primes = np.insert(primes,0,2,0) # ... and two

    testFigs = np.arange(3,np.ceil(np.sqrt(N))+2,2)

    for i in testFigs:
        if (primes[((i+1)/2-1)] != 0):
            noPrime = i*i
            while noPrime <= N:
                primes[((noPrime+1)/2-1)] = 0
                noPrime = noPrime + 2 * i

    return np.trim_zeros(np.sort(primes))

def eratosthenes_vect(N):
    primes = np.arange(3,N+1,2)  # only uneven figures
    primes = np.insert(primes,0,2,0) # ... and two

    nUneven = np.size(primes) - 1.0

    for i in np.arange(3,np.ceil(np.sqrt(N))+2,2):
        primes[(i*i+1)/2-1:nUneven+1.0:i] = 0;

    return np.trim_zeros(np.sort(primes))

In dem Code-Abschnitt habe ich gleich zwei alternative Beispiele für den Sieb des Eratosthenes aufgeführt. Beide Funktionen gehen nach dem gleichen Prinzip vor; der kleine Unterschied ist beim Streichen der Vielfachen zu finden.

Da von vornherein klar ist, dass keine gerade Zahl außer der Zwei Primzahl sein kann, werden nur die ungeraden Zahlen bis N im Vektor primes gespeichert. Bevor ich den Code getippt habe, führte ich das Sieben auf dem Papier aus und bin dann darauf gekommen, dass die größte, auf Vielfache zu prüfende Primzahl die Wurzel von N sein muss. Alle Zahlen die größer als die Wurzel von N sind, müssen demnach Primzahlen sein oder werden beim Sieben gestrichen.

Die an zweiter Stelle aufgeführte Funktion nutzt die Möglichkeiten von Numpy aus, indem keine while-Schleife verwendet wird, sondern das Streichen über eine Indexauswahl des Vektors stattfindet.

Zuletzt werden mit den Numpy-Funktionen sort und trim_zeros die Primzahlen von den Nullen getrennt.

So weit so gut! Nun liefert uns das Sieb einen Vektor an Primzahlen bis zu einer bestimmten Zahl N. Um die Projecteuler-Aufgabe zu lösen, muss noch der größte Primfaktor gefunden werden:

def solver(N,primes):
    rebuild = 1.0
    prob    = N
    for i in primes:
        while (N%i == 0):
            N = N/i
            found = i
            rebuild = rebuild * found

            if (rebuild/prob > 0.9):
                print(rebuild)
                return found

    return 0.0

Der Solver durchläuft alle Primzahlen, prüft Sie auf Teilbarkeit und, wenn die Zahl ein Teiler ist, so wird sie als ein Lösungskandidat gespeichert. Die while-Schleife soll doppelte Primzahlen ebenfalls erfassen.

Der Solver wurde von mir nicht weiter validiert und könnte durchaus noch das eine oder andere Problem bereiten, aber für die von mir getesteten Zahlen hat alles funktioniert.

Lösungsanalyse

Kommen wir nun zur Anwendung des Siebs und des Solvers.

Zunächst muss eine Grenze für das Sieb festgelegt werden. Da ich den Solver so geschrieben habe, dass er mir nur einen Lösungskandidaten ausgibt, wenn die Zahl von Projecteuler rekonstruiert werden konnte, habe ich als Grenze zunächst 1000 ausprobiert. Das war zu wenig und ich erhöhte die Grenze auf 10000, was eine Lösung ausspuckte.

Der Aufruf:

N  = 10000
Pe = 600851475143
#
t0 = t.clock()
primes = eratosthenes_direct(N)
prim = solver(Pe,primes)
tn = t.clock()

print("Zeit fuer Primzahlensieb: %.15f" %(tn-t0))
print("Primzahl: ")
print(prim)

t0 = t.clock()
primes2 = eratosthenes_vect(N)
prim2 = solver(Pe,primes2)
tn = t.clock()

print("Zeit fuer Primzahlensieb: %.15f" %(tn-t0))
print("Primzahl: ")
print(prim2)

Und die Ausgabe:

600851475143.0
Zeit fuer Primzahlensieb: 0.080000000000000
Primzahl:
6857
600851475143.0
Zeit fuer Primzahlensieb: 0.030000000000000
Primzahlen:
6857

Abgesehen davon, dass das Ergebnis die richtige Lösung für das dritte Projecteuler-Problem ist, kann festgestellt werden, dass der Sieb ohne die while-Schleife um mehr als das doppelte schneller ist. Das war zu erwarten, denn die Numpy-Funktionen werden sicherlich nicht von Anfängern, wie ich einer bin, geschrieben.

Fazit

Damit wäre das dritte Problem gelöst. Auch diesmal gibt es eine kleine Neuerung im Blog: mit dem Sieb des Eratosthenes wurde der erste Algorithmus vorgestellt. Ich denke, dass ich in nächster Zeit wieder etwas mehr Zeit für den Blog haben werde und daher öfter etwas schreiben kann.

Jetzt sind aber erstmal die Leser wieder an der Reihe mit Verbesserungsvorschlägen und weiteren Lösungsansätzen. Ich freue mich darauf.

Deine Stadt - Dein Preis
Mit CityDeal und vielen Anderen den Preis drücken!

© Muvik for muvik-multigrid, 2010. | Permalink | 2 Kommentare | Teile es mit deinen Freunden: del.icio.us MisterWong Twitter
Tags: Primzahlen, Projecteuler, Python