Effiziente Algorithmen mit Python. D. Komm, T. Kohn

Transkript

1 Effiziente Algorithmen mit Python D. Komm, T. Kohn

2 Copyright c 2017, ABZ, ETH Zürich Version vom 7. September 2017.

3 Effiziente Algorithmen mit Python 3 1 Effizienz Effizient Effizienz hat nur Sinn in Bezug auf eine Metrik: Welcher Aspekt eines Algorithmus oder Programms soll effizient sein? Minimale Anzahl Rechenoperationen, Minimale Ausführungszeit, Minimale Speicherbelastung, Minimaler Energieverbrauch, Maximale Skalierbarkeit (grössere Eingaben), Maximale Ausnutzung der Resourcen (Parallelisierung), Minimale Programmlänge, Minimale Anzahl von Prozessorinstruktionen (kleinstes compiliertes Programm). Hier geht es in erster Linie um die minimale Anzahl an Operationen, die minimale Ausführungszeit, und vor allem auch um eine maximale Skalierbarkeit. Das bedeutet, dass das Programm auch dann schnell lauen soll, wenn wir die Eingabelänge erhöhen. Wir sprechen auch von der Laufzeit. Eingabelänge messen Für einen Algorithmus, der eine Liste sortiert, ist die Eingabelänge die Länge der Liste. Auch bei Strings (Texten) ergibt sich die Eingabelänge direkt aus der Länge des Textes. Für Zahlen verwenden wir als Eingabelänge analog die Anzahl der Stellen, und nicht den tatsächlichen Wert der Zahl! Im Bereich der Informatik wird diese Anzahl der Stellen binär gemessen. Das heisst: Die Eingabelänge einer Zahl ist die Anzahl der Bits. Zum Beispiel braucht die binäre Darstellung der Zahl «24» fünf Bits. «48» ist zwar doppelt so gross, braucht aber nur ein Bit mehr, nämlich sechs Bits. Big O-Notation Mit der O (Big O)-Notation drücken wir die Skalierbarkeit eines Algorithmus aus. Wir wollen also wissen, wie die Anzahl der Rechenoperationen von der Eingabelänge abhängt. Wenn die Funktion f(n) für die Eingabelänge n die Anzahl der Rechenschritte angibt, dann interessiert uns nur der «Grad» von f(x). Ist es

4 4 Effiziente Algorithmen mit Python eine lineare Funktion? Ist die Funktion quadratisch, oder sogar exponentiell? In der Informatik drücken wir das mit O(n), O(n 2 ) bzw. O(2 n ) aus. O ( g(n) ) ist die Menge aller Funktionen, die nicht schneller wachsen als g(n). Damit ist natürlich auch: O(1) O(n) O(n 2 ) O(n 3 ) O(2 n ) O(3 n ) Beispiele: 1. Prüfen, ob eine Zahl durch 2 teilbar ist, geht immer mit «einer» Operation. Wenn die letzte Ziffer gerade ist, dann ist auch die ganze Zahl gerade. Diese Aufgabe ist also in konstanter Zeit lösbar, sie hängt nicht von der Eingabelänge ab, d. h. O(1). 2. Prüfen, ob eine Zahl durch 3 teilbar ist, können wir über die Quersumme. Die Anzahl der Stellen gibt im Wesentlichen die Anzahl der Operationen an. Dieser Algorithmus arbeitet also in linearer Zeit, d. h. O(n). Ob das konkret nun bedeutet, dass wir n + 1, 2 n oder 3 n + 4 Operationen brauchen ist nicht wesentlich. Wichtig ist die Linearität. 3. Prüfen, ob eine Zahl eine Primzahl ist, können wir, indem wir jeden möglichen Teiler durchprobieren. Für eine vierstellige Zahl sind das im Wesentlichen 10 4, für eine fünfstellige Zahl 10 5 Divisionen. Es handelt sich also um einen exponentielles Algorithmus, der (binär gesehen) O(2 n ) Rechenschritte benötigt. In Python die Zeit messen Mit time.clock() lässt sich die verstrichene Zeit in Sekunden messen. Je nach System gibt clock() die Zeit seit Mitternacht, seit dem Start des Betriebssystems oder seit dem Start des Programms zurück. Weil wir uns nur für die Differenz interessieren ist der Startwert für uns aber irrelevant. 1 import time 2 t1 = time.clock() 3 # do something 4 t2 = time.clock() 5 print t2 - t1

