Basis und Kür

Die Basis sind die Inhalte und Aufgabentypen, die zum Bestehen reichen; alles darüber hinaus heißt Kür. Wie Sie damit lernen, steht unter Wie Sie Inf-Einf-B bewältigen. Die Einordnung ist vorläufig und wird noch abgestimmt.

Die fünf Labels

Basis-Code: Gehört zur Basis. Sie müssen es selbst schreiben können, sodass es kompiliert bzw. läuft.
Basis-Konzept: Gehört zur Basis. Sie müssen es benennen, erklären und, wo die Sache es verlangt, von Hand durchspielen können. Code schreiben müssen Sie dafür nicht.
Kür-Code: Geht über die Basis hinaus (Kür), für Noten über dem Bestehen. Sie sollen es anwenden und schreiben können.
Kür-Konzept: Geht über die Basis hinaus (Kür). Sie sollen es erkennen, benennen und gegebenenfalls von Hand durchspielen können.
Hintergrund: Einordnung und Zusammenhänge, kein Schwerpunkt der Klausur. Es hilft Ihnen, den übrigen Stoff zu verstehen und die Übungen sicher zu lösen.

Die Labels sagen, worauf die Klausur ihr Gewicht legt. Sie sagen nicht, was Sie weglassen können: Wer die Übungsaufgaben selbst lösen kann, besteht auch die Klausur, und dafür hilft es, sich auch mit Kür und Hintergrund zu beschäftigen.

Die Liste

Geordnet nach den Notes der Vorlesung. Zur Basis gehört jeweils die geradlinige Form, die eine Zeile nennt; weitere Parameter, Kurzformen und Sonderfälle derselben Technik sind Kür.

Notes 0

Basis-Konzept (Erklären und von Hand durchspielen):
- Binär- und Dezimalzahlen umrechnen (von Hand)
- ASCII, Zeichen als Zahlen
- Abstraktion, Algorithmusbegriff, Pseudocode
Kür-Konzept (Erkennen und erklären):
- Unicode, UTF-8
Hintergrund (Einordnung):
- Scratch
- Abschnitt Künstliche Intelligenz

Notes 1 und 2, Shell

Basis-Code (Programmieren können):
- Variablen, Datentypen, Operatoren, Bedingungen, Schleifen
- Funktionen, Parameter, Rückgabewerte, Scope
- Arrays von Zahlen, auch zweidimensional, an Funktionen übergeben (mit Länge)
- Strings als char-Array: durchlaufen, vergleichen, \0, strlen, strcmp
- Zeichenarithmetik (Caesar)
- argc/argv benutzen, Exit-Code
- Ganzzahldivision, Float-Ungenauigkeit umgehen (Cast, größerer Typ)
- Kommentare, Codestil (Einrückung, Klammersetzung, sprechende Namen)
- Eingabevalidierung (Schleife bis zur gültigen Eingabe)
- Symbolische Konstante mit #define anlegen
- Einfache Shell-Befehle (cd, ls, cp, mv, mkdir, rm, cat, pwd)
Basis-Konzept (Erklären und von Hand durchspielen):
- switch lesen, auch das Durchfallen ohne break
- Compiler-Fehlermeldungen lesen
- Magic Numbers erkennen
Kür-Code (Anwenden und schreiben):
- const-Variablen
- Progressives Refactoring
- Pipes, Umleitungen, Wildcards, Textfilter (sort, uniq, cut), komplexere Shell-Konstruktionen
Kür-Konzept (Erkennen und erklären):
- char * vs. char[]
Hintergrund (Einordnung):
- Manual Pages (man)

Notes 3

