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

Los gehts: Sehr schnell nach der Veröffentlichen des ersten Tutorials zum Lesen von csv-Daten mit Python, kamen von zwei Identi.ca-Teilnehmern der Hinweis auf das Python csv-Modul. Darauf möchte ich nun eingehen.

Reaktionen auf das erste Tutorial

Erstaunlicherweise kamen buchstäblich Sekunden nach der Veröffentlichung des ersten Tutorials von lutzgh und evgeni über identi.ca zwei Reaktionen in gleiche Richtung. Beide wiesen mich auf das csv-Modul hin, welches genutzt werden kann, um diverse Daten zu importieren.

Natürlich kam mir sofort der Gedanke, warum ich das Modul nicht selber entdeckt habe. Ich muss zugeben, dass ich gar nicht gesucht habe. Mir ist auf Anhieb die Lösung mit den regulären Ausdrücken eingefallen. Doch, aus zwei Gründen bin ich glücklich, dass es nun so gekommen ist:

1. Auf dieser Grundlage lässt sich ein weiterer netter Blog-Artikel schreiben .
2. Aus eins mach zwei: Ursprünglich als alleinstehendes Thema geplant, ist es nun in zunächst zwei verschiedenen Ausführungen vorhanden, die sich prächtig ergänzen. Dadurch ergibt sich eine breitere Grundlage und noch mehr Wissen für meine Leser.

Also nur Vorteile für alle im Thema interessierten.

Das csv-Modul

Das csv-Modul, welches es laut der Python-Dokumentationseite, seit der Version 2.3 gibt, unterstützt den Programmierer in seiner Arbeit beim Import und Export von Daten, welche tabellarisch im csv-Format gespeichert sind oder werden sollen. Dafür stellt es diverse Funktionen zur Verfügung, von denen ich die reader() und writer()-Funktionen als die für mich wichtigsten einstufe.

Sehr interessant ist die Möglichkeit mit Hilfe des csv-Moduls, Excel-Daten zu importieren und in Excel-Stil zu exportieren. Dazu muss lediglich ein bestimmter Parameter übergeben werden, der das Format definiert. Das scheint mir einer der größten Vorteile dieses Moduls zu sein.

Datensatz und Import der Daten mit dem csv-Modul

Wie bereits im ersten Tutorial wird auch hier der kleine Beispiel-Datensatz von walkingrandomly.org übernommen:
header 1;
header 2;
1031,-948,-76, ,"12"
507,635,-1148, ,"34"
-1031,948,750, ,"45"
-507,-635,114, ,"67"

Diese Zeilen sollen nun mit dem csv-Modul in das Programm importiert werden und in drei verschiedenen Listen gespeichert werden. Dabei interessieren uns lediglich die Daten, die nicht Kopfdaten sind oder in Anführungszeichen stehen. Dazu habe ich folgendes Python-Skript geschrieben:

import csv
fileO = open('walking_example.dat','r')
csvreader=csv.reader(fileO, delimiter=',')
k= []; l = []; m = [];

for row in csvreader:
    if len(row) > 1:
        k.append(float(row[0]))
        l.append(float(row[1]))
        m.append(float(row[2]))

print(k,l,m)

fileO.close()

Schrittweise erklärt

1.Zeile: Import des csv-Moduls

2.Zeile: Erstellen eines file-Objekts, welcher die Datei mit dem gezeigten Datensatz enthält.

3.Zeile: Einlesen der Daten von fileO mit der reader()-Funktion des csv-Moduls. Die Funktion erwartet mindestens einen Übergabeparameter und zwar das file-Objekt. Des Weiteren kann ein sogenannter Dialekt vorgegeben werden, welcher für sich die Struktur der csv-Daten definiert. Ein Dialekt könnte zum Beispiel Excel sein (dialect=’excel’). Weitere optionale Argumente wie das Trennungszeichen (delimiter=’,’) können hinzugefügt werden.

4.Zeile: Initialisieren der Listen, mit welchen weiter gerechnet werden soll.

7-10.Zeile: Das Auslesen der importierten Daten erfolgt an dieser Stelle. Die reader()-Funktion liest die Daten zeilenweise ein, dabei spielt es zunächst keine Rolle, ob es Kopfdaten sind oder nicht. Dieses Vorwissen muss bei der vorgestellten Methode vorhanden sein. Im Beispiel haben wir zwei Zeilen mit Kopfdaten, welche ignoriert werden sollen. Dies geschieht über die Abfrage der Länge der Liste row. Zuletzt werden in den Zeilen noch die Listen k,l,m um die ersten drei Spalten erweitert.

