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

Jetzt geht es beinahe schon Schlag auf Schlag: nach der Vorstellung der Lösung des achten folgt sofort die Lösung des neunten Problems. Das neunte Projecteuler-Problem beschäftigt sich mit dem Satz von Pythagoras und der Bildung von sogenannten Pythagoras-Tripeln. Wie gewohnt, erfolgt auch diesmal die Lösung mit Python.

Problemvorstellung

Das neunte Projecteuler-Problem dreht sich um den Satz von Pythagoras, welcher eine Aussage über die Seitenlängen eines rechtwinkligen Dreiecks liefert. Wie die meisten Schüler mehr oder weniger leidvoll erfahren haben, ergibt sich aus der Addition der Quadrate der zwei kürzeren Seiten, der Katheten, eines rechtwinkligen Dreiecks genau das Quadrat der längsten Seite, der Hypotenuse. Dass der Satz des Pythagoras auch heute noch bei Schülern sehr gefragt ist, lässt sich auf gutefrage.net nachlesen.

Ist nun die Länge der zwei Katheten und der Hypotenuse eines Dreiecks durch natürliche Zahlen (ganze Zahlen) beschreibbar, so bezeichnet man die drei Zahlen als pythagoreisches Tripel.

In dem neunten Projecteuler-Problem geht es darum, ein bestimmtes pythagoreisches Tripel zu finden. Dieses Tripel soll folgende Bedingungen erfüllen:

1. a + b + c = 1000,
2. a < b < c und natürlich
3. a^2 + b^2 = c^2

So viel sei zur Aufgabenstellung angemerkt.

Obwohl der Satz des Pythagoras eine elementare Unterrichtseinheit in der Schule darstellt, haben zum heutigen Zeitpunkt trotzdem nur 52711 der insgesamt 114860 Projecteuler-Teilnehmer die Aufgabe mit Erfolg gelöst und das richtige Ergebnis eingegeben.

Als Ergebnis werden übrigens nicht die drei Zahlen a, b, c erwartet, sondern ihr Produkt: a * b * c.

Problemeingrenzung

Geht man ganz unbedarft an das Problem heran, kommt man schnell auf die Lösung, einfach alle Zahlen für a und b einzusetzen, die die Bedingung a < b erfüllen. Dann muss die Hypotenuse errechnet werden. Was noch bleibt, ist zu testen, ob die Summe der drei Zahlen auch wirklich 1000 ergibt.

Damit hätte man zwei for-Schleifen und eine if-Abfrage und natürlich die Lösung des Problems. Eine elegante Lösung ist jedoch etwas anderes!

Ebenso unbedarft kann das Problem nur ein wenig genauer angeschaut werden. Ein Quäntchen Glück vorausgesetzt, erkennt man dabei, dass man bei drei Unbekannten genau zwei Gleichungen gegeben hat. Dies kann ausgenutzt werden, um die Lösung etwas komplizierter erscheinen zu lassen.

Dabei lässt sich zum Beispiel die erste Bedingung a + b + c = 1000 nach c auflösen und in die dritte einsetzen:
a + b + c = N
c = N - a - b
a^2 + b^2 - N^2 - 2*N*(a+b) - (a+b)^2 = 0

Die letzte Gleichung kann nun nach zum Beispiel b aufgelöst werden:
b = (0.5*N^2 - N*a)/(N - a)

Das Auflösen nach b lässt sich über die zweite Bedingung motivieren. Wenn wir nun Zahlen von 1 ausgehend für a einsetzen, dann wird die zweite Bedingung immer erfüllt bleiben.

Damit müssen wir nur noch die Zahlen für a vorgeben und testen, ob der Quotient eine natürliche Zahl ergibt.

Weiter wollen wir das Problem nicht mehr mit mathematischem Hintergrund aufblasen und gehen zur Lösung mit Python über.

Problemlösung

Abgesehen davon, dass dieses Problem eigentlich keiner Implementierung in einer Programmiersprache bedarf, wenn die Informationen zur Erzeugung eines pythagoreischen Tripels ausgenutzt werden, ist es wohl eines der kürzesten Lösungen, die ich im Rahmen dieser Serie bisher vorgestellt habe.

def search(a,N):
    found = 0

    while (found == False):
        for i in a:
            num = 0.5*N*N - N * i
            denom = N - i
            if (num%denom == 0.0):
                found = 1
                result = np.array([i,num/denom])
    return result

N = 1000.0

aa = np.arange(int(N)/3)

erg = search(aa,N)

a = erg[0]
b = erg[1]
c = N-a-b

print(a,b,c,a*b*c)

Innerhalb dieser Zeilen habe ich die wenigen Gedanken aus der Problemeingrenzung verarbeitet. Der aufmerksame Leser wird gemerkt haben, dass noch eine zusätzliche Vereinfachung im Code berücksichtigt wurde.

Aufgrund der gegebenen Bedingungen wurde für a ein etwas kleinerer Suchbereich von maximal bis 300 eingestellt. Gehen wir von einem Extremfall aus:
a = 300
b = 301
a^2 + b^2 = c^2 = 180601
=> c = 424.972


Prüfen wir die erste Bedingung, so finden wir, dass die Summe bereits ca. 1026 beträgt. Das ist schon zu viel.

