Bevor Sie sich mit den Problemen befassen, schauen Sie sich die Vorlesungen 7-8 an, lesen Sie die „ Zusätzlichen Materialien der dritten Woche “ und vertiefen Sie sich in sie. Sie widmen sich Suchalgorithmen (linear und binär), Sortierung (davon gibt es viele!), sowie der Arbeit eines Debuggers (die Fähigkeit, mit einem Debugger zum Debuggen von Programmen zu arbeiten, ist eine äußerst wichtige Fähigkeit!). Wenn bei den Vorlesungen und der Theorie alles so gelaufen ist, wie es sollte, können Sie die Testfragen ganz einfach beantworten:
Warum erfordert die binäre Suche ein sortiertes Array?
Warum wird die Blasensortierung auf O(n2) geschätzt?
Warum ist die Einfügungssortierungsschätzung Ω(n)?
Wie funktioniert die Auswahlsortierung? Beschreiben Sie in drei Sätzen (oder weniger).
Was ist die Obergrenze (im schlimmsten Fall), wie lange die Zusammenführungssortierung ausgeführt werden kann?
Mit dem GDB-Debugger können Sie ein Programm debuggen. Und wenn Sie es konkreter formulieren: Was genau ermöglicht es Ihnen?
Ziele
Erfahren Sie, wie Sie mit Projekten arbeiten, die mehrere Dateien enthalten
Lernen Sie, den Quellcode einer anderen Person zu lesen
Verstehen Sie verschiedene Algorithmen und rekursive Funktionen
Die meisten dieser Ziele lassen sich praktisch nicht formal bewerten. Unter dem Gesichtspunkt der formalen Überprüfung von Problemen gibt es daher wenig, was Ihnen schwierig erscheint. Wir erinnern Sie jedoch daran: Programmieren kann man nur durch ständiges Üben erlernen! Daher ermutigen wir Sie, nicht nur die Aufgaben zu lösen, sondern auch zusätzliche Zeit und Mühe aufzuwenden und alle Algorithmen, die diese Woche besprochen wurden, zu implementieren. Nach vorne!
Beginnen
Denken Sie daran, dass Sie für die Übungsaufgaben in den Wochen eins und zwei Programme von Grund auf neu geschrieben und mit dem Befehl mkdir Ihre eigenen pset1- und pset2- Verzeichnisse erstellt haben . Für die Übungsaufgabe der dritten Woche müssen Sie die von uns geschriebene Distribution (oder „Distribution“, wie wir sie nennen) herunterladen und Ihre eigenen Codezeilen hinzufügen. Lesen Sie zunächst unseren Code und versuchen Sie, ihn zu verstehen. Die wichtigste Fähigkeit dieser Woche besteht darin, zu lernen, wie man den Code anderer Leute liest. Melden Sie sich also bei cs50.io an und führen Sie den Befehl in einem Terminalfenster aus, um sicherzustellen, dass die Workspace-Version auf dem neuesten Stand ist. Wenn Sie das Terminalfenster versehentlich geschlossen haben und es nicht finden können, gehen Sie zum Menü „Ansicht “ und stellen Sie sicher, dass die Option „Konsole“ aktiviert ist (aktivieren Sie sie, wenn dies nicht der Fall ist). Klicken Sie auf (+), wählen Sie innerhalb des grünen Kreises im Rahmen des Terminalfensters „Neues Terminal“ aus . Führen Sie anschließend den Befehl aus und stellen Sie sicher, dass Sie sich im Arbeitsbereichsverzeichnis befinden (dies ist Ihr Verzeichnis). Führen Sie anschließend den Befehl aus, um das ZIP-Archiv des Problembuchs in Ihren Arbeitsbereich herunterzuladen (wget ist der Linux-Download-Befehl). Wenn alles in Ordnung ist, sehen Sie in der Zeile den folgenden Satz: Stellen Sie sicher, dass Sie pset3.zip wirklich heruntergeladen haben , indem Sie den Befehl ausführen: und dann ausführen , um die Datei zu entpacken. Wenn Sie nun den Befehl ls erneut ausführen , sehen Sie auch das Verzeichnis pset3 . Gehen Sie dorthin, indem Sie den Befehl ausführen und dann erneut die Anzeige des Inhalts des Verzeichnisses anfordern: Sie werden sehen, dass es in diesem Verzeichnis zwei Unterverzeichnisse gibt: Schon interessant! update50cd ~/workspacewget http://cdn.cs50.net/2015/fall/psets/3/pset3/pset3.zip'pset3.zip' savedlsunzip pset3.zipcd pset3lsfifteen find
Suchen
Lassen Sie uns nun in eines dieser Unterverzeichnisse eintauchen. Dazu führen wir den Befehl aus: cd ~/workspace/pset3/find Wenn Sie den Inhalt dieses Ordners auf dem Bildschirm anzeigen (Sie wissen wahrscheinlich bereits, wie das geht), sollten Sie Folgendes sehen: Wow helpers.c helpers.h Makefile find.c generate.c , da sind viele Dateien. Aber keine Sorge, wir kümmern uns jetzt darum. Die Datei „generate.c“ enthält Code für ein Programm, das einen „Pseudozufallszahlengenerator“ (erzeugt durch die Funktion drand48 ) verwendet, um eine große Anzahl von Zufallszahlen (eigentlich Pseudozufallszahlen, Computer können mit reiner Zufälligkeit nicht umgehen!) zu generieren , und platzieren Sie sie einzeln in der Zeile. Kompilieren Sie das Programm: make generate Führen Sie es nun aus, indem Sie den Befehl ausführen: ./generate Das Programm gibt Ihnen die folgende Meldung: Usage: generate n [s] Dies bedeutet, dass das Programm ein oder zwei Befehlszeilenargumente erwartet. Verwenden Sie das erste, n ist obligatorisch; diese Zahl gibt an, wie viele Pseudozufallszahlen Sie erstellen möchten. Der Parameter s ist optional, wie durch die eckigen Klammern angegeben. Die Zahl s kann als „Startwert“ für den Pseudozufallszahlengenerator bezeichnet werden. Mit „Startwert“ Wir meinen die Eingabedaten für den Pseudozufallszahlengenerator, die sich auf dessen Ausgabe auswirken. Wenn Sie beispielsweise drand48 verwenden, rufen Sie zunächst srand48 (eine andere Funktion, deren Zweck es ist, drand48 zu „säen“) mit einem Argument von beispielsweise 1 auf und Wenn Sie dann drand48 dreimal aufrufen, könnte drand48 2728, dann 29785 und dann 54710 zurückgeben. Wenn Sie anstelle des vorherigen Aufrufs mit drand48 zuerst srand48 mit einem Argument von beispielsweise 2 aufrufen und dann drand48 erneut dreimal verwenden, könnte drand48 dies tun Geben Sie 59797, dann 10425 und dann 37569 zurück. Wenn Sie jedoch drand48 erneut sehen, indem Sie srand48 erneut mit dem Argument 1 aufrufen, erhalten Sie als Ergebnis der nächsten drei Aufrufe von drand48 erneut 2728, dann 29785 und dann 54710! Sie sehen, alles geschieht aus einem Grund. Führen Sie das Programm erneut aus, dieses Mal sagen wir n=10, wie unten gezeigt; Sie sehen eine Liste mit 10 Pseudozufallszahlen. ./generate 10 Lassen Sie uns das Programm ein drittes Mal mit demselben Wert von n ausführen. Sie sollten eine weitere Liste mit 10 Nummern sehen. Versuchen Sie nun, das Programm mit zwei Parametern auszuführen. Nehmen wir s=0 wie unten gezeigt. ./generate 10 0 Führen Sie nun denselben Befehl noch einmal aus: ./generate 10 0 Sie können nicht einmal argumentieren: Sie haben wieder dieselbe „zufällige“ Folge von zehn Ziffern gesehen. Dies geschieht, wenn Sie die Seeds des Pseudozufallszahlengenerators nicht ändern. Schauen wir uns nun das Programm „generate.c“ selbst an(erinnern Sie sich wie?). Die Kommentare am Anfang dieser Datei erläutern die allgemeine Funktionalität des Programms. Aber wir scheinen vergessen zu haben, den Code selbst zu kommentieren. Lesen Sie den Code sorgfältig durch und lesen Sie ihn, bis Sie die Bedeutung jeder Zeile verstanden haben. Kommentieren Sie dann diesen Code für uns aus und ersetzen Sie jedes TODO durch einen Satz, der den Zweck oder die Funktionalität der entsprechenden Codezeile(n) beschreibt. (Hinweis: unsigned int ist ein „unsigned“ int, was bedeutet, dass es nicht negativ sein kann). Um weitere Informationen zu rand oder srand zu erhalten, führen Sie Folgendes aus: man drand48 oder man srand48 Nachdem Sie so viel wie möglich in „generate.c“ auskommentiert haben, kompilieren Sie das Programm neu, um sicherzustellen, dass nichts kaputt gegangen ist: make generate Wenn „generate“ nicht mehr kompiliert werden kann, beheben Sie das Problem Pleite: )! Zur Erinnerung: Der Befehl „make“ automatisiert die Codekompilierung, sodass Sie den Befehl „clang“ nicht ausführen müssen, indem Sie manuell eine Reihe von Schaltern einfügen. Tatsächlich vereinfacht make jedoch lediglich unsere Eingabe, tatsächlich verbirgt sich jedoch derselbe Klang mit den Parametern, die wir benötigen. Wenn Ihre Programme jedoch größer werden, kann make aus dem Kontext nicht mehr herausfinden, wie der Code kompiliert wird. In diesem Fall müssen Sie make mitteilen, wie die Programme kompiliert werden sollen, insbesondere wenn dabei unterschiedliche Quelldateien (z. B. .c) verwendet werden. Um dieses Problem zu lösen, verwenden wir Konfigurationsdateien (Makefiles), die make genau sagen, was zu tun ist. Woher wusste der Befehl „make“, wie wir „generieren“ kompilieren sollten? Tatsächlich verwendete das Team eine Konfigurationsdatei, die wir bereits geschrieben hatten. Diese Datei heißt Makefile und befindet sich im selben Verzeichnis wie generic.c . Makefile ist eine Liste von Regeln, die festlegen, wie die Datei generiert wird, die aus „generate.c“ generiert wird. In der Datei finden Sie insbesondere die entsprechenden Zeilen: generate: generate.c clang -ggdb3 -O0 -std=c11 -Wall -Werror -o generate generate.c Die erste Zeile teilt make mit, dass durch den Aufruf des Befehls aus der zweiten Zeile ein „Ziel“ namens „generate“ erstellt werden soll. Darüber hinaus teilt die erste Zeile make mit, dass „generate“ von „generate.c“ abhängt, was bedeutet, dass „make“ „generate“ bei nachfolgenden Durchläufen nur dann neu erstellt, wenn diese Datei geändert wurde. Kein schlechter zeitsparender Trick, oder? Führen Sie den folgenden Befehl sogar noch einmal aus, wenn Sie „generate.c“ nicht geändert haben . make generate Sie werden darüber informiert, dass Generate bereits auf die aktuelle Version aktualisiert wurde. Hinweis : Der Einzug am Anfang der zweiten Zeile ist keine Folge von Leerzeichen, sondern ein Tabulatorzeichen. Unglücklicherweise erfordert make, dass Befehlen Tabulatoren vorangestellt werden müssen. Achten Sie also darauf, diese nicht in Leerzeichen umzuwandeln, da sonst seltsame Fehler auftreten! Das Flag -Werror teilt dem Clang- Befehl mitBehandeln Sie Warnungen (schlecht) als Fehler (noch schlimmer), sodass Sie (auf eine gute, lehrreiche Art!) gezwungen werden, sie zu korrigieren. Schauen wir uns nun die Datei find.c an . Beachten Sie, dass dieses Programm ein Befehlszeilenargument erwartet: „igloo“, das in einem „Heuhaufen“ von Werten gefunden werden muss. Überprüfen Sie anschließend den Code und kompilieren Sie das Programm, indem Sie den folgenden Befehl ausführen. make find make hat uns grundsätzlich folgendes mitgeteilt: clang -ggdb3 -O0 -std=c11 -Wall -Werror -o find find.c helpers.c -lcs50 -lm Passt auf! Sie haben gerade eine Anwendung kompiliert, die aus einer, aber zwei Dateien besteht: helpers.c und find.c . Wie haben Sie davon erfahren? Um dies zu verstehen, öffnen Sie das Makefile erneut, um zu sehen, was dort wirklich vor sich geht. Die relevanten Zeilen finden Sie weiter unten. find: find.c helpers.c helpers.h clang -ggdb3 -O0 -std=c11 -Wall -Werror -o find find.c helpers.c -lcs50 -lm Was wir mit Abhängigkeit (nach dem Doppelpunkt) meinen, ist, dass alle Änderungen an find.c , helpers.c oder helpers.h dazu führen, dass make neu erstellt wird, wenn find das nächste Mal für diese Zwecke aufgerufen wird. Führen Sie nun dieses Programm aus, indem Sie beispielsweise Folgendes tun: ./find 13 Danach werden Sie aufgefordert, einen bestimmten Stapel (d. h. ganze Zahlen) bereitzustellen und ihnen einen Strohhalm nach dem anderen zuzuführen. Wenn Sie keine Lust mehr haben, Zahlen einzugeben, drücken Sie die Tastenkombination Strg-D . Diese Kombination sendet dem Programm ein EOF-Zeichen (End-of-File). Das Symbol zwingt die GetInt- Funktion aus der CS50-Bibliothek, die Konstante INT_MAX zurückzugeben , was wiederum in find.c dazu führt, dass find die Eingabe von „stack“ stoppt. Das Programm sucht nun im von Ihnen bereitgestellten Heuhaufen nach der Nadel und teilt Ihnen schließlich mit, ob sie gefunden wurde. Kurz gesagt, das Programm sucht nach einem Wert in einem Array. Zumindest sollte sie das tun, aber der Haken ist, dass sie noch nichts finden wird! Aber hier kommen Sie zur Rettung! Wir werden etwas später über die Bedeutung Ihrer Rolle sprechen. Tatsächlich kann der Prozess der Bereitstellung eines Heuhaufens automatisiert werden, zumindest indem die Ausgabe von „generate“ mit „find“ als Eingabe „zusammengeführt“ wird. Der folgende Befehl übergibt beispielsweise 1000 Pseudozufallszahlen an „find“, die dann in diesen Werten nach 42 suchen. ./generate 1000 | ./find 42 Beachten Sie, dass Sie beim Übergeben der Rohdaten durch „generate“ an „find“ nicht die generierte Zahl, sondern „find“ sehen . Alternativ können Sie die Ausgabe von „generate“ mit einem Befehl wie diesem in eine Datei „umleiten“: ./generate 1000 > numbers.txt Der Inhalt dieser Datei kann mit dem folgenden Befehl zur Eingabe von „find“ umgeleitet werden: ./find 42 < numbers.txt Schauen wir uns den Code im Makefile noch einmal an und beachten Sie das Folgende Zeile: all: find generate Dies bedeutet, dass Sie Build generieren und finden können, indem Sie den folgenden Befehl ausführen: make all Darüber hinaus entspricht der Befehl unter dieser Zeile dem darüber liegenden Befehl, da make standardmäßig den ersten Eintrag im Makefile erstellt. make Wenn Sie nur all diese Übungsaufgaben auf einen Befehl zusammenfassen könnten! Aber – leider! Achten Sie abschließend auf diese letzten Zeilen im Makefile: clean: rm -f *.o a.out core find generate Mit diesem Eintrag können Sie alle Dateien entfernen, die auf .o enden oder als core bezeichnet werden (das erklären wir gleich!), und auch die Such- oder Generierungsprogramme einfach ausführen indem Sie die Zeile ausführen: Wenn Sie experimentieren möchten make clean , sollten Sie Folgendes beachten: Fügen Sie beispielsweise nicht *.c zur letzten Zeile des Makefiles hinzu! (Warum?) Alle Zeilen, die mit dem #-Zeichen beginnen, sind nur Kommentare.
Aufgabe 1: Suchen
Es ist Zeit für etwas Interessantes! Beachten Sie, dass find.c search aufruft , eine in helpers.h deklarierte Funktion . Leider haben wir vergessen, diese Funktion komplett in helpers.c zu implementieren ! (Es sollte beachtet werden, dass wir den Inhalt von helpers.h und helpers.c in einer find.c zusammenfassen könnten . Manchmal ist es jedoch besser, Programme in mehrere Dateien aufzuteilen. Vor allem, wenn einige Funktionen, oder besser gesagt Hilfsfunktionen, nützlich sein könnten für andere Programme. Wie zum Beispiel die CS50-Bibliotheksfunktionen. Werfen Sie einen Blick auf helpers.c und Sie werden sehen, dass die Suche immer false zurückgibt, unabhängig davon, ob der angegebene Wert in Werten vorliegt. Schreiben Sie die Suche so um, dass sie die lineare Suche verwendet und true zurückgibt , wenn der Wert in Werten vorliegt, und falsch, wenn der Wert nicht in Werten vorliegt. Achten Sie darauf, sofort false zurückzugeben, wenn n nicht positiv ist. Wenn Sie bereit sind, die Gültigkeit zu überprüfen, rufen Sie den folgenden Befehl auf: Da eine der Zahlen gedruckt ./generate 1000 50 | ./find 127 wurde Wenn „Generieren, als 50 gesetzt wurde“ 127 ist, sollte Ihr Code die Nadel finden! Versuchen Sie als Kontrast diesen Befehl: ./generate 1000 50 | ./find 128 Da 128 nicht zu der Menge von Zahlen gehört, die von „Generieren, als 50 gesetzt wurde“, muss Ihr Code die „Nadel“ nicht finden. . Führen Sie weitere Tests durch, indem Sie „generate“ mit etwas Startwert ausführen, die Ausgabe analysieren und nach der Nadel suchen, die im Heuhaufen sein sollte. Beachten Sie, dass main in find.c so geschrieben ist, dass find 0 zurückgibt, wenn die „Nadel“ gefunden wird, andernfalls 1. Sie können den sogenannten „Ausgabecode“ überprüfen, den main zurückgibt, wenn es ausgeführt wird, nachdem eine andere ausgeführt wurde Befehle echo $? . Wenn Ihre Suchimplementierung beispielsweise korrekt ist und Sie sie ausführen, ./generate 1000 50 | ./find 127 echo $? wird 0 angezeigt, während 127 zu den 1000 von „generate“ ausgegebenen Zahlen mit einem Startwert von 50 gehört. Die von Ihnen geschriebene Suche sollte also „true“ zurückgeben. In diesem Fall sollte main (von uns geschrieben) 0 zurückgeben (also beenden). Wenn Sie die folgende Eingabe machen ./generate 1000 50 | ./find 128 echo $? , wird 1 angezeigt, da 128 nicht zu den 1000 Zahlen gehört, die von „generate“ mit einem Startwert von 50 ausgegeben wurden. In diesem Fall gibt „search“ (von Ihnen geschrieben) „false“ und „main“ (von uns geschrieben) zurück ) gibt 1 zurück (und beendet dann den Job). Verstehen Sie die Logik? Wenn alles zur Überprüfung mit check50 bereit ist, führen Sie den folgenden Befehl aus: check50 2015.fall.pset3.find helpers.c Übrigens sollten Sie sich nicht daran gewöhnen, Ihren Code mit check50 zu testen, bevor Sie ihn selbst testen. Schließlich existiert check50 nicht wirklich. Daher ist es an dieser Stelle die beste Angewohnheit, den Code mit Ihren eigenen Eingabebeispielen auszuführen und die tatsächliche Ausgabe mit der erwarteten Ausgabe zu vergleichen. Es ist wahr, werden Sie nicht süchtig! Wenn Sie daran interessiert sind, mit der Find-Implementierung der CS50-Assistenten herumzuspielen, führen Sie diesen Befehl aus: ~cs50/pset3/find
Sortierung
Die lineare Suche ist nicht wirklich beeindruckend, aber schon in den ersten Vorlesungen (und in der siebten haben wir diesen Trick noch einmal wiederholt!) erinnern Sie sich, dass Sie die Nadel im Heuhaufen viel schneller finden können. Aber zuerst müssen wir unseren Heuhaufen sortieren. Beachten Sie, dass find.c sort aufruft , eine in helpers.h deklarierte Funktion . Leider haben wir „vergessen“, diese Funktion vollständig in helpers.c zu implementieren ! Schauen Sie sich helpers.c an und Sie werden sehen, dass die Sortierung sofort zurückgegeben wird, obwohl die Hauptfunktion von find tatsächlich das eigentliche Array übergibt. Erinnern Sie sich nun an die Syntax der Array-Deklaration. Sie geben nicht nur den Elementtyp dieses Arrays an, sondern auch seine Größe in eckigen Klammern. Dies ist, was wir für haystack in find.c tun : int haystack [MAX]; Beim Durchlaufen eines Arrays geben Sie jedoch nur seinen Namen an. Und wir machen es genauso, wenn wir den Heuhaufen durchgehen, um die Sortierung in find.c durchzuführen : sort (haystack, size); (Raten Sie mal, warum wir die Größe dieses Arrays separat übergeben?) Wenn wir eine Funktion deklarieren, die ein eindimensionales Array als Argument verwendet, Wir müssen die Größe des Arrays nicht angeben. Ebenso haben wir dies nicht getan, als wir sort in helpers.h (und helpers.c) deklariert haben: void sort (int values [] int n); Implementieren Sie sort, damit die Funktion das Zahlenarray tatsächlich von klein nach groß sortiert. Es benötigt eine Laufzeit von O(n 2 ), wobei n die Größe des Arrays ist. Wahrscheinlich möchten Sie die Blasensortierung, die Auswahlsortierung oder die Einfügungssortierung implementieren, wie wir in Woche drei davon erfahren haben. Es ist jedoch wichtig zu beachten: Es gibt keinen „richtigen“ Weg, diese Algorithmen zu implementieren. Es gibt eine Vielzahl an Variationen. Tatsächlich können Sie sie bei Bedarf jederzeit verbessern, solange Ihre Implementierung gegen O(n2 ) konvergiert . Überlassen Sie das Experimentieren jedoch dem Funktionskörper und ändern Sie unsere Sortierdeklaration nicht, um das Testen zu vereinfachen. Es sollte so aussehen: void sort (int values [] int n); Da die Funktion einen ungültigen Wert zurückgibt, sollte sie kein sortiertes Array zurückgeben. Stattdessen muss es das tatsächliche Array, durch das es „läuft“, „destruktiv“ sortieren und seine Elemente verschieben. In Woche vier werden wir besprechen, dass Arrays als Referenz und nicht als Wert übergeben werden. Das heißt, sort erhält keine Kopien des Arrays, sondern das ursprüngliche Array selbst. Während Sie unsere Sortierdeklaration nicht ändern können, können Sie jederzeit Ihre eigene Funktion in helpers.c definieren, die dann von sort aufgerufen werden kann. Entscheiden Sie selbst, wie Sie Ihre Sortierimplementierung am besten testen. Vergessen Sie nicht, dass printf und GDB Ihnen helfen werden! Und vergessen Sie nicht, dass Sie die gleiche Folge von Pseudozufallszahlen immer wieder erstellen können, indem Sie die Startwerte für „generate“ explizit angeben.
Binäre Suche, Tipps
Das erste, was Sie über die Suchfunktion verstehen müssen, ist , dass wir bereits Code (Verteilung) geschrieben haben. Wir füllen lediglich einige Lücken im vorhandenen Code. Das Programm find.c fordert die Eingabe von Zahlen an (das heißt, um einen „Stapel“ zu füllen) und sucht dann auf Wunsch des Benutzers nach einer „Nadel“ darin, indem es Sortier- und Suchfunktionen verwendet, die in helpers.c definiert sind . Da „find“ also bereits geschrieben ist, müssen wir „helpers“ schreiben . Folgendes müssen wir also tun:
Suche implementieren. Diese Funktion sollte true zurückgeben, wenn der Wert im Stapel gefunden wird, und false, wenn er nicht vorhanden ist.
Implementieren Sie sort, eine Funktion, die ein Array von Werten sortiert.
Die Suche wurde zunächst linear umgesetzt. Aber Sie können es besser machen. Der lineare Suchalgorithmus läuft in O(n) -Zeit . Ihre Aufgabe besteht darin, einen binären Suchalgorithmus zu schreiben. Seine Ausführungszeit beträgt O(log n) . Das Problem besteht jedoch darin, dass es sortierte Daten als Eingabe benötigt, sonst funktioniert es nicht. Sie erinnern sich an das Beispiel des zerrissenen Buches und wissen wahrscheinlich, warum das so ist. Wenn Sie eine binäre Suche nach den Elementen durchgeführt haben und keine mehr davon übrig sind (das heißt, es gibt einfach keine „Nadel“ in diesem „Stapel“), muss die Funktion „false“ zurückgeben. Die binäre Suche kann iterativ oder rekursiv implementiert werden (David Malan sprach in der achten Vorlesung über Rekursion).
GO TO FULL VERSION