11-12.Zeile: Ausgabe der Listen und schließen des file-Objekts.

Schlusswort

Die Vorteile des csv-Moduls im Vergleich zu der Lösung mit regulären Ausdrücken liegen auf der Hand. Zum einen ist der Import effizienter und einfacher zu schreiben und zum anderen ist die Fehleranfälligkeit nicht so hoch.

Auf der anderen Seite stellen die regulären Ausdrücke eine viel allgemeinere Methode dar, Daten zu importieren. Hierbei muss lediglich die Struktur der Daten bekannt sein, Kopfzeilen werden automatisch ignoriert. Des Weiteren stellen zusätzliche Störungen in den Daten für reguläre Ausdrücke kein Problem dar.

Sollte ich jemals in die Verlegenheit kommen, mich zwischen den zwei Lösungen entscheiden zu müssen, so werde ich natürlich das dem Problem am besten angepasste nutzen. Das heißt: bei relativ sauberen Daten das csv-Modul und bei stark ungeordneten Daten die regulären Ausdrücke.

Nun hoffe ich auf konstruktive Kritik!

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: InputOutput, Python, Tutorial

Los gehts: Tutorials, die nicht in die Kurztipp-Serie passen, weil sie zu groß, zu lang, zu wichtig sind oder ein besonderes Feature enthalten haben nun ebenfalls eine eigene Kategorie-Grafik. Diesmal geht es um das Einlesen beliebiger, durch ein Komma getrennter Daten aus sogenannten csv-Dateien (comma-seperated-values) in Python mit Hilfe der regulären Ausdrücke (regular expressions).

Idee und Intention

Wie aus der Seitenleiste des Blogs entnommen werden kann, lese ich regelmäßig die Artikel des walkingrandomly.com Blogs von Mike Croucher. Am 21. Mai 2010 schrieb Mike ein Matlab Tutorial, dessen Inhalt es war, wie csv-Dateien in Matlab eingelesen werden können. Im Rahmen dieses Artikels ging er auf verschiedene Möglichkeiten ein, eine csv-Datei zu importieren.

Begonnen hat er mit einer einfachen zu importierenden Datei, worin die Daten ohne Ausnahmen durch eine Komma getrennt waren. Richtig interessant wurde es beim Import von Daten aus einer unordentlich definierten csv-Datei. Das Beispiel stammte von einem Leser seines Blogs und soll hier ebenfalls verwendet werden.

Der Datensatz

Es lässt sich unendlich lange darüber unterhalten, wie sinnvoll oder sinnlos es ist, innerhalb einer Datei mit csv-Daten weitere Daten zu integrieren, welche nicht durch Kommas getrennt werden und eventuell andere Datentypen sind. Abgesehen davon ist das Beispiel, welches auch Mike verwendet folgendes:

header 1;
header 2;
1031,-948,-76, ,"12"
507,635,-1148, ,"34"
-1031,948,750, ,"45"
-507,-635,114, ,"67"

Da das Ziel beim Import der Daten ist, mit ihnen weiter zu rechnen oder zu plotten, ergeben sich für mich zwei Herausforderungen, bei dem gegebenen Datensatz:

1. Eine straight-forward Lösung bricht sich bereits an der ersten Zeile das Bein, an der ersten Kopfzeile. Also müssen eine vorgegebene Anzahl an Zeilen beim Importieren ignoriert werden können.
2. Da die letzte Spalte nicht nur durch ein Komma getrennt ist, sondern in Anführungszeichen steht, soll angenommen werden, dass es reiner Text ist und soll beim Import ignoriert werden.

Damit wären die Stolpersteine lokalisiert und können aus dem Weg geräumt werden.

Reguläre Ausdrücke (regular expressions, kurz: regex)

Es gibt mehrere Möglichkeiten das beschriebene Problem anzugehen und die regulären Ausdrücke stellen in meinen Augen nicht die schlechteste dar. Zum einen wird aus den zwei Herausforderungen nur noch eine und zum anderen ist die Lösung sehr schnell auf dem Tisch und sieht elegant aus. Sollte sich die Struktur der csv-Daten noch ändern, stellt es für die Lösung mit regulären Ausdrücken kein großes Problem dar. Es muss lediglich eine Zeile angepasst werden.

Reguläre Ausrücke habe ich persönlich bisher sehr sporadisch gebraucht, würde aber dennoch folgendes Vorgehen vorschlagen:

1. Klären der Struktur der Daten
2. Erkennen eines Musters
3. Definition des Musters in regulären Ausdrücken
4. Implementierung des Rahmenprogramms: öffnen einer Datei, ausgeben der Ergebnisse …