5 Primzahl-Tests 5 2 Primzahl-Tests Problem Wir wollen möglichst schnell entscheiden, ob eine gegebene natürliche Zahl n eine Primzahl ist oder nicht. Das Problem eignet sich für den Unterricht, weil die Schüler Primzahlen bereits kennen und der naive Algorithmus simpel ist. Vor allem aber lässt sich daran sehr schön zeigen, wie eine (verständliche) algorithmische Verbesserung zu einer massiv schnelleren Lösung führt. Durchprobieren möglicher Teiler Erster Ansatz: Eine Primzahl p ist durch keine andere Zahl n mit 1 < n < p teilbar. Also prüfen wir für jede solche Zahl n, ob p ohne Rest durch n teilbar ist. 1 def primzahl(eingabe): 2 teiler = 2 3 while teiler < eingabe: 4 if eingabe % teiler == 0: 5 return False 6 teiler += 1 7 return True 8 9 if primzahl( ): 10 print "Primzahl" 11 else: 12 print "Keine Primzahl" Didaktische Schwierigkeiten: Für dieses Programm müssen die Schüler mit return umgehen können (ein schwieriges Konzept). Besonders schwierig ist auch der %-Operator: Hier lohnt es sich unter Umständen, eine Alternative zu verwenden: while teiler < eingabe: rest = eingabe % teiler if rest == 0: Oder: while teiler < eingabe: if isinteger(teiler / eingabe): Für jeden Teiler a einer Zahl z gilt, dass auch z a eine natürliche Zahl und Teiler von z ist. Dabei sind a und z a nicht beide grösser als die Wurzel von z; wenn z einen echten Teiler hat, dann hat z einen echten Teiler, der nicht grösser ist als z. Daher genügt es, nur die geraden Zahlen bis z als mögliche Teiler zu prüfen. Damit wird die Laufzeit von O(2 n ) auf O(2 n/2 ) verbessert. Der Algorithmus kann also in der selben Zeit doppelt so lange Zahlen verarbeiten.

6 6 Effiziente Algorithmen mit Python 1 def primzahl3(eingabe): 2 if eingabe!= 2 and eingabe % 2 == 0: 3 return True 4 teiler = 3 5 wurzel = sqrt(eingabe) 6 while teiler <= wurzel: 7 if eingabe % teiler == 0: 8 return False 9 teiler += 2 10 return True if primzahl3( ): 13 print "Primzahl" 14 else: 15 print "Keine Primzahl" Sieb des Eratosthenes Das Sieb des Eratosthenes ist konzeptuell einfach und löst das Problem auf einem «Umweg». Wir prüfen damit nicht direkt, ob eine Zahl eine Primzahl ist, sondern wir erzeugen eine Liste aller Primzahlen. Der Algorithmus ist zeitlich effizient (sofern wir eine Liste der Primzahlen wollen), braucht aber relativ viel Speicherplatz. 1 zahlen = [True] * # 0 und 1 sind keine Primzahlen 4 zahlen[0] = False 5 zahlen[1] = False 6 7 for i in range(2, sqrt(len(zahlen))): 8 if zahlen[i]: 9 j = i * i 10 while j < len(zahlen): 11 zahlen[j] = False 12 j += i primzahlen = [] 15 for i in indices(zahlen): 16 if zahlen[i]: 17 primzahlen.append(i) print primzahlen Verschiede Tricks können helfen, den Speicherverbrauch zu senken. Zum Beispiel ist a priori schon ersichtlich, dass nur ungerade Zahlen Primzahlen sein können (ausser der 2). Die Liste aller Zahlen müsste damit keine ungerade Zahlen enthalten. Das wird aber von der Programmierung her schwieriger.