Lässt man sich nun das Ergebnis berechnen, so erhält man folgende Ausgabe:
(200.0, 375.0, 425.0, 31875000.0)

Damit wäre die gesuchte Zahl: 31875000.

Schlusswort

Ich gebe zu, dass der Lösungsvorschlag nicht der Weisheit letzter Schluss ist, doch für dieses Problem funktioniert er gut und zuverlässig. Die Grenzen, die Projecteuler vorgibt, werden nicht annähernd erreicht.

Natürlich wäre ich daher besonders froh, den einen oder anderen Lösungsvorschlag in den Kommentaren zu sehen .

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: Projecteuler, Pythagoras, Python

Und weiter geht es in der Lösungen zu Projecteuler Problemen mit Python Serie. Heute steht das achte Problem auf dem Plan. Dieses etwas andere Problem als die bisherigen wird, wie gewohnt, erläutert, die Herausforderung hierbei werden eingegrenzt und die Lösung mit Python nach bestem Wissen und Gewissen herausgefunden.

Problemvorstellung

Die Aufgabenstellung des achten Problems ist, wie bereits beim siebten, sehr kurz geraten. Und trotzdem bekommt der unvorbereitete Besucher der Projekteuler-Seite etwas das Grausen, wenn er die Aufgabenstellung sieht. Neben der textlichen Anweisung, was zu tun ist, wird nämlich das Untersuchungsobjekt gleich mitgeliefert.

Aber nur der Reihe nach: zuerst die Aufgabenstellung ins Deutsche übersetzten:

Finde das größte Produkt von fünf aufeinander folgenden Ziffern innerhalb einer Zahl mit 1000-Stellen.

Nach der Problembeschreibung folgt das Untersuchungsobjekt:
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Zum heutigen Zeitpunkt haben sich genau 52538 mutige Projecteuler-Teilnehmer an die Aufgabe mit erfolgreichem Ausgang getraut. Das entspricht grob der Hälfte der insgesamt 115013 registrierten Leidensgenossen.

Problemeingrenzung

Unbeeindruckt von der Wucht großer Zahlen machen wir uns an die Problemanalyse und -eingrenzung heran.

Die erste Idee, welche sich beinahe sofort in die Gedanken einmischt, ist die straight-forward-Methode: Man nehme die ersten fünf Ziffern, multipliziere sie und vergleiche sie mit dem Produkt der Ziffern 2-6. So läuft man durch das ganze Feld, bis man am Ende angekommen ist. Das ist eine sehr simple Methode, die todsicher zum richtigen Ergebnis führt.

Doch so einfach möchten wir uns das ganze bloß nicht machen. Nach dem Motto “Warum einfach, wenn es auch kompliziert geht?” überdenken wir die offensichtlichen Nachteile der simplen, ersten Idee:

1. In erster Linie wäre die Aufgabe so viel zu einfach. Der Reiz des Unmöglichen geht verloren!
2. In zweiter Linie sind wir sparsame Menschen und sehen sofort, dass bei der trivialen Lösung sehr oft multipliziert wird. Genauer betrachtet, stellen wir fest, dass in einer Reihe wie (2 3 4 5 0 5 5 2 3) genau 20 mal eine Multiplikation durchgeführt wird, ohne dass ein Produkt größer als 0 herauskommt.

Ok, das sind uns Nachteile genug, um die Lösung nochmal zu überdenken.

Schauen wir uns einen Ausschnitt aus der ersten Ziffernreihe an und veranschaulichen uns, wie die Produkte gebildet werden:

624919225119674426574742355349194934
62491
_24919
__49192
___91922
...

Was erkennen wir daraus?

1. Zuerst muss ein reguläres Produkt aus fünf Ziffern gebildet werden.
2. Das nachfolgende Produkt besteht zu einem Großteil aus den Ziffern seines Vorgängers. Lediglich die erste Ziffer entfällt und eine neue kommt hinzu.

Diese Erkenntnisse können wir uns nun zu Nutze machen, indem wir vom Vorgänger stets die erste Zahl dividieren und die nächste multiplizieren! Dadurch haben wir die Anzahl an Rechenoperationen halbiert.

Da der neue Vorschlag nun neben der Multiplikation auch eine Division aufweist, müssen wir zusätzliche Vorsicht walten lassen, denn durch Null teilen ist verboten.

Nach dem Motto “Vorbeugen ist besser als Bekämpfen” sieht jeder ein, dass das Problem mit der Division durch Null nicht auftreten kann, wenn keine Vorgänger null sind, also kein Quintett eine Null enthält. Das realisieren wir folgendermaßen:

1. Solange keine Null auftritt, die zur Bildung eines neuen Produkts nötig wäre, kann der bisher beschriebene Algorithmus durchgeführt werden.
2. Sobald eine Null auftritt, wird die Bildung des Quintetts abgebrochen. Danach wird versucht, ein neues Quintett aus den fünf Ziffern nach der Null zu bilden. Sollte hierbei wieder eine Null vorkommen, so wird der Vorgang wieder abgebrochen und ein neues Quintett mit den Ziffern nach dieser zweiten Null gebildet.

Was haben wir damit erreicht? In erster Linie teilen wir nie wieder durch Null und in zweiter Linie werden kein Quintett mit einer Null gebildet und somit diese unnötigen Multiplikationen eingespart.