Die Struktur des Datensatzes haben wir schon geklärt: es ist ein Datensatz, dessen Elemente durch Kommata getrennt sind. Die zwei Kopfdateien interessieren uns hierbei nicht, die sollen nicht importiert werden.

Das Muster ergibt sich, indem logische Bereiche von einer Zeile betrachtet werden:
-1031,948,750, ,"45"
Zum Einen ist zu bemerken, dass alle Zahlen ganze Zahlen sind. Zudem ist ein Minus auch erlaubt. Also ergibt sich aus der Überlegung folgendes Muster: drei aufeinander folgenden Integer-Zahlen, die durch jeweils ein Komma getrennt sind und evt. ein Minus vor der Integer-Zahl.

Daraus lässt sich nun der folgende einfache reguläre Ausdruck ableiten:
(-?[0-9]*),(-?[0-9]*),(-?[0-9]*),.*
Es sei angemerkt, dass auch an dieser Stelle viele Wege nach Rom führen. Drei Programmierern fallen bestimmt spontan neun verschiedene reguläre Ausdrücke ein, die alle die korrekte Lösung liefern.

Reguläre Ausdrücke in Python

Der glückliche und aktive Linux Benutzer kann reguläre Ausdrücke in sehr vielen Programmen und Tools anwenden. Als Beispiele seien nur die Tools grep und awk genannt.

Ich möchte nicht behaupten, dass die meisten Bücher, jedoch sehr viele erklären reguläre Ausdrücke in Kombination mit der Skriptsprache Perl. In Python lassen sich die regulären Ausdrücke doch ebenso leicht verwenden. Dazu muss lediglich das Modul re importiert werden:
import re Damit sind wir mit einer mächtigen Waffe ausgestattet.

Import der csv-Daten und Ausgabe der Listen (Arrays)

Gehen wir es an und importieren den Datensatz mit den unordentlich formatierten Daten. Dazu schlage ich folgendes kleines Python-Skript vor:

import re

# define a pattern for matching the needed data

fileO = open('walking_example.dat','r')
search_data = fileO.readlines()

fileO.seek(0,0)

print("Following data will be parsed:\n")
print(fileO.read())

fileO.close()

pattern = '(-?[0-9]*),(-?[0-9]*),(-?[0-9]*),.*'
r = []; s = []; t = [];

for line in search_data:
    found = re.search(pattern, line)
    if found:
        r.append(float(found.group(1)))
        s.append(float(found.group(2)))
        t.append(float(found.group(3)))

print("\nThe parsed lists:\n")
print(r,s,t)

Schrittweise erklärt:

1.Zeile: Zu Beginn wird das Modul zur Verwendung regulärer Ausdrücke importiert.

5.Zeile: Es wird ein file-Objekt angelegt, welches die Datei mit dem Datensatz enthält. Die Funktion open erhält im ersten Übergabeparameter die Datei inklusive dem Pfad und im zweiten die Option ‘r’, was bedeutet, dass nur gelesen werden soll. Da in meinem Fall die csv-Datei sich im selben Ordner befindet, wie das Python-Skript, muss lediglich der Dateiname angegeben werden.

6.Zeile: Um die Daten aus dem file-Objekt zu verwenden, werden sie zeilenweise eingelesen und in der Variablen search_data gespeichert.

7-11.Zeile: Dieser Abschnitt ist optional. Zunächst wird die Position im file-Objekt wieder auf den Ausgangszustand zurückgesetzt, damit der Datensatz erneut mittels read() gelesen und dadurch einfach mit print() ausgegeben werden kann. Dies alles dient nur der leichten Kontrolle des regulären Ausdrucks.

13.Zeile: Das file-Objekt wird geschlossen.

15.Zeile: Der bereits vorgestellte reguläre Ausdruck wird in der Variable pattern gespeichert.

16.Zeile: Initialisierung leerer Listen für die drei Spalten aus den Datensatz.

19.Zeile: Anwendung des regulären Ausdrucks für jede Zeile aus search_data, was mit Hilfe der for-Schleife aus Zeile 18 bewerkstelligt wird. Hierzu wird die Funktion search aus dem re-Modul verwendet. search erhält als erstes Argument das Muster und als zweites die zu untersuchende Zeile des Datensatzes.

21-23.Zeile: Wenn re.search etwas gefunden hat, dann werden die Teile, welche im regulären Ausdruck in runden Klammern stehen in die drei Listen r,s,t geschrieben. Vor dem eigentlichen Anhängen an die Liste mittels append wird der Inhalt in float-Zahlen umgewandelt.