7 Primzahl-Tests 7 Binäre Suche Die Funktion getlistofprimenumbers(n) im xprimes- Modul erzeugt mit dem Sieb des Eratosthenes eine Liste der ersten ca. n Millionen Primzahlen (genauer findet die Funktion alle Primzahlen im Bereich bis n 10 7, 1 n 25). Wir können dann prüfen, ob eine Zahl eine Primzahl ist, indem wir in der Liste nachsehen: 1 from xprimes import getlistofprimenumbers 2 primes = getlistofprimenumbers(2) 3 for x in [1, 11, 111, 1111, 11111, , ]: 4 print x, x in primes Dieses Programm läuft aber ziemlich langsam. Wenn die Liste der Primzahlen genug gross ist, dann dauert die Operation x in primes merklich etwa eine halbe Sekunde oder mehr. Das ist zu langsam! Hier lohnt es sich, mit binärer Suche zu prüfen, ob die Zahl x in der Liste L enthalten ist. 1 from xprimes import getlistofprimenumbers 2 3 def contains(l, x): 4 if L.first <= x <= L.last: 5 left, right = 0, len(l) 6 while left < right: 7 center = (left + right) // 2 8 value = L[center] 9 if x == value: 10 return True 11 if x < value: 12 right = center 13 else: 14 left = center return L[left] == x 16 else: 17 return False primes = getlistofprimenumbers(2) 20 for x in [1, 11, 111, 1111, 11111, , ]: 21 print x, contains(primes, x) Bessere Methoden Es gibt eine Reihe von sehr viel schnelleren Methoden, um zu prüfen, ob eine Zahl eine Primzahl ist. Zum Beispiel mit dem kleinen Satz von Fermat. Für jede Primzahl p und eine zu p teilfremde Basis a gilt: a p 1 1 mod p. Für eine Zahl p wählen wir eine teilerfremde Basis a und berechnen z = a p 1 mod p. Wenn z 1 ist, dann ist p garantiert keine Primzahl.

8 8 Effiziente Algorithmen mit Python Ist z = 1, so könnte z möglicherweise eine Primzahl sein (aber nicht zwingend). Dieses Verfahren erkennt zwar alle Primzahlen als prim, aber nicht alle zusammengesetzten Zahlen als zusammengesetzt. Die Idee eines probabilistischen Tests ist, dann wir zufällig verschiedene Basen a wählen und für jede solche Basis prüfen, ob a p 1 1 mod p gilt. Wenn das für alle zufälligen Basen a stimmt, dann ist p mit einer (berechnbaren) Wahrscheinlichkeit eine Primzahl. Je mehr Basen a geprüft werden, umso höher ist die Wahrscheinlichkeit. Der Algorithmus von Baillie-PSW (Baillie, Pomerance, Selfridge, Wagstaff) verwendet zwei ähnliche Verfahren, die ebenfalls einige zusammengesetzte Zahlen als Primzahlen angeben. Bis heute hat man noch keine zusammengesetzte Zahl gefunden, die von beiden Verfahren im Baillie-PSW-Algorithmus gleichzeitig als «falsche Primzahl» angegeben würde. Damit funktioniert dieser Algorithmus mindestens bis zu zuverlässig. In Python arbeitet die Funktion isprime(x) aus dem Modul primefac nach diesem Verfahren: 1 from primefac import isprime 2 3 for x in [1, 11, 111, 1111, 11111, , ]: 4 print x, isprime(x)

9 Wurzel-Berechnung 9 3 Wurzel-Berechnung Angenommen, wir wollen einen einfachen Algorithmus schreiben, der zu einer gegebenen Zahl die Quadratwurzel ausgibt. Nehmen wir der Einfachheit halber an, die Eingabe sei eine Quadratzahl. Ein naiver Ansatz testet einfach alle Kandidaten und kann folgendermassen umgesetzt werden: 1 def wurzel(eingabe): 2 kandidat = 0 3 while (kandidat*kandidat < eingabe): 4 kandidat = kandidat+1 5 return kandidat Falls wir den allgemeineren Fall betrachten, dass die Eingabe keine Quadratzahl ist, können wir den Code wie folgt verallgemeinern: 1 def wurzel_prec(eingabe,prec): 2 kandidat = i = while (i >= 1/10**prec): 5 while (kandidat*kandidat < eingabe): 6 kandidat = kandidat+i 7 if (kandidat*kandidat == eingabe): 8 return kandidat 9 else: 10 kandidat = kandidat-i 11 i = i/10 12 return kandidat print wurzel_prec(2, 4) Wie schnell ist dieses Verfahren? Gehen wir wieder von dem einfachen Fall aus, dass die Quadratzahl der Eingabe eine natürliche Zahl ist. Sei ferner die Eingabelänge wieder n und habe damit eine Grösse von ungefähr 2 n. Um die Laufzeit des Algorithmus abzuschätzen, zählen wir wieder die Schleifendurchläufe. Die Variable kandidat beginnt bei 1 und die while-schleife (des ersten Algorithmus) wird durchlaufen, bis kandidat die Grösse 2 n hat. Damit ist die Laufzeit in O( 2 n ). Verbessertes Verfahren mit binärer Suche Einfacher geht es, wenn wir uns ein Verfahren zu Nutze machen, dass wir von der Suche in sortierten Daten kennen, nämlich die binäre Suche. Anstatt die Datenliste von links nach rechts nach dem gesuchten Element zu durchsuchen, gehen wir wie folgt vor: Definiere zwei Variablen links and rechts, welche den aktuellen Suchraum festlegen