Damit sind wir erst einmal zufrieden. Wie das in Python-Code aussieht, steht im folgenden Abschnitt.

Problemlösung

Neben den rein mathematischen Schwierigkeiten bei dem 8.Problem, treffen wir noch auf ein rein programmiertechnisches Problem, nämlich dem Import der gegebenen Zahl. Ich habe mich dafür entschieden, die Zahl von der Projecteuler-Webseite in eine einzelne Datei (data.dat) zu kopieren und im Python-Programm nur die Datei zu importieren. Dabei bietet es sich an, die Zeilenumbrüche zu ignorieren und die ganze Zahl in einem eindimensionalen Numpy-Array zu speichern.

Der langen Rede kurzer Sinn, heute mal am Stück:

import numpy as np
import time as t

fileO =  open('data.dat','r')
peData = fileO.read()

def create_long_array(data):
    fdata = np.array([])

    print("Following data will be red:")
    print(data+"\n")

    for lines in data:
        for item in lines:
            if (item != "\n"):
                fdata = np.append(fdata,float(item))
    return fdata

def search_greatest_product(data,N):
    Ndata = len(data)
    print("%i values will be checked!" %Ndata)
    print("Product interval: %i\n" %N)

    greatest = 1
    for i in range(0,N):
        greatest = greatest * data[i]

    greater = greatest

    i = N
    while (i <= Ndata-1):

        factor = data[i]
        if (factor == 0):
            j = 1
            k = i
            greater = 1

            while ((j <= N) & (k<=Ndata-N)):
                k = i + j
                factor = data[k]
                if (factor == 0):
                    j = 1
                    i = k
                    greater = 1
                else:
                    greater = greater * data[k]
                    j = j + 1

            i = i+j-1

        else:
            greater = greater / data[i-N] * data[i]

        if (greater > greatest):
            print("Found greater product: %i - %i" %(greatest, greater))
            greatest = greater

        i = i + 1

    return greatest

fdata = create_long_array(peData)

t0 = t.time()
greatest = search_greatest_product(fdata,5)
tn = t.time()

print("\nFound solution: %i in %.15f seconds!" %(greatest,tn-t0))

Wie elegant die Realisierung des Lösungsvorschlags ist, kann ich als Anfänger nicht wirklich beurteilen. Das Gute an dem gesamten Konzept ist auf jede Fall, dass beliebige Zahlen eingegeben werden können. Es wird immer das größte Produkt der N aufeinander folgenden Zahlen gefunden.

Lösungsanalyse

Wird das vorgeschlagene Programm auf das 8.Projecteuler-Problem losgelassen, so liefert es folgende Ausgabe in der Konsole:

Following data will be red:
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
1000 values will be checked!
Product interval: 5
Found greater product: 882 -> 1764
Found greater product: 1764 -> 6048
Found greater product: 6048 -> 15552
Found greater product: 15552 -> 16128
Found greater product: 16128 -> 18144
Found greater product: 18144 -> 40824
Found solution: 40824 in 0.022379159927368 seconds!

Mit diesem Ergebnis bewegen wir uns erwartungsgemäß in den Grenzen, die von Projecteuler vorgegeben sind und haben auf Anhieb die richtige Zahl gefunden.

Schlusswort

Wahrscheinlich merken die Leser schon an der Länge der Artikels, dass es mir viel Spaß bereitet hat, dieses Problem zu lösen, obwohl es eher eines von den einfacheren Problem war. Wie auch immer, es ist gelöst und vielleicht auf einem nicht ganz konventionellen Wege.

Andere Lösungsvorschläge in den Kommentaren, oder Aussagen zu meinem Lösungsvorschlag sind wie immer sehr 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: 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

Nach etwas über einem Monat kann dieser Beitrag zur Serie “Lösungen mit Python und C++” der projecteuler.net – Problemen als Lebenszeichen gedeutet werden. Die Serie gibt es noch und an dieser Stelle wird der sechste Teil vorgestellt. Wie bereits im fünften Teil der Serie, gibt es auch beim 6. eine einfache Lösung mit Papier und Bleistift und eine kurze Lösungen in Python.

Problemvorstellung

Projecteuler bietet mittlerweile gut 300 Aufgabe, die mehr oder weniger herausfordernd sind. In meiner Serie habe ich bisher erst fünf Lösungen vorgestellt und heute kommt die sechste hinzu. Dabei muss ich zu meiner Schande gestehen, ist die Frequenz, mit der neue Probleme hinzukommen höher als die Veröffentlichungsfrequenz der Lösungen. Aber ich möchte mich bessern !

Die sechste Aufgabe stellt für alle, die Geschichten über den Mathematiker Gauss als kleinen Jungen kennen, kein Problem dar. Ehrlich gesagt, ist es auch für Leute, welche die Geschichten nicht kennen, keine größere Herausforderung.

Ins Deutsche übersetzt, lautet die Aufgabe folgendermaßen:

Finde die Differenz zwischen dem Quadrat der Summe und der Quadratsumme der natürlichen Zahlen bis einschließlich 100.

Laut der Statistik von Projecteuler.net haben bis zum heutigen Tag genau 68751 Teilnehmer das Problem gelöst. Das entspricht grob gesagt der Hälfte aller registrierten User (112160).

