Auf einen Blick - Wiley-VCH
Werbung
Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc.3d from 03.08.2017 10:00:40 3B2 9.1.580; Page size: 176.00mm x 240.00mm Auf einen Blick Über die Autoren ....................................................... 11 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Teil I: Erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Kapitel 1: Kapitel 2: Kapitel 3: Kapitel 4: Kapitel 5: Grundlegendes über Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Algorithmendesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Mit Python Algorithmen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Algorithmen mit Python programmieren: Grundlagen . . . . . . . . . . . . . . . . . . 85 Grundlagen der Datenbearbeitung mit Python. . . . . . . . . . . . . . . . . . . . . . . . . 107 Teil II: Die Notwendigkeit des Suchens und Sortierens . . . . . . . . . 127 Kapitel 6: Kapitel 7: Daten strukturieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Daten ordnen und durchsuchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 Teil III: Die Welt der Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Kapitel 8: Kapitel 9: Kapitel 10: Kapitel 11: Die Grundlagen von Graphen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Punkte verbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Geheimnisse der Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die richtige Webseite finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 183 207 217 Teil IV: Der Kampf mit Big Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 Kapitel 12: Big Data verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Kapitel 13: Abläufe parallelisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 Kapitel 14: Daten komprimieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Teil V: Komplexe Aufgaben angehen Kapitel 15: Kapitel 16: Kapitel 17: Kapitel 18: Kapitel 19: Kapitel 20: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Mit gierigen Algorithmen arbeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dynamische Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Randomisierte Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lokale Suchen durchführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lineare Optimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Heuristiken untersuchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 301 323 339 355 367 Teil VI: Zehn große Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 Kapitel 21: Zehn algorithmische Verfahren, die die Welt verändern . . . . . . . . . . . . . . . . . 385 Kapitel 22: Zehn bislang ungelöste Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc.3d from 03.08.2017 10:00:40 3B2 9.1.580; Page size: 176.00mm x 240.00mm Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:54 3B2 9.1.580; Page size: 176.00mm x 240.00mm Inhaltsverzeichnis Über die Autoren ....................................................... 11 John Muellers Widmung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Luca Massarons Widmung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . John Muellers Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Luca Massarons Danksagung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 11 12 12 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Über dieses Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konventionen in diesem Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Törichte Annahmen über den Leser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Symbole, die in diesem Buch verwendet werden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie es weitergeht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TEIL I ERSTE SCHRITTE ......................................................... Kapitel 1 Grundlegendes über Algorithmen 25 26 26 27 28 31 .................................. 31 Algorithmen beschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definitionen zur Anwendung von Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithmen sind überall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Computern Aufgaben lösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Moderne CPUs und GPUs wirksam einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . Arbeiten mit Spezialchips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Netzwerke wirksam einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten effektiv nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwischen Aufgaben und Lösungen unterscheiden. . . . . . . . . . . . . . . . . . . . . . . . . . . . Richtigkeit und Effizienz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Erkenntnis, dass nichts umsonst ist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Strategie an die Aufgabe anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithmen in einer Lingua franca beschreiben . . . . . . . . . . . . . . . . . . . . . . . . Schwierige Aufgaben angehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten für Lösungen strukturieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Sichtweise eines Computers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenordnung muss sein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 33 36 37 37 38 39 39 40 40 41 41 41 42 42 42 43 Kapitel 2 Algorithmendesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Der Anfang der Problemlösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Praxisaufgaben modellieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 46 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:54 3B2 9.1.580; Page size: 176.00mm x 240.00mm 16 Inhaltsverzeichnis Lösungen und Gegenbeispiele finden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Auf den Schultern von Riesen stehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Teile und herrsche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Brute-Force-Lösungen vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erster Schritt: Vereinfachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Reduktion ist meist vorteilhaft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erkennen, dass Gier gut sein kann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gierig denken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine gute Lösung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kostenberechnungen und Heuristiken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Problem in einem Raum darstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zufällig und von Glück gesegnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Heuristiken und Kostenfunktionen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . Algorithmen auswerten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Simulationen mittels abstrakter Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Weitere Abstrahierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Funktionen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 49 49 50 51 51 52 52 53 54 54 55 55 56 57 58 59 Kapitel 3 Mit Python Algorithmen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Die Vorteile von Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie Python in diesem Buch verwendet wird . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit MATLAB arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Andere Testumgebungen für Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python-Distributionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Analytics Anaconda installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enthought Canopy Express . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python(x,y) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . WinPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python auf Linux installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python auf MacOS installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python auf Windows installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datensätze und Beispielcode herunterladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Jupyter Notebook benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Coderepository definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Datensätze in diesem Buch verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 65 66 67 67 68 69 69 69 70 71 72 76 76 77 83 Kapitel 4 Algorithmen mit Python programmieren: Grundlagen . . . . . . . . . 85 Mit Zahlen und Logik arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variablenzuordnungen vornehmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Berechnungen durchführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenvergleich durch boolesche Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . Strings erstellen und verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Datumsangaben arbeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funktionen erstellen und verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 87 88 89 91 92 93 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:54 3B2 9.1.580; Page size: 176.00mm x 240.00mm Inhaltsverzeichnis 17 Mehrfach aufrufbare Funktionen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funktionen aufrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bedingte Anweisungen und Schleifen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entscheidungen mittels if-Befehl treffen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mittels verschachtelter Entscheidungen zwischen mehreren Möglichkeiten auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Iterative Aufgaben mittels for-Schleife ausführen . . . . . . . . . . . . . . . . . . . . . . . Der while-Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten in Mengen, Katalogen und Tupeln speichern . . . . . . . . . . . . . . . . . . . . . . . . . . Datasets erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Listen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tupel erstellen und verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nützliche Iteratoren definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten mittels Dictionaries indizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 94 97 97 98 99 100 101 101 102 103 104 105 Kapitel 5 Grundlagen der Datenbearbeitung mit Python . . . . . . . . . . . . . . . . . . 107 Berechnungen mit Vektoren und Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variablen- und Vektoroperationen verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . Vektoren multiplizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der erste Schritt: Matrizen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Matrizen multiplizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erweiterte Matrizenoperationen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der richtige Weg: Kombinationen erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Permutationen unterscheiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kombinationen erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wiederholungen behandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ergebnisse mit Rekursion erzielen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Funktionsweise der Rekursion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Endrekursionen entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Prozesse schneller ausführen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der »teile und herrsche«-Ansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwischen möglichen Lösungen unterscheiden . . . . . . . . . . . . . . . . . . . . . . . . . . 108 108 110 111 112 114 115 116 117 118 118 118 121 122 122 125 TEIL II DIE NOTWENDIGKEIT DES SUCHENS UND SORTIERENS . . . . . . . . . . 127 Kapitel 6 Daten strukturieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Die Notwendigkeit einer Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhalt vereinfacht darstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten aus verschiedenen Quellen anpassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Wichtigkeit der Datenbereinigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten gestapelt und kumuliert anordnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stapelweise Anordnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 130 131 132 134 135 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:54 3B2 9.1.580; Page size: 176.00mm x 240.00mm 18 Inhaltsverzeichnis Warteschlangen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten mittels assoziativen Datenfeldern finden . . . . . . . . . . . . . . . . . . . . . . . . . Mit Bäumen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grundlegendes über Bäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bäume erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Relationen in Graphen darstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Über Bäume hinauswachsen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kapitel 7 Daten ordnen und durchsuchen 136 137 138 139 139 141 142 143 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 Daten mit Mergesort und Quicksort sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Notwendigkeit des Sortierens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten naiv anordnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bessere Sortiertechniken einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Suchbäume und Heaps verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Notwendigkeit einer effizienten Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Binäre Suchbäume erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spezialisierte Suchen mit einem binären Heap. . . . . . . . . . . . . . . . . . . . . . . . . . Hashing verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Alles in Buckets füllen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kollisionen vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hashfunktionen selbst erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 146 147 149 153 154 156 157 158 158 160 161 TEIL III DIE WELT DER GRAPHEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Kapitel 8 Die Grundlagen von Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Die Wichtigkeit von Netzwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grundlegendes über Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen sind überall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die soziale Seite eines Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Teilgraphen verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definitionen für das Zeichnen von Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die wichtigsten Eigenschaften von Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen zeichnen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Funktionalität eines Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kanten und Knoten zählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zentralität berechnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen in ein numerisches Format bringen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen zu einer Matrix hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dünn besetzte Matrizen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen durch Listen ausdrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 168 170 171 172 172 173 174 175 176 178 180 181 182 182 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:55 3B2 9.1.580; Page size: 176.00mm x 240.00mm Inhaltsverzeichnis Kapitel 9 Punkte verbinden 19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 Graphen effizient durchsuchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einen Graphen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Breitensuche anwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tiefensuche anwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Entscheidung für eine Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Elemente eines Graphen sortieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit gerichteten azyklischen Graphen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . Topologische Sortierungen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Reduktion auf einen minimalen Spannbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Geeignete Algorithmen verwenden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vorrangwarteschlangen kennenlernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Algorithmus von Prim einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Algorithmus von Kruskal testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entscheiden, welcher Algorithmus am besten passt . . . . . . . . . . . . . . . . . . . . . Den kürzesten Weg finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definieren, was der kürzeste Weg ist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Dijkstra-Algorithmus: eine Erklärung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 184 186 187 189 189 190 191 192 195 195 196 198 200 201 201 203 Kapitel 10 Die Geheimnisse der Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Soziale Netzwerke als Graphen betrachten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Netzwerke in Gruppen clustern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Communitys entdecken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einen Graphen durchlaufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grade der Trennung abzählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphen zufällig durchlaufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 208 210 213 213 215 Kapitel 11 Die richtige Webseite finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 Die Welt in einer Suchmaschine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datensuche im Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die richtigen Daten finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Funktionsweise des PageRank-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Logik hinter dem PageRank-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . Das A und O von PageRank. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PageRank implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pythonskripte implementieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Kampf mit naiven Implementierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Langeweile und Teleportation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Leben einer Suchmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Andere Verwendungsmöglichkeiten von PageRank . . . . . . . . . . . . . . . . . . . . . . Über das PageRank-Paradigma hinaus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Semantisches Suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ranking von Suchergebnissen mit künstlicher Intelligenz. . . . . . . . . . . . . . . . . 218 218 218 219 220 221 222 222 225 228 229 230 230 231 231 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:55 3B2 9.1.580; Page size: 176.00mm x 240.00mm 20 Inhaltsverzeichnis TEIL IV DER KAMPF MIT BIG DATA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 Kapitel 12 Big Data verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Die Umwandlung von Strom in Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Auswirkungen von Moore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten sind überall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithmen ins Geschäft bringen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenflüsse streamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Streams korrekt analysieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die richtigen Daten auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lösungen aus Stream-Daten skizzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenstromelemente filtern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bloomfilter darstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Anzahl der Elemente bestimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Elemente eines Streams abzählen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 236 238 240 242 243 244 248 248 251 254 256 Kapitel 13 Abläufe parallelisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 Die Handhabung großer Datenmengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die parallele Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateien und Vorgänge verteilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lösungen mit MapReduce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operationen verteilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithmen für MapReduce erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MapReduce-Simulationen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anfragen durch Mapping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kapitel 14 Daten komprimieren 258 258 260 262 264 265 266 268 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 Daten reduzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codierungen verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Folgen der Kompression. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Entscheidung für eine Kompressionsart . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Wahl einer vernünftigen Codierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codieren mit der Huffman-Kompression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Folgen merken mit dem LZW-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 272 273 275 276 279 280 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:55 3B2 9.1.580; Page size: 176.00mm x 240.00mm Inhaltsverzeichnis TEIL V KOMPLEXE AUFGABEN ANGEHEN 21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Kapitel 15 Mit gierigen Algorithmen arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Die Entscheidung, wann Gier Sinn macht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Vorteile der Gier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gierige Algorithmen im Zaum halten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . NP-vollständige Probleme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Herausfinden, wieso Gier nützlich ist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten im Cache anordnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Kampf um Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Noch mal zu Huffman-Codierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 289 290 292 293 294 295 297 Kapitel 16 Dynamische Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 Dynamische Programmierung – was ist das? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die historische Grundlage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Probleme dynamisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rekursion dynamisch auslegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Memoisation verwenden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die besten dynamischen Techniken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Rucksack packen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Städte bereisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Näherungsweise nach Strings suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 302 303 304 307 309 309 313 317 Kapitel 17 Randomisierte Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323 Die Funktionsweise der Randomisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Notwendigkeit der Randomisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Wahrscheinlichkeitsprinzip verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verteilungen verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Monte-Carlo-Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Zufall in die Logik einbauen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Median durch Quickselect bestimmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Monte-Carlo-Simulationen ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schneller sortieren mit Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 324 325 326 329 331 332 334 337 Kapitel 18 Lokale Suchen durchführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 Lokale Suchen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Nachbarschaft kennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tricks bei der lokalen Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bergsteigen und das Damenproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340 340 342 343 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:56 3B2 9.1.580; Page size: 176.00mm x 240.00mm 22 Inhaltsverzeichnis Die Funktionsweise des Simulated Annealing . . . . . . . . . . . . . . . . . . . . . . . . . . . Wiederholungen durch die Tabu-Suche vermeiden . . . . . . . . . . . . . . . . . . . . . . Die Erfüllbarkeit boolescher Schaltkreise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-SAT mittels Randomisierungen lösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Code-Implementierung in Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Wichtigkeit des Anfangspunkts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346 347 348 349 350 353 Kapitel 19 Lineare Optimierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 Lineare Funktionen – ein Werkzeug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die mathematischen Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Während des Planens vereinfachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Simplex-Verfahren geometrisch bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . Die Grenzen der linearen Optimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lineare Optimierung in der Praxis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PuLP auf dem eigenen Computer installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . Produktionsvorgänge und Einnahmen optimieren . . . . . . . . . . . . . . . . . . . . . . 356 357 358 359 361 361 362 362 Kapitel 20 Heuristiken untersuchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 Unterschiedliche Heuristiken kennenlernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Ziele heuristischer Verfahren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Von genetisch zu künstlich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Heuristische Routensuche bei Robotern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Unbekannte Gebiete erkunden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entfernungsmessungen als Heuristiken verwenden . . . . . . . . . . . . . . . . . . . . . Pathfinding-Algorithmen verstehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einen Irrgarten erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Suche nach dem besten Weg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Heuristische Bewegungen mit A* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 368 369 370 370 372 373 373 376 379 TEIL VI ZEHN GROSSE ALGORITHMEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 Kapitel 21 Zehn algorithmische Verfahren, die die Welt verändern . . . . . . . 385 Sortierverfahren einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Suchen durchführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Zufallszahlen eine neue Ordnung herstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenkompressionen vornehmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Geheimhaltung von Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenbereiche ändern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenhänge erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Muster in Daten erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Automatisierung und automatischen Antworten arbeiten . . . . . . . . . . . . . . . . . Eindeutige Identifizierungen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 386 386 387 387 388 388 389 390 390 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:56 3B2 9.1.580; Page size: 176.00mm x 240.00mm Inhaltsverzeichnis 23 Kapitel 22 Zehn bislang ungelöste Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 Textsuchen bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wörter unterscheiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Herausfinden, wann eine Anwendung anhält . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einwegfunktionen erstellen und verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Multiplikation großer Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Gleichverteilung von Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Berechnungszeit der Editierdistanz reduzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . Aufgaben schnell lösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Paritätsspiel spielen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Räumliche Aufgabenstellungen verstehen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stichwortverzeichnis 392 392 392 393 393 394 394 395 395 395 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Reemers Publishing Services GmbH O:/Wiley/Reihe_Dummies/71381_Mueller/3d/ftoc2.3d from 03.08.2017 10:00:56 3B2 9.1.580; Page size: 176.00mm x 240.00mm