10 10 Effiziente Algorithmen mit Python Betrachte den Wert in der Mitte der Datenliste (Variable aktuell) Ist dieser der gesuchte, sind wir fertig Ist dieser zu klein, ist auch alles links von ihm zu klein Dann setzen wir links = aktuell + 1 Ist dieser zu gross, ist auch alles rechts von ihm zu gross Dann setzen wir rechts = aktuell Diese Idee führt zu folgendem Algorithmus: 1 def bin_suche(eingabe,gesucht): 2 left = 0 3 right = len(eingabe) 4 while left < right: 5 current = (left + right) // 2 6 if eingabe[current] == gesucht: 7 return current 8 elif eingabe[current] < gesucht: 9 left = current else: 11 right = current 12 return None print bin_suche([3,5,7,9,11,14,16,19,22,35,37], 19) Für das Wurzelziehen einer Quadratzahl können wir die binäre Suche nun auf den Zahlenraum von 1 bis eingabe anwenden. Dieser definiert dann unseren Suchraum, also alle möglichen Kandidaten. In Python können wir diese Idee wie folgt umsetzen: 1 def wurzel2(eingabe): 2 left = 0 3 right = eingabe 4 while left < right: 5 test = (left + right) // 2 6 if test**2 == eingabe: 7 return test 8 elif test**2 < eingabe: 9 left = test else: 11 right = test print wurzel2(36) Es überrascht nicht, dass dieser Ansatz die Laufzeit exponentiell verbessert. Jedes Mal, wenn die Wurzel nicht gefunden wurde, wird der Suchraum halbiert. Am Anfang gibt es ungefähr eingabe = 2 n Kandidaten, nach dem ersten Test gibt es 2 n /2 = 2 n 1 Kandidaten, nach

11 Wurzel-Berechnung ,000 Schleifendurchläufe 400, , , ,000 0 Verbessertes Verfahren (wurzel2) Naiver Ansatz (wurzel) Eingabelänge n Abbildung 1: Die beiden Algorithmen zum Wurzelziehen dem zweiten Test gibt es 2 n 1 /2 = 2 n /4 = 2 n 2 Kandidaten, nach dem dritten Test gibt es noch 2 n 2 /2 = 2 n /8 = 2 n 3 Kandidaten usw. Wie viele Iterationen x sind nötig, bis nur noch eine Zahl übrig bleibt? In anderen Worten muss x 2 n /2 x = 1 x = n erfüllen und somit ist die Anzahl von Schleifendurchläufen in O(n). Die beiden Laufzeiten sind in Abb. 1 dargestellt. Dieses Beispiel eignet sich gut, um eine nicht ganz offensichtliche Anwendung der binären Suche zu zeigen. Für den Fall, dass das algorithmische Wurzelziehen genauer untersucht werden soll, wäre es als nächstes z.b. möglich, das Heron-Verfahren vorzustellen.

12 12 Effiziente Algorithmen mit Python 4 Exponentiation Für eine feste Zahl a wollen wir die Potenz a n berechnen, wobei n N. Wenn wir den naiven Ansatz verwenden (wir multiplizieren die Basis a n Mal mit sich selbst), dann dauert das für grosse n relativ lange. 1 def exponenzieren(a, eingabe): 2 i = 1 3 ausgabe = 1 4 while i <= eingabe: 5 ausgabe *= a 6 i += 1 7 return ausgabe 8 9 print exponenzieren(3, 4) Eine deutliche Verbesserung wird hier erzielt, wenn wir a jeweils quadrieren. Zum Beispiel ist: ( ((a a 16 2 = ) ) ) Das sind nur vier Multiplikationen anstatt 16. Wenn der Exponent n keine Zweierpotenz ist, dann zerlegen wir n in Zweierpotenzen: a 23 = a = a 16 a 4 a 2 a Im Programm arbeiten wir von der kleinsten Stelle der Eingabe her. Wir prüfen jeweils, ob das letzte Bit gesetzt ist (die Eingabe ist dann ungerade). Wenn ja, dann multiplizieren wir das Resultat mit a k. Anschliessend entfernen wir das letzte Bit über eine Division durch zwei. 1 def exponenzieren3(a, eingabe): 2 ausgabe = 1 3 power = a 4 while eingabe!= 0: 5 if eingabe % 2 == 1: 6 ausgabe *= power 7 eingabe //= 2 8 power **= 2 9 return ausgabe print exponenzieren3(2, 10)