Problemeingrenzung

Abgesehen von der rein mathematischen Lösung durch etwas nachdenken und Anwenden der Summenformeln, sehe ich bei dieser Aufgabe lediglich die Herausforderung, sich nicht mit einer straight-forward Lösung zufrieden zu geben, sondern zu versuchen, die Anzahl an Rechenoperationen zu minimieren.

Läge der Schwerpunkt in dieser Artikelserie auf der Mathematik, die hinter den Lösungen steckt, so müssten die Summenformeln hergeleitet werden. Damit wäre der Beweis der Summenformeln die Herausforderung. In unserem Fall soll die Kernaufgabe jedoch mit Hilfe von Python gelöst werden, daher sehe ich keine weitere Herausforderung.

Der Problemlösung erster Teil

Im ersten Lösungsvorschlag geht es darum, wie das 6.Problem gelöst werden kann, wenn man lediglich Papier und einen Bleistift zur Verfügung hat. Des Weiteren müssen wir die zusätzliche Einschränkung einführen, dass nicht viel Zeit benötigt werden darf. Nicht, dass noch jemand auf die Idee kommt alles von Hand oder im Kopf zu rechnen.

Wenden wir uns der ersten Teilaufgabe zu: Berechnung des Quadrats der Summe von 1 bis 100.

Hierfür können wir erst einmal die Gauss-Formel verwenden:
1 + 2 + 3 + ... + 98 + 99 + 100 = n (n+1) * 0.5 = 5050

Wird das Ergebnis der Summenformel (5050) noch quadriert, so erhalten wird schon den ersten Teil der Lösung:
5050 * 5050 = 25502500

Der zweite Teil, also die Quadratsumme, macht uns das Leben nicht so einfach. Aber mit Hilfe einer zweiten Summenformel auch nicht wirklich schwer:
1*1 + 2*2 + 3*3 + ... + 98*98 + 99*99 + 100*100 = n * (n+1) * (2n+1) * (1/6) = 338350

Damit wäre das 6.Projecteuler-Problem gelöst:
25502500 - 338350 = 25164150

Der Problemlösung zweiter Teil

Kommen wir zu der versprochenen Implementierung in Python:

def direct(N):
    SOSq = 0
    SqOS = 0

    for i in range(1,N+1):
        SOSq = SOSq + i*i
        SqOS = SqOS + i

    return SqOS*SqOS - SOSq

Zugegebenermaßen ist dieser Vorschlag nun wirklich ganz einfach und leicht nach zu vollziehen. Die Variable SOSq speichert hierbei die Summe der Quadrate und SqOS das Quadrat der Summe. Ausgegeben wird die gesuchte Differenz.

Natürlich habe ich an dieser Stelle auch etwas weiter gedacht und versucht die Lösung zu optimieren. Jedoch führten meine Gedanken mich immer wieder in Richtung der bereits vorgestellten Summenformeln.

Schlusswort

Das war nun wieder ein Lebenszeichen der Serie zu Lösungen von Projecteuler-Problemen. Der Python-Teil ist diesmal etwas kurz ausgefallen, was in Anbetracht des Problems aber nicht wirklich verwunderlich ist. Sollte ein Leser eine raffinierte Lösung parat haben, so freue ich mich auf den Kommentar.

An dieser Stelle sei allen, die neben der Mathematik und vielen Stunden Programmierarbeit noch etwas Zeit finden zum Lesen, das Buch Die Vermessung der Welt* von Daniel Kehlmann empfohlen. Es geht um zwei herausragende deutsche Wissenschaftler: Carl Friedrich Gauss und Alexander von Humboldt. Es ist ein interessantes Buch, welches durch einen lockeren Schreibstil gekennzeichnet ist, perfekt um in den Kopf zweier Genies einzutauchen.

*: Partnerlink

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: Mathematik, 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

Heute wird die Lösung des vierten Projekteuler-Problems vorgestellt. Es ist nun ein guter Monat vergangen, seit ich das Problem gelöst habe, deswegen hoffe ich, dass ich noch alles zusammenbekomme.

Problemvorstellung

Das Durchlesen des vierten Problems hat mir wieder einmal vor Augen geführt, warum die Mathematik auf viele Menschen eine abschreckende Wirkung hat. In der Aufgabe gilt es das größte Palindrom zu finden, welches sich aus zwei dreistelligen Zahlen ergibt.

Da ist mir erstmal durch den Kopf gegangen: Pali…was?

Dabei ist die Mathematik doch viel einfacher als es klingt, der Blick hinter den Vorhang lohnt sich immer. Gesagt, getan und herausgefunden, dass Palindrome keine Medikamente und auch nichts zum Essen sind, sondern Zahlen, welche von vorne oder von hinten gelesen, den selben Wert ergeben:
22, 232, 23232, 996676699, ...
Der Fantasie kann hierbei freier Lauf gewährt werden. Es gibt jedoch nicht nur Palindrom-Zahlen, sondern auch Namen, wie zum Beispiel Anna.

Um die Aufgabenstellung nochmal hervorzuheben, sei sie nochmal besonders genannt:

Finde das größte Palindrom, welches sich multiplikativ aus zwei dreistelligen Zahlen ergibt.