26.Zeile: Zu guter Letzt werden die Listen zur Kontrolle ausgegeben.

Ergebnis und Kontrolle

Die Arbeit ist getan, jetzt gilt es nur noch die Lorbeeren zu pflücken.

Dazu schauen wir uns an, was das Skript in der Shell ausgibt:
Following data will be parsed:
header 1;
header 2;
1031,-948,-76, ,"12"
507,635,-1148, ,"34"
-1031,948,750, ,"45"
-507,-635,114, ,"67"
The parsed lists:
([1031.0, 507.0, -1031.0, -507.0], [-948.0, 635.0, 948.0, -635.0], [-76.0, -1148.0, 750.0, 114.0])
Es ist ganz leicht zu erkennen, dass das kleine Programm für diesen Fall richtig funktioniert hat.

Schlusswort

Reguläre Ausdrücke sind ein mächtiges Instrument, welches jedoch aufgrund der etwas undurchsichtigen Syntax oft als zu umständlich abgelehnt werden. Aus meiner Sicht lohnt sich eine kurze Einarbeitung in die Syntax, wenn öfter mal bestimmte Bereiche eines Datensatzes extrahiert werden müssen, was bei mir der Fall ist.

An dieser Stelle ein Dankeschön an Mike vom walkingrandomly.com-Blog für die Steilvorlage.

Weiterhin würde mich interessieren, wie meine Leser an die Sache herangegangen wären und welche Erfahrungen sie gemacht haben in Bezug auf reguläre Ausdrücke.

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: InputOutput, Python, Tutorial

Thema der ersten Liste lautet: Python (Programmieren-) Lernen. Diesen sehr allgemeine Beginn möchte ich kurz begründen, bevor es zur eigentlichen Linkliste geht. Die Linkliste enthält heute einige eBooks und einen Verweis zu Screencasts bzw. Videos zum Thema.

Nur in den seltensten Fällen gibt es lediglich einen gewichtigen Grund für ein Vorgehen oder einen Entschluss eines Menschen; die Auswahl des heutigen Themas stellt dahingehen auch keine Ausnahme dar. Aus folgenden Gründen gibt es heute Links zu dem sehr allgemein gehaltenen Thema “Python Lernen”:

• Python als Programmiersprache und Problemlösungswerkzeug stellt eine wichtige Säule auf meinem Blog dar. Insbesondere steht hierbei das Erlernen von Python im Vordergrund. Das allein ist schon Grund genug, um an dieser Stelle eine Liste mit allgemeinen Büchern für Anfänger und Fortgeschritten in der Python-Programmierung zu erstellen.
• Da ich selber noch ein Anfänger bin, kann ich beurteilen, wie viel Wert eine kompakte Sammlung an Links für Anfänger darstellt. Diese möchte ich auf meiner Webseite daher nicht missen.
• Da ich grundsätzlich nicht vor habe, überwiegend brandaktuelle News in der Linkliste aufzuführen, kann die Linkliste sich zu einer Informationsquelle für im Thema interessierte Leser entwickeln.

Damit möchte ich die Begründung als ausreichen ansehen und zur eigentlichen Linkliste übergehen.

4 eBooks zum Thema Python Lernen

Videos und Screencasts zum Thema Python Lernen

Schlusswort

Das waren die ersten fünf Links zu Resourcen, die mir wichtig waren und sind und denen ich zutraue, dass sie meinen lieben Lesern ebenfalls hilfreich sein können.

Natürlich würde ich mich über Kommentare diesbezüglich freuen. Weitere Links zum Thema “Python Lernen” nehme ich gerne auf und veröffentliche sie in einer weiteren Linkliste.

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: eBook, Python, Tutorial

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 im Fokus: Testen von Funktionen mit den DocStrings.

Auch unter Programmierern sind Stammtischgespräche verbreitet. Je nach Bewusstseinszustand vertritt der eine oder andere sogar die Meinung, dass der überwiegende Anteil der Zeit beim Entwickeln einer Software auf das Debuggen, Fehlersuchen und Testen verwendet wird. Auch wenn das wahr sein sollte, besteht für Python-Programmierer keinen Grund zur Unruhe, denn es gibt das doctest-Modul, welches das Testen von Python-Code leichter macht.

In dem Artikel “Python Dokumentation mit DocString bin ich bereits auf die DocStrings und die Möglichkeiten, welche diese bieten etwas eingegangen. Ganz beiläufig hieß es dabei (Zitat):

