Codeoptimierungen anhand von Beispielen

  • Schönen guten Tag Community! :)
    In der letzten Zeit habe ich mich intensiv mit Algorithmen beschäftigt, darunter auch um die Optimierungen dieser. Durch die Project Euler bin ich auf ein paar interessante Aufgaben gestoßen, welche das Thema Primzahlen betrifft. Ich bin erstaunt was sich mit ein wenig Fachwissen an einem Algorithmus alles an Geschwindigkeit heraus holen lässt. Ich möchte mit euch meine Erkenntnisse teilen und einfach mal niederschreiben was ich gelernt habe. In Zukunft werde ich Probleme so angehen, wie ich es durch diese Website gelernt habe. Nun denn, fangen wir einmal an:




    Die Primfaktorzerlegung:
    Eine natürliche Zahl über 1 lässt sich in Primzahlen zerlegen (sofern diese nicht selber eine Primzahl ist). In diesen Teilabschnitt geht es darum einen Algorithmus zu entwickeln, der eine beliebige Zahl in ihre Primfaktoren zerlegt und diese als 2 dimensionales Array aus gibt. Gehen wir beispielsweise einmal von der Zahl 140 aus, ihre Primfaktoren sind 2^2 * 5 * 7. Doch wie genau können wir jetzt vorgehen um diese Primzahlen zu ermitteln?


    Ein Denkbarer (und einfacher) Ansatz wäre, einfach die Zahl ständig durch 2 zu dividieren, bis ein Rest entsteht. Danach dividieren wir die Zahl durch 3, 4 und 5 (usw.) bis aus unserer ursprünglichen Zahl 1 geworden ist. Versuchen wir das mal mit der 140:

    Code
    140 / 2 = 70 Rest 0
    70 / 2 = 35 Rest 0
    35 / 2 = 17 Rest 1 > Da ein Rest besteht, kann 2 als weiterer Faktor nicht mehr zutreffen...
    35 / 3 = 11 Rest 2
    35 / 4 = 8 Rest 3
    35 / 5 = 7 Rest 0
    7 / 5 = 1 Rest 2
    7 / 6 = 1 Rest 1
    7 / 7 = 1 Rest 0 > Abbruchbedingung erfüllt! Ergebnis ist 1 und Rest = 0.


    Wir sehen nun in unseren Rechnungen, dass jener Divisor welche als Faktor in Frage kommt ein restloses Ergebnis liefert. Dadurch sehen wir auch welche die Primfaktoren sind und wie oft diese vorkommen. Hier der dazu passende AutoIt Code:

    Funktioniert doch, erste Sahne. Nun fangen wir an mit den Optimierungen an. Sicherlich fragt sich jetzt der schlaue Leser, warum überhaupt Optimierungen vorgenommen werden sollten? Tja, ich sag nur eins: Setzt doch mal die Zahl 98765432123 spaßeshalber ein und lasst euch davon die Primfaktoren ausrechnen. Mein Rechner hat 2 Minuten gebraucht um herauszufinden dass die Primfaktoren von 98765432123 = 1447^1 * 68255309^1 sind. Jetzt wird auch schnell klar weshalb das unser Algorithmus für solch eine Zahl so lange braucht. Es muss 68255309 Schleifendurchgänge durchlaufen, um auch diesen großen Primfaktor zu ermitteln. Nicht gerade optimal. Jedoch können wir mit ein wenig Know-How die Laufzeit um 50% verringern ohne dass wir auf irgend eine Akademie gegangen sein müssen. Es gibt (außer der 2) keine geraden Primzahlen! Wie denn auch? Jede gerade Zahl lässt sich durch 2 teilen und ist daher keine Primzahl, wir können uns also ersparen die geraden Zahlen zu durchlaufen und überspringen diese einfach. Das bedeutet wir müssen am Anfang überprüfen ob die Zahl durch 2 teilbar ist, danach nur noch ob diese durch eine ungerade Zahl teilbar ist. Unser Algorithmus verändert sich also folgendermaßen:

    Super, damit haben wir unseren Anwender eine Wartezeit von einer Minute beschert, auf Toilette gehen kann er also auch nicht mehr, also müssen wir die Rechenzeit doch noch etwas verkürzen damit unsere Arbeit doch nicht ganz umsonst ist. Damit das allerdings klappt müssen wir eine andere Eigenschaft der Primzahlen ausnutzen. Jede Zahl kann(!) genau ein Primfaktor besitzen, welcher die Quadratwurzel der Zahl übersteigt. Dadurch müssen alle anderen Primfaktoren auf jeden Fall unter der Quadratwurzel der Zahl liegen. Damit haben wir schon mal ein Limit für unsere Schleifendurchgänge, und zwar die Quadratwurzel der Zahl. Damit können wir unseren Code noch mehr optimieren:

    Und wenn wir den Code jetzt ausführen, brauchen wir für die gleiche Zahl, die uns vorhin mit unverschämten 120 Sekunden geärgert hat, knapp nur noch 10 Millisekunden. Wenn das mal keine Steigerung der Geschwindigkeit von unseren ursprünglichen Algorithmus ist! Die Geschwindigkeit hat sich um den Faktor 12000 verringert! Nun könnten wir nur noch berechnen wie viele Primfaktoren in etwa die Zahl hat und somit den Speicherbedarf für das Array senken. Eine Möglichkeit wäre es, alle Primzahlen zu multiplizieren (ab 2 aufwärts) bis wir die Zahl 2^64 -1 (x64) bzw. 2^32 -1 (x86) übersteigen. Die Anzahl der Faktoren entspricht somit die Anzahl der meist möglichen Primfaktoren für den überhaupt möglichen Speicherbereich. Dadurch können wir dem Array eine fixe Größe Zuteilen dessen Anzahl der Elemente wir nicht zur Laufzeit berechnen müssen.


    >> Weiteres folgt noch...
    Gerne dürft ihr auch selber was dazu schreiben :)

  • Danke!
    Schön dargestellt.

    ...... Lieben Gruß, ........
    ...........
    Alina ............

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Ich habe die Deutsche Hilfe auf meinem PC und
    OrganizeIncludes ist beim Scripten mein bester
    Freund. Okay?