Aufgrund des Fremdwortes, welches genauer betrachtet nur für eine optisch besondere Zahlenmenge steht, hört sich die Aufgabe erstmal abschreckend an. Jedoch haben sich inklusive meiner Wenigkeit bis heute 54282 Projecteuler-Aktivisten an das Problem mit erfolgreichem Ausgang getraut. Verglichen mit den vorangehenden Problemen 3 und 2 haben sich an dieser Aufgabe noch etwas mehr Menschen die Zähne aus gebissen. Das hat dann dazu geführt, dass nochmal weniger Lösungen eingereicht wurden. Aber wir lassen uns doch nicht von irgendwelchen Statistiken abschrecken und grenzen das Problem etwas näher ein.

Problemeingrenzung

Hat man sich erstmal klar gemacht, was nun Palindrome sind, so stellt sich sogleich die Frage, wie man mit Hilfe einer Programmiersprache überprüfen kann, ob eine Zahl die besondere Eigenschaft der Palindrome besitzt oder nicht. Dies betrachte ich zunächst als erste kleine Herausforderung bei dem Problem.

Die zweite Herausforderung ist in meinen Augen, eine sinnvolle Suche nach Palindromen zu gestalten. Die straight forward Methode wäre alle Zahlen zu multipilzieren und das Produkt auf die Palindrom-Eigenschaft zu prüfen. Doch diesmal dachte ich mir, biete ich keine straight forward Lösung an, sondern steige gleich mit ein Paar Gedanken ins Programmieren ein.

Das Resultat einiger Gedanken kann zum Beispiel sein:

• Die größte Zahl aus einem Produkt zweier dreistelliger Zahlen ergibt sich aus den Zahlen 999 und 999, deswegen lassen wir die Suche von diesen Zahlen beginnen.
• Das größte Palindrom hat wahrscheinlich eine 9 an der ersten und somit auch an der letzten Stelle. Daher sind nur Faktoren interessant, die definitiv eine 9 an letzter Stelle ergeben. Dazu zählen folgende Paare: (7,7) (3,3) (1,9) (9,1)
• Um garantiert das größte Palindrom mit dem Musters 9*****9 zu finden, muss in erster Annahme lediglich die Zehner-Stelle der Faktoren variiert werden. Diese wird in jedem Test um 1 reduziert. Sobald an der Hunderttausender-Stelle eine 8 auftaucht, wird angenommen, dass es schon nicht das größte Palindrom sein kann.

Mit diesem “Wissen” im Hinterkopf, lässt sich das vierte Projecteuler Problem schnell lösen.

Problemlösung

Aus der Problemeingrenzung wissen wir, dass es zwei Herausforderungen bei dieser Aufgabe gibt. Die erste ist der Palindromtest, die zweite die sinnvolle Suche nach dem größten Palindrom. Dazu habe ich folgenden Code geschrieben:

import numpy as np

def test_palindrom(x):
    return x == int(str(x)[::-1])

#    return x == reverse_int(x)

def solver(L,R):
    chL = np.array([-2,-6,-8,0])
    chR = np.array([-2,-6,0,-8])

    maxChange = range(0,11,1)

    palindroms = np.array([[1,2,3]],ndmin=2)

    for k in [0,1,2,3]:
        for i in maxChange:

            LFact = L + chL[k] - i*10

            for j in maxChange:

                RFact =  R + chR[k] - j*10
                testFig = LFact * RFact

                if test_palindrom(testFig):
                    palindroms = np.append(palindroms, [[testFig, LFact, RFact]],axis=0)

    return palindroms

L = 999
R = 999

print(solver(L,R))

Die zu Beginn definierte Funktion test_palindrom(x) überprüft die Palindromeigenschaft. Dies geschieht auf eine einfache Weise: zuerst wird die Zahl x in einen String umgewandelt, dann wird der String gedreht und wieder in einen Integer-Wert konvertiert. Auf diese Weise kann getestet werden, ob x von beiden Seiten gelesen den selben Wert besitzt.

Die Doppelpunktnotation, welche ich zum Umdrehen des Strings verwendet habe, kennt wahrscheinlich jeder Matlab-Nutzer. Der erste Doppelpunkt steht für den ersten Wert, der ausgegeben werden soll, der zweite für den Letzten und die “-1″ zeigt an, dass jeder 1-ste Wert ausgegeben werden soll, aber von hinten.

Wenn nun x kein Palindrom ist, dann spuckt die Funktion den wert “0″ oder “false” aus.

Die solver-Funktion baut auf den zuvor gemachten Gedanken auf. Als Eingabewerte werden jeweils 999 erwartet. Die numpy-Vektoren “chL” und “chR” beinhalten die Variation der Suchzahlen. Damit werden folgende Zahlen als Startzahlen verwendet:
(997,997) (993,993) (991,999) (999,991)

Der Vektor maxChange bewirkt, dass von den Startwerten maximal Zehn mal die Zehn abgezogen wird.

Durch die drei Schleifen wird sichergestellt, dass auch jede Zahl mit jeder multipliziert wird, die nach der Eingrenzung noch übrig geblieben sind. Ist eine Zahl ein Palindrom, so wird sie in einem Feld samt der Faktoren gespeichert und zurückgegeben.