Basis-Code (Programmieren können):
- Lineare Suche
- Lineare Rekursion (Fakultät, Summe, Produkt), rekursiv und iterativ
- Structs, typedef
Basis-Konzept (Erklären und von Hand durchspielen):
- Binäre Suche (von Hand durchspielen)
- Selection, Bubble, Merge Sort, auch Merge zweier Arrays (von Hand durchspielen)
- Laufzeitklassen O(1), O(log n), O(n), O(n log n), O(n²) zuordnen, Best und Worst Case benennen (Ω und Θ sind Kür)
Kür-Code (Anwenden und schreiben):
- Binäre Suche und Sortierverfahren implementieren, Merge-Funktion
Kür-Konzept (Erkennen und erklären):
- Ω, Θ, Laufzeit begründen und herleiten (Schritte zählen, auch für fremden Code), Laufzeit gegen Speicherbedarf abwägen
- Rekursion über die lineare hinaus: mehrere Fälle oder mehrere Aufrufe (Fibonacci, Collatz; Merge Sort von Hand bleibt Basis), Stack Overflow bei zu tiefer Rekursion

Notes 4 und 4.5

Basis-Code (Programmieren können):
- Pointer, &, *, swap über Pointer
- Structs über Pointer, . und ->, Arrays von Structs
- malloc/free im einfachen Fall (mit NULL-Prüfung)
- String kopieren mit malloc(strlen + 1) und strcpy
- scanf für einfache Werte
- Datei-I/O: fopen (Modi r, w, a), fclose, fprintf, fread/fwrite in festen Blöcken, fgetc/fputc, fgets; Leseschleife bis zum Dateiende, auch mit Zuweisung in der Bedingung (mit FILE*)
- Integer Overflow (erkennen und umgehen)
Basis-Konzept (Erklären und von Hand durchspielen):
- Hexadezimal umrechnen (von Hand)
- Speichermodell: Adressen (Speicher als Array von Bytes), string als char *, Arrays als Adresse übergeben
- Speicherfehler benennen: Garbage Values, Dangling Pointer, Memory Leak
- Call Stack von Hand durchspielen, lokale Variable überlebt das Funktionsende nicht (Stack vs. Heap)
Kür-Code (Anwenden und schreiben):
- fseek, ftell
Kür-Konzept (Erkennen und erklären):
- Double Pointer
- Pointer-Arithmetik, Speicheradressen verrechnen, Speicherlayout über Stack und Heap hinaus (übrige Segmente, Wachstumsrichtung), Größe eines Pointers
- Buffer Overflow (scanf mit %s, strcpy in ein zu kleines Array)
- Valgrind-Ausgabe
Hintergrund (Einordnung):
- Vertiefungen in Notes 4.5: GDB, size_t als eigenes Thema, Rücksprungadresse, Aufbau von FILE, BMP-Format, Funktionspointer

Notes 5 und 5.5

Basis-Code (Programmieren können):
- Verkettete Liste: Knoten definieren, vorne einfügen, vorne entfernen, durchlaufen und suchen, komplett freigeben (free_list)
Basis-Konzept (Erklären und von Hand durchspielen):
- Verkettete Liste lesen
- Stack und Queue (LIFO/FIFO), beide auf einem Array (von Hand durchspielen: push und pop, enqueue und dequeue)
- Array dynamisch vergrößern (neues Array anlegen, kopieren)
- Binärbaum: Suche von Hand durchspielen
- Hash-Tabelle: Prinzip, Kollisionsauflösung (von Hand durchspielen)
Kür-Code (Anwenden und schreiben):
- Verkettete Liste: an beliebiger Stelle löschen (Double Pointer), sortiert einfügen, doppelt verkettete Liste
Kür-Konzept (Erkennen und erklären):
- Binärbaum: Code zum Suchen und Einfügen lesen und erklären
- Hash-Tabelle: Aufbau im Code (Array von Listen) und Hashfunktion lesen und erklären
- Tries

Notes 6 und 7