Somit ergeben sich folgende Vorteile für Anwender und Coder:

• …
• Beispiele in DocStrings können zum Veranschaulichen und Testen verwendet werden.

Dieser Aussage möchte ich heute anhand eines kleinen Beispiels mehr Inhalt geben. Zumindest was das “Testen” angeht.

Szenario

Die modulare Entwicklung von Software birgt etliche Vorteile, von denen an dieser Stelle besonders eine ganz wichtig ist. Zum Einen steigert die modulare Methode die Übersichtlichkeit und erleichtert das Verstehen der kleineren Bausteine im Vergleich zum großen Ganzen. Der größte Vorteil ist jedoch der enorme Zeitgewinn. An jedem Modul kann ein anderer Programmierer sich die Finger wund tippen. Am Ende werden die voll funktionsfähigen Einzelmodule zusammengeführt und ergeben das endgültige Produkt.

Damit das Zusammenführen reibungslos vonstatten gehen kann, müssen die Einzelmodule zuvor eingehen getestet werden. An dieser Stelle kommen die DocStrings mit dem doctest-Module ins Spiel.

Einleitend in dieses Thema lässt sich die Funktion der Kombination aus DocString und doctest-Modul folgendermaßen zusammenfassen: Innerhalb des DocStrings wird der Python-Kommandozeilenaufruf nachgestellt und das zu erwartende Ergebnis angegeben.

An einem kleinen Beispiel wird dies deutlicher.

Komplizierte Beispielfunktion

Um den Kurztipp anschaulicher zu gestalten, habe ich mir eine sehr wichtige Funktion einfallen lassen :

def addtwo(x):
    """Addiert zu jeder Zahl eine Zwei hinzu:

    >>> addtwo(3.0)
    5.0

    >>> addtwo(0.0)
    2.0
    """

    return x + 2.0

Die Beispielfunktion erhöht jede Zahl x um zwei und gibt diese zurück. Damit mit Sicherheit klar ist, was sie tut, wird der Zweck und Sinn innerhalb eines DocStrings beschrieben. Zusätzlich wird die Funktion im DocString zwei Mal “aufgerufen” und das dazugehörige Ergebnis angegeben.

Die drei spitzen Klammern sollen hierbei die Python-Kommandozeile symbolisieren.

Wie erfolgt nun der Test, ob die Funktion auch das richtige Ergebnis liefert?

Das doctest-Modul führt die Anweisungen, vor denen der Python-Prompt (>>>) steht, aus und vergleicht das Ergebnis mit dem erwarteten Wert, welcher unterhalb des Prompts steht. In der Standardeinstellung liefert doctest nichts zurück, wenn beide Zahlen gleich sind, stimmen sie nicht überein, so gibt es eine Fehlermeldung:
> python -m doctest addtwo.py

Dieser Skriptaufruf hat keine Ausgabe zur Folge, weswegen man sich entspannen und davon ausgehen kann, dass die Funktion in Ordnung ist.

Möchte man auf etwas Feedback nicht verzichten, dann lässt sich das Skript auch mit einer ausführlichen Version starten:
> python -m doctest -v addtwo.py
Trying:
addtwo(3.0)
Expecting:
5.0
ok
Trying:
addtwo(0.0)
Expecting:
2.0
ok
1 items had no tests:
addtwo
1 items passed all tests:
2 tests in addtwo.addtwo
2 tests in 2 items.
2 passed and 0 failed.
Test passed.

Und wenn etwas nicht richtig läuft, wenn zum Beispiel statt zwei nur eins hinzu addiert wird:
> python -m doctest -v addtwo.py
Trying:
addtwo(3.0)
Expecting:
5.0
***************************************************
File "addtwo.py", line 4, in addtwo.addtwo
Failed example:
addtwo(3.0)
Expected:
5.0
Got:
4.0
Trying:
addtwo(0.0)
Expecting:
2.0
***************************************************
File "addtwo.py", line 7, in addtwo.addtwo
Failed example:
addtwo(0.0)
Expected:
2.0
Got:
1.0
1 items had no tests:
addtwo
***************************************************
1 items had failures:
2 of 2 in addtwo.addtwo
2 tests in 2 items.
0 passed and 2 failed.
***Test Failed*** 2 failures.


Fazit

DocStrings in Kombination mit doctest stellen in meinen Augen eine praktische und leicht handhabbare Methode dar, um Module, Funktion und Klassen zu testen und gleichzeitig den Funktionsaufruf direkt im DocString und damit in der Dokumentation zu demonstrieren.

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: DocString, Python