Der langen Rede kurzer Sinn besteht dann aus drei Zeilen:
[[ 1 2 3]
[906609 993 913]
[906609 913 993]]
Erwartungsgemäß trat zumindest ein Palindrom mit einer äußeren 9 auf. Da habe ich ziemlich Glück gehabt . Ebenfalls war zu erwarten, dass das Palindrom doppelt vorkommt, weil mit der gezeigten Methode jedes Zahlenpaar zwei Mal multipliziert wird. Da wäre also noch etwas Optimierungspotential vorhanden.

Fazit

Da es heute keine alternativen Lösungen gibt, komme ich gleich zum Fazit. Das vierte Problem war für mich eine interessante Aufgabe, bei der ich Python etwas besser lernen konnte. Zum Beispiel war mir nicht bekannt, dass in Python die Doppelpunkt-Notation auch mit negativen Zahlen funktioniert. Also wieder etwas gelernt.

Nun hoffe ich, dass es euch auch Spass gemacht hat, das Problem und die Lösung nachzuvollziehen und freue mich über Kommentare.

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

© Muvik for muvik-multigrid, 2010. | Permalink | ein Kommentar | Teile es mit deinen Freunden: del.icio.us MisterWong Twitter
Tags: Palindrom, 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

Die “Lösungen in Projecteuler”-Serie geht mit dem zweiten Teil und dem zweiten Problem weiter. Heute stelle ich wieder kurz das Problem vor und einige kleine Statistiken aus Projecteuler.net-Seite und dann gibt es zunächst eine straight-forward Lösung und zwei alternative Ansätze, die eventuell etwas schneller oder eleganter sind.

Problemvorstellung

Das zweite Problem von Projecteuler.net dreht sich um eine Zahlenfolge, die bei allen Mathematik- und Informatiklehrern beliebt zu sein scheint. Es handelt sich dabei um die Fibonacci-Folge, eine unendliche Folge von Zahlen, die sich jeweils aus den zwei vorhergehenden Zahlen durch Addition ergeben.

Im folgenden Beispiel beginnt die Fibonacci-Folge mit zwei Einsen:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 ...

Ein Herr Fibonacci hat der Legende nach versucht, eine ideal wachsende Kaninchenpopulation damit zu beschreiben. Er ist von zwei Kaninchen ausgegangen und ist auf diese Zahlenfolge mit folgenden Regeln gekommen:

• das Spiel beginnt mit einem Kaninchenpärchen
• pro Zyklus wirft jedes geschlechtsreife Pärchen ein weiteres Pärchen
• jedes Pärchen wird im zweiten Zyklus geschlechtsreif
• kein Tier stirbt, kein Tier kommt zusätzlich hinzu

Wendet man die Regeln an, so lebt im ersten Zyklus ein Pärchen. Im zweiten Zyklus leben schon 2 Pärchen, aber nur eines ist geschlechtsreif und wirft im dritten Zyklus ein weiteres Pärchen. Im vierten Zyklus werden zwei weitere Pärchen geworfen, weil es bereits zwei geschlechtsreife Pärchen gibt, das erste und das zweite Pärchen, welches inzwischen im zweiten Zyklus lebt. Auf diese Weise ergibt sich anschaulich die Fibonacci-Folge. Vielleicht lieben es die Lehrer deswegen so sehr .

Etwas mathematischer ausgedrückt sieht es so aus:

Damit haben wir das zweite Problem von Projecteuler.net etwas eingegrenzt und das Verständnis für die Fibonacci-Folge bildlich untermauert.

Doch worum geht es in dem Problem?

In der zweiten Aufgabe sollen wir alle Zahlen der Fibonacci-Folge, die kleiner als vier Millionen und gleichzeitig gerade sind, addieren.

Das war es schon.

Die Aufgabe gehört genauso, wie die erste zu den einfacheren Problemen. Zum heutigen Zeitpunkt haben 73397 der derzeit 95331 registrierten Hobbymathematiker diese Aufgabe gelöst, das sind immerhin stolze 77%.

Problemeingrenzung

Um der Herausforderung dieses Problems etwas auf die Schliche zu kommen, habe ich mir einfach alle Zahlen der Fibonacci-Folge ausgeben lassen, die kleiner als 4000000 sind. Dazu habe ich folgende kleine Funktion geschrieben:

def print_fibos(N):
    i = 1;

    fibs = np.zeros(1)
    fibs[0] = 1
    fibs = np.append(fibs,[2.],axis=0)
    while (fibs[i]+fibs[i-1])

Die Ausgabe zeigt genau 32 Zahlen. Würde man alle Zahlen addieren wollen, dann wären das 31 Additionen von Ganzzahlen, was nicht wirklich aufwendig ist. Deswegen denke ich, dass es eher sinnvoll ist, die Lösung dahingehend zu optimieren, dass möglichst wenige Tests durchgeführt werden müssen, ob eine Zahl gerade ist oder nicht.

Problemlösung

Wie bereits angekündigt stelle ich zunächst eine straight-forward Lösung vor. Hierbei geht Python alle Fibonacci-Zahlen durch und überprüft, ob sie kleiner als die Grenze von 4000000 ist und ob sie gerade ist. Sind beide Bedingungen erfüllt, so wird die Zahl zu einem Zähler addiert.
So sieht das in Python-Code aus:

import time as t
import numpy as np