Basis-Code (Programmieren können):
- Python-Grundlagen: Funktionen, Listen, Dictionaries, Strings (len, in, upper, lower, strip, split), f-Strings, input(), einfaches Slicing
- Einfache Klasse mit __init__ und einfachen Methoden, Instanziieren
- sort() vs. sorted()
- Tupel (benutzen, entpacken)
- Exceptions mit try/except abfangen, mit raise auslösen
- sys.argv, sys.exit
- Module importieren (import, from … import)
- JSON lesen und schreiben (json.load, json.dump)
- Geschachtelte Strukturen verarbeiten (Liste von Dicts, Dict von Dicts, etwa aus JSON)
- Mehrdimensionale Listen, Liste von Listen (anlegen, durchlaufen, auf ein Element zugreifen)
- __str__ schreiben
Basis-Konzept (Erklären und von Hand durchspielen):
- OOP-Begriffe benennen und erklären (Klasse, Objekt, Attribut, Methode, self)
- Python erklären: dynamische Typisierung, Fehler erst zur Laufzeit, Weg einer Exception durch die Aufrufe
- Funktionen als Werte übergeben: einfaches map/filter und sorted mit key lesen (Ergebnis angeben)
- Ausdrücke auswerten: Truthiness, == vs. is
- Aliasing, Mutable vs. Immutable (Verhalten vorhersagen, auch: eine Liste taugt nicht als Dict-Schlüssel)
- Einfache List Comprehension lesen und durchspielen
- pytest: Test lesen und verstehen (assert, pytest.raises)
Kür-Code (Anwenden und schreiben):
- CSV lesen und schreiben (csv-Modul)
- Vererbung
- List Comprehensions schreiben (auch Set und Dict), Generator Expressions
- Sets
- pytest: Tests schreiben
- Properties (@property)
- Lambda schreiben
Kür-Konzept (Erkennen und erklären):
- Defensives Programmieren, Test-Driven Development, Type Hints
- Private Attribute, Klassenattribute, weitere Dunder-Methoden (außer __init__ und __str__), Duck Typing, Inversion of Control

Notes 8

Basis-Code (Programmieren können):
- HTML-Formulare schreiben (form, input, button, name, method, action)
Basis-Konzept (Erklären und von Hand durchspielen):
- HTTP-Grundlagen: Request/Response, GET vs. POST, Statuscodes (200, 404, 500) zuordnen
- URLs zerlegen (Schema, Host, Pfad, Query)
- HTML lesen (Tags, Baumstruktur)
- CSS lesen (Rahmen, Innen- und Außenabstand unterscheiden, sonst keine Attribute auswendig)
Kür-Code (Anwenden und schreiben):
- Einfache HTML-Seite von der leeren Datei an schreiben
- JavaScript schreiben, einschließlich DOM-Manipulation und Event-Handler
Kür-Konzept (Erkennen und erklären):
- CSS-Spezifität (welche Regel bei Widerspruch gewinnt), kombinierte Selektoren, Selektor *, Block- und Inline-Elemente (display)
- Reguläre Ausdrücke
- JavaScript lesen und Fehler finden (Kontrollstrukturen, Funktionen, Arrays, Objekte, Besonderheiten gegenüber C)

Notes 8.5

Basis-Konzept (Erklären und von Hand durchspielen):
- IP-Adressen und Ports, DNS (Namensauflösung erklären), TCP vs. UDP
Kür-Konzept (Erkennen und erklären):
- Encapsulation, NAT, Routing

Notes 9

Basis-Code (Programmieren können):
- Route definieren (Decorator, Rückgabe, variabler Pfadteil)
- Template rendern, Jinja mit Variablen, Schleife und Bedingung
- Formulardaten mit request.form, GET/POST in der Route
- Persistenz über JSON-Datei
- redirect nach POST (schreiben und begründen)
Basis-Konzept (Erklären und von Hand durchspielen):
- Template-Vererbung ({% extends %}, {% block %}) und url_for lesen, statische von dynamisch erzeugten Seiten unterscheiden
Kür-Code (Anwenden und schreiben):
- UUIDs als IDs
- Sessions (einrichten, Wert speichern, einfaches Login)
- Eigene API (Route liefert JSON)
Kür-Konzept (Erkennen und erklären):
- Cookies; HTTP ist zustandslos
- fetch im Browser, API aus Python abrufen (requests.get)

Diese Seite als Markdown: ansehen herunterladen

Hinweise zur Prüfung Linux-Cheat-Sheet