def straight_forward(N):
    count  = 2;
    first  = 2;
    second = 3;
    next   = 0;

    while next < N:
        next = first+second;
        first = second;
        second = next;

        if next%2 == 0:
            count = count + next

    return count;

# max. fibo
N = 4000000

print_fibos(N);

t0 = t.time();
erg = straight_forward(N);
tn = t.time();

print("The straight-forward method needed %.15f seconds.\nThe sum is: %12i" %(tn-t0,erg));

Die Funktion gibt auf Anhieb die richtige Lösung von 4613732 aus.

Lösungsanalyse

In dem Code der straight-forward Lösung habe ich bereits die Zeitmessung mit eingebaut. Die Ausgabe des kleinen Programms liefert:

The straigt-forward method needed 0.000010013580322 seconds.
The sum is: 4613732
Ehrlich gesagt, ist die Ausgabe der Zeit in diesem Fall wohl eher nicht sehr zuverlässig. Mir geht es jedoch mehr um die Tendenz, weniger um den absoluten Wert, daher ist es ok.

Also hat die straight-forward Lösung in einer Zeit von 10 Mikrosekunden 10 Zahlen addiert und 31 Zahlen auf die Teilbarkeit durch zwei geprüft. Da die Aufgabe noch recht leicht ist, muss es ja auch besser gehen. Darum geht es im nächsten Abschnitt.

alternative Lösung

Die Problemeingrenzung hat uns gezeigt, dass es gilt, die Teilbarkeitstest durch zwei so selten wie nur möglich durchzuführen sind. Am Besten wären gar keine Tests.

Schauen wir uns die Folge der geraden Fibonacci-Zahlen näher an:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 ...
Es wird deutlich, dass ab der “2″ jede dritte Zahl eine gerade Zahl ist. Folglich müssen auch nur diese summiert werden. Aus diesen Überlegungen hat sich dann folgender Code ergeben:

import time as t
import numpy as np

def only_even(N):
    count = 2;
    a = 1;
    b = 2;
    next = 0;

    while count < N:
        next = 2*a+3*b
        a = 2*b+a
        b = next
        count = count + next;
    return count;

N=4000000;

t0 = t.time();
erg = only_even(N);
tn = t.time();

print("The only_even method needed %.15f seconds.\nThe sum is: %12i" %(tn-t0,erg));

Die Anweisung zur Berechnung der nächsten gerade Fibonacci-Zahl ergibt sich aus folgender Betrachtung:

Setzt man nun von unten nach oben die jeweiligen Variablen ein, so ergibt sich die oben aufgeführte Formel.

Doch welche Vorteile bringt diese Lösung? Folgende Ausgabe erhält man beim Ausführen:
The only_even method needed 0.000007867813110 seconds.
The sum is: 4613732 Also haben wir damit etwas weniger Wartezeit und sind somit effizienter.

Ok, das ist schon besser, aber ich war noch nicht zufrieden und habe noch eine Lösung ausgetestet:

alternative Lösung 2

Mit der zweite alternative Lösung habe ich einen rekursiven Ansatz verfolgt:

import time as t
import numpy as np
def rec_fibo(a,b,N):
    next = 2*a + 3*b;
    if (next < N):
        return next + rec_fibo(2*b+a,next,N);
    else:
        return 0;

t0 = t.time();
erg = rec_fibo(1,2,N);
tn = t.time();

print("The recursive method needed %.15f seconds.\nThe sum is: %12i" %(tn-t0,erg));

Wie du bestimmt festgestellt hast, verwendet auch die rekursive Lösung keine Gradheitsüberprüfung der Fibonacci-Zahlen. Hier habe ich genauso, wie bei der ersten alternativen Lösung nur die geraden Zahlen betrachtet.

Die Rekursion bietet sich oft für Probleme wie dieses an. Es ergibt meist eine recht elegante und kurze Lösung, die aber nicht zwangsläufig auch weniger Rechenzeit benötigt, wie die Ausgabe zeigt:
The straigt-forward method needed 0.000010013580322 seconds.
The sum is: 4613732
The only_even method needed 0.000007867813110 seconds.
The sum is: 4613732
The recursive method needed 0.000009059906006 seconds.
The sum is: 4613730

Zusammengefasst ist die einfache Lösung ohne Gradheitsüberprüfung die schnellste, jedoch sind die Zeiten bei dieser Dimension des Problems mit Vorsicht zu genießen, sie sind ziemlich klein.

Fazit

Damit wäre ich am Ende meiner Lösungsvorstellung des zweiten Projecteuler.net Problems. Diesmal gab es wieder eine Neuerung, die bisher in der Form in meinem Weblog noch nicht vorkam: die Rekursion.

Jetzt ist wieder deine Meinung gefragt: Was hat dir gefallen, was nicht und was würdest du mir als Tipp für die nächste Folge "Lösungen mit Python und C++" mitgeben?

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: Projecteuler, Python, Rekursion

Im ersten Teil der Serie über Lösungen zu Aufgaben von Projecteuler geht es um das erste Problem. Nach der Vorstellung des Problems und der Lokalisierung der kritischen Stelle wird zunächst eine straight-forward Lösung beschrieben. Eine alternative Lösung stellt schließlich das Ende des ersten Teils der Lösungen zu Projekteuler-Serie dar.

Problemvorstellung

Im ersten Problem auf Projecteuler.net geht es darum, eine Summenformel auf zu stellen, welche alle Zahlen addiert, die kleiner als 1000 sind und durch drei oder fünf teilbar sind.

Das ist wohl das einfachste Problem. Diese Vermutung wird durch eine ebenfalls einfache statistische Betrachtung bestätigt: Auf Projecteuler.net sind derzeit 94426 Benutzer angemeldet. Davon haben genau 87185 das erste Problem gelöst. Prozentual betrachtet sind das etwa 92.33%. In Kürze: jeder hat das Problem gelöst, die restlichen 7.67% haben sich nur angemeldet um einmal hinter die Kulissen von Projecteuler.net zu schauen.

Problemeingrenzung

Das Problem ist wirklich einfach und es sollte auch mit der langsamsten Programmiersprache innerhalb von einer Minute zu schaffen sein. Nichtsdestotrotz nehme ich an, dass das Ziel einer Optimierung der Lösung die Anzahl der benötigten Rechenoperationen sein könnte, insbesondere die Anzahl der nötigen Überprüfungen, ob ein bestimmtes i durch drei oder durch fünf teilbar ist.

Problemlösung

Das erste, was mir bei dem Durchlesen des Problems eingefallen war, ist die einfachste straight-forward Lösung, wie sie in der Latexformel gezeigt ist. In Worten heißt es: Addiere alle Zahlen, die durch drei oder fünf teilbar sind und kleiner als 1000 sind. Dies kann in Python direkt so hingeschrieben werden:

count = 0;
N = 1000
for i in range(3,N):
    if i%3==0 or i%5==0:
        count = count + i;

Zwar ist das aus mathematischer Sicht sicherlich nicht die eleganteste Lösung, aber es ist die einfachste. Als Ergebnis kommt übrigens 233168 heraus.

Lösungsanalyse

Die Rechenzeit ist bei Projekeuler.net auf maximal eine Minute begrenzt, was hier jedoch kein Problem darstellen sollte. Und tut es auch nicht.
Da ich ein Python-Anfänger bin, habe ich an dieser Stelle nicht aufgehört, sondern mich gefragt, wie lange die Lösung den nun wirklich braucht. Dazu habe ich wieder auf eine möglichst einfache Weise die Zeit vor dem Ausführen der Schleife und danach gemessen:

import time as t
count = 0;
tin = t.time();
N = 1000
for i in range(3,N):
    if i%3==0 or i%5==0:
        count = count + i;
tout = t.time();

Eine auf diese Weise gemessene Zeitspanne beträgt für die Summation 0.000219 Sekunden.

alternative Lösung

Mit der bereits vorgestellten Lösung hätten wir das erste Problem aus der Welt geschafft und könnten uns dem nächsten widmen. Da dieser Ansatz aber nicht wirklich elegant ist, habe ich mir noch eine Lösung überlegt. Fast jeder hat in der Schule einmal die Geschichte vom kleinen Gauss gehört. Darin geht es um den Schuljungen Gauss, welcher schnell rechnen konnte und dadurch seinem Lehrer auf den Geist ging. Daraufhin hat sich der Lehrer gedacht, Gauss die Aufgabe zu geben, alle Zahlen von 1 bis 100 zusammen zu zählen, was ja dem ersten Projecteuler-Problem ganz nahe kommt. Wäre der Gauss ein einfacher Junge gewesen, so hätte er die Summe, wie ich in der ersten Lösung, gebildet. Damit wäre er eine Weile beschäftigt gewesen.
Jedoch hat er sich eine Summenformel ausgedacht, mit welcher er in drei Operationen das Ergebnis hatte. Meine alternative Lösung wendet nun eine ähnliche Summenformel an:

def pr1_littlegauss(N):
    N=N-1
    cthree = (N-(N%3)+3)*(N-N%3)/3/2;
    cfive  = (N-(N%5)+5)*(N-N%5)/5/2;
    cfifteen = (N-(N%15)+15)*(N-N%15)/15/2;
    return cthree+cfive-cfifteen;

Hierbei werden zunächst alle Zahlen, die durch drei teilbar sind in die Variable cthree gespeichert, entsprechend auch alle durch fünf teilbaren in cfive. Da nun alle Zahlen die durch drei und gleichzeitig durch fünf teilbar sind, doppelt in der Summe vorkommen würden, müssen alle fünfzehn-fachen abgezogen werden. Das sieht schon viel eleganter aus.
Misst man die Zeit, wie oben beschrieben, so komme ich dabei auf 0.000005 Sekunden. Wie man leicht sieht ist da ein Faktor von 44 dazwischen!
Um den Unterschied in tatsächlich messbaren Zeiten zu messen habe ich beide Funktionen alle Zahlen, die durch drei und fünf teilbar sind und kleiner als 10000000 sind, addieren lassen:
Straigt-Forward
The sum is: 23333331666668
used time for the calculation: 2.965809822082520
Little-Euler
The sum is: 23333331666668
used time for the calculation: 0.000020980834961 Und das ist schon ein beträchtlicher Unterschied.

Fazit

Das war die erste Vorstellung eines Projecteuler.net Problem. Ich hoffe, dass es verständlich geschrieben ist und würde mich über Kommentare, Anmerkungen und Verbesserungsvorschläge freuen.

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

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