Analysis, Lineare Algebra, Stochastik. Grundlagen für Bachelor-Mathe, mit visuellen Beweisen statt nur Skript-Reihen.
Wie speichert ein Programm Werte? Wie unterscheiden sich int, double, String und boolean?
if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?
for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?
Methoden, Parameter, Rückgabewerte. Code, der wiederverwendbar wird.
Funktionen, die sich selbst aufrufen. Mit Call-Stack-Visualisierung am Beispiel Fakultät.
Geordnete Sammlungen mit Index-Zugriff. Statisches Array (fixe Größe) vs dynamische Liste (ArrayList, list). Welche Operationen sind O(1), welche O(n)? Klausurwichtige Datenstruktur Nummer 1.
Der Bauplan-Trick: Datenstruktur und Verhalten zusammen. Klassen, Konstruktor, Felder, Methoden, this/self. Die Grundlage objektorientierter Programmierung.
Eine Klasse erbt von einer anderen: gemeinsamer Code wandert nach oben, Spezifisches bleibt unten. Override, super, dynamischer Dispatch, das Fundament für jede OOP-Architektur. Mit Tier-Hierarchie-Visualizer.
Sequenzen von Zeichen, indexiert, immutable, end ist exklusiv. substring, indexOf, replace, split, die 80%-Operationen jeder Programmieraufgabe. Mit String-Lab und animiertem indexOf.
try, catch, finally, wie reagiert dein Programm auf Fehler ohne abzustürzen? Exception-Hierarchie, Checked vs. Unchecked, eigene Exceptions, try-with-resources. Mit Try-Catch-Simulator und 4 Live-Snippets.
int, double, String, boolean, wie wandelst du sicher um? Auto-Widening, Truncation, parseInt, Integer-Division (5/2 = 2 vs. 2.5). Mit Cast-Lab und Java/Python parallel.
abs, sqrt, pow, max/min, round/floor/ceil, log, sin, random, die wichtigsten Funktionen der Standard-Mathematik. Mit Math-Lab und Java/Python parallel. Praktisch + klausurrelevant.
Was passiert bei `new Student(...)`? Default-Konstruktor, Konstruktor-Overloading, this(...)-Chaining und die 4 Java-Sichtbarkeitsstufen (public, private, protected, package-private). Mit Heap-Stepper für die Objekt-Erzeugung. Klausur-Pflicht in 13/17 WInf-Prog-1-Klausuren.
Der Java-Trick für Mehrfach-Vererbung: ein Interface ist ein Vertrag, den beliebig viele Klassen erfüllen können. implements vs. extends, Multi-Implementation, Interface-Hierarchien und der ewige Klausur-Klassiker Interface vs. abstrakte Klasse. Mit UML-Visualizer für 3 Beziehungs-Szenarien.
Type-Parameter wie List<String>, Box<T>, Map<K,V>. Type-Safety zur Compile-Zeit statt ClassCastException zur Laufzeit. Bounded Types, Wildcards (PECS-Regel), Type-Erasure, Diamond-Operator. Mit Type-Toggle-Visualizer der Compile-Fehler bei wechselnden Typen live zeigt.
List, Set, Map: die 3 großen Container-Familien in Java. Wann welche Datenstruktur? Reihenfolge, Duplikate, Lookup-Verhalten, der Klausur-Klassiker für jede OOP-Klausur. ArrayList, HashSet, HashMap als Default-Implementierungen, mit Tree-Varianten für sortierte Reihenfolge. Mit Side-by-Side-Visualizer der alle drei live vergleicht.
Java 8 Lambda-Ausdrücke (x -> x*2), funktionale Interfaces (Function, Predicate, Consumer, Supplier), Method-References (String::length) und Stream-API (filter, map, reduce). Mit interaktiver Higher-Order-Pipeline, in der du Stream-Schritte ein-/ausschalten kannst. P3-Vertiefung, oft schon in Prog-1 angerissen.
Namensräume in Java: package-Deklaration, Import-Anweisungen, Wildcard-Imports, static imports. Sichtbarkeit zwischen Paketen (public, protected, package-private, private) und wie die Datei-Struktur zum Paket passen muss. Mit Paket-Baum-Visualizer der ein 3-Paket-Mini-Projekt zeigt.
IS-A oder HAS-A? Wann Komposition statt Vererbung besser ist: Delegation, Fragile Base Class, Klassen-Explosion. Interaktiver Vergleich, mit Java-Beispielen.
Die Java-Stream-API in der Tiefe: Pipeline, Lazy Evaluation, Collectors (groupingBy, joining), reduce und flatMap. Mit interaktiven Pipeline-Steppern.
Threads in Java: start vs. run, join, Race Condition am verschränkten counter++, synchronized als Lösung, volatile und Deadlock. Mit interaktiven Steppern.
JavaFX-Grundlagen: Scene-Graph (Stage, Scene, root), Layout-Container (VBox, HBox, GridPane), Controls und Event-Handling mit setOnAction. Mit Layout-Preview.
Datei-I/O in Java: Byte- vs. Char-Streams, das EOF-Signal (-1 / null), Buffering und try-with-resources, plus NIO (Files/Path). Mit interaktiven Lese-Steppern.
Objekte als Byte-Strom speichern: Serializable, writeObject/readObject, transient, serialVersionUID, der Objekt-Graph, und warum JSON oft die bessere Wahl ist.
y = mx + b verstehen, Graph zeichnen, Werte berechnen. Die Grundlage für Algorithmus-Laufzeit, Kostenmodelle und einfache Regression.
f(x) = ax² + bx + c. Parabeln verstehen, Scheitelpunkt finden, Nullstellen berechnen mit pq- und abc-Formel. Drei Darstellungsformen und wann welche.
Vom Differenzenquotienten zum Differentialquotienten: Tangentensteigung als Grenzwert der Sekantensteigungen. Grundregeln (Potenz, Faktor, Summe, Differenz) und erweiterte Regeln (Produkt, Quotient, Kette). Extremwerte über die notwendige Bedingung f'(x) = 0 und hinreichende Bedingung mit f''.
Fläche unter der Kurve: Riemann-Summen, Stammfunktion und Hauptsatz. Bestimmtes vs. unbestimmtes Integral, Potenzregel rückwärts. Die zweite Säule der Analysis.
Gerichtete Größen mit Komponenten und Länge. Addition, Skalarprodukt, Winkel, Orthogonalität. Grundlage für lineare Algebra, Computergrafik und Machine Learning.
Sammlungen verstehen: Vereinigung, Schnitt, Differenz, Komplement. Venn-Diagramme, De Morgansche Regeln, Inklusion-Exklusion. Grundlage für Logik, Datenbanken und Wahrscheinlichkeit.
Wahr und Falsch verknüpfen: AND, OR, NOT, Implikation. Wahrheitstabellen, Tautologien, De Morgan. Grundlage für jede if-Bedingung in Code und für mathematische Beweise.
Vom Würfel zur Vorhersage: Ergebnisraum, Laplace, Gegenereignis, Unabhängigkeit. Wahrscheinlichkeits-Lab mit 5 Szenarien (Münze, Würfel, Karte, Urne, 2-Würfel-Summe) zeigt das Gesetz der großen Zahlen, auch bei ungleicher Verteilung.
Die Mathematik des Zählens: Variation, Permutation und Kombination, mit oder ohne Wiederholung. Lotto (Kombination), PIN (Variation mit Wdh), 5 Bücher anordnen (Permutation). Mit Entscheidungstabelle und Explorer für n und k.
Mittelwert, Median, Modus, Varianz, Standardabweichung, Quartile, Boxplot. Mit interaktivem Statistik-Lab, sieh wie ein einziger Ausreißer den Mittelwert zerlegt, der Median aber ruhig bleibt.
Tabellen aus Zahlen, die Sprache der linearen Algebra. Addition, Multiplikation (nicht elementweise!), Transposition, Determinante. Mit Matrix-Lab und animierter Multiplikation Zelle-für-Zelle.
Bruch, Dezimal, Prozent, Promille, vier Schreibweisen für denselben Anteil. Kürzen, Erweitern, Prozent-Rechnung mit Grundwert / Prozentwert / Prozentsatz.
Wachstum und Zerfall: a^x und log_a(x) als Inversen. Zinseszins, 72er-Regel, Halbwertszeit, log₂ in der Informatik. Mit Funktions-Plotter und Verdopplungs-Rechner.
Einfacher Zins vs. Zinseszins, Aufzinsen ↔ Abzinsen mit Diskontfaktor, unterjährige Verzinsung (30/360-Konvention), Effektivzins vs. Nominalzins. Vorstufe für Investitions-, Renten- und Tilgungsrechnung.
Folge gleicher Zahlungen, Endwert und Barwert vor- vs. nachschüssiger Renten, ewige Rente als Sonderfall, Brücke zu Annuitätendarlehen und DCF-Bewertung.
Annuitäten- vs Ratentilgung mit interaktivem Tilgungsplan: Restschuld nach t Jahren, Annuitäten-Faktor, Disagio + Aufgaben mit Lösungen.
Lineare Programmierung: Modellierung als Zielfunktion + Restriktionen, 2D-grafische Lösung über Polygon-Ecken, Simplex-Algorithmus, Spezialfälle (unbeschränkt, mehrfach optimal) und Sensitivitäts-/Schattenpreis-Analyse.
Arithmetische und geometrische Folgen, Partialsummen, Konvergenzbegriff und wichtige Grenzwerte. Geometrische Reihe als Rückgrat der Wirtschaftsmathe (ewige Rente, Zinseszins, NPV).
Funktionen mehrerer Variablen: partielle Ableitungen, Gradient, Hesse-Matrix und Klassifikation kritischer Punkte (Min/Max/Sattel). Anwendungen in Cobb-Douglas, Nutzenmaximierung und Optimierung.
Die 4 Standard-Techniken jeder Mathe-1-Klausur: direkter Beweis, Widerspruchsbeweis (klassisch für √2 irrational), vollständige Induktion (für 'für alle n ∈ ℕ'), Kontraposition. Plus Gegenbeispiel zum Widerlegen. Mit Beweis-Stepper für 3 klassische Beweise Schritt für Schritt.
Wie man Winkel zwischen Vektoren berechnet. Skalarprodukt algebraisch (Komponenten-Summe) + geometrisch (|u|·|v|·cos α), Norm via √(v·v), Orthogonalität ⇔ Skalarprodukt = 0, Cauchy-Schwarz-Ungleichung, orthogonale Projektion mit Anwendung in Least-Squares. Mit interaktivem Vektor-Lab.
Funktionen zwischen Vektorräumen, die Additivität + Homogenität erfüllen. Matrix-Darstellung über Bilder der Standard-Basisvektoren, Bild und Kern als Unterräume, Dimensionssatz (Rangsatz), injektiv/surjektiv/bijektiv, Komposition = Matrix-Multiplikation. Mit Transformations-Lab (Drehung, Spiegelung, Streckung, Scherung).
Vektoren, die unter einer Matrix-Transformation nur gestreckt (nicht gedreht) werden. Charakteristisches Polynom det(A−λI)=0 für Eigenwerte, Gauß für Eigenvektoren, Spur/Determinante als Shortcuts, Diagonalisierung A=PDP⁻¹. Grundlage für PCA, Google PageRank, Quantenmechanik. Mit Transformations-Visualizer.
Eine Zahl, die alles über eine Matrix sagt: invertierbar oder nicht, Lösungstyp des LGS, vorzeichenbehaftetes Volumen. 2×2-Formel ad−bc, Sarrus für 3×3, Laplace-Entwicklung für größere Matrizen, Gauß-Methode mit Operations-Tracking. Mit Parallelogramm-Lab als geometrische Anschauung.
Das Standard-Werkzeug zur Lösung linearer Gleichungssysteme. Stufenform durch Zeilen-Operationen, Rückwärts-Einsetzen, Rang einer Matrix, Rouché-Capelli-Kriterium für Lösungstyp (eindeutig / unendlich / keine Lösung). Mit Tableau-Stepper für 3 Szenarien, die Standardtechnik jeder LinAlg-Klausur.
Einführung in Differentialgleichungen für dynamische Vorgänge (Wachstum, Zerfall, Schwingungen). Klassifikation (Ordnung, linear/nicht-linear, homogen/inhomogen), Trennung der Variablen für 1. Ordnung, charakteristische Gleichung für 2. Ordnung (3 Fälle Diskriminante), Anfangswertprobleme, klassische Modelle. Mit interaktivem Lösungs-Plot.
Doppel- und Dreifachintegrale für Funktionen mehrerer Variablen. Fubini für Vertauschen der Reihenfolge, nicht-rechteckige Bereiche, Polar-/Kugel-Koordinaten mit Jacobi-Determinante, Anwendungen (Fläche/Volumen/Masse/Schwerpunkt/Trägheitsmoment/Wahrscheinlichkeit). Mit interaktivem Doppelintegral-Visualizer.
Polynom-Approximation einer Funktion um einen Entwicklungspunkt. Taylor-Formel mit Ableitungen + Faktoriellen, Maclaurin als Spezialfall ($x_0=0$), Standard-Reihen ($e^x, \sin, \cos, \ln$), Restglied (Lagrange-Form), Konvergenzradius, Anwendungen (Linearisierung, numerische Berechnung). Mit interaktivem Approximations-Plot.
Pilot Welle 14, der mathematische Klausur-Klassiker für Optimierung mit Nebenbedingungen. Lagrange-Funktion $\mathcal{L} = f - \lambda(g - c)$, notwendige Bedingungen (3 partielle Ableitungen = 0), Schattenpreis-Interpretation, KKT für Ungleichungs-NB. Mit interaktivem Höhenlinien-Plot.
Mathematische Definition der 'ohne abzusetzen zeichnen'-Eigenschaft. 3 Bedingungen (Funktionswert + Limes + Gleichheit), 4 Unstetigkeitstypen (hebbar/Sprung/Pol/Oszillation), Zwischenwertsatz für Nullstellen-Existenz, Satz von Weierstraß für Max/Min, ε-δ-Definition (formal). Mit Visualizer für alle 4 Unstetigkeitstypen.
Erweiterung der Aussagenlogik um Quantoren (∀, ∃) und Prädikate. Syntax: Konstanten, Variablen, Prädikate (Großbuchstaben), Junktoren, Quantoren. Formalisierungs-Muster: 'Alle X sind Y' = ∀x (X(x) → Y(x)) vs. 'Es gibt X, das Y ist' = ∃x (X(x) ∧ Y(x)). Quantor-Reihenfolge (∀∃ ≠ ∃∀). De Morgan für Quantoren (¬∀ ⇔ ∃¬, ¬∃ ⇔ ∀¬). Freie vs. gebundene Variablen. Modell-Theorie (Domäne + Interpretation). Erfüllbarkeit / Gültigkeit / Semi-Entscheidbarkeit (Church 1936, Turing 1936). Mit interaktivem Formel-Explorer + Highlighting.
Der intuitive Sortieralgorithmus: zwei verschachtelte Schleifen, größere Werte blubbern nach oben. Einfach zu erklären, in der Praxis aber zu langsam: O(n²).
Teile und Herrsche. Garantierte O(n log n) durch rekursives Halbieren plus Merge. Stabil, aber braucht O(n) Zusatzspeicher. Klausur-Klassiker schlechthin.
Der schnellste der Klassiker im Average Case: O(n log n), in-place, partitioniert um einen Pivot. Bei sortiertem Input rutscht er aber auf O(n²) ab.
Bubblesort, Mergesort und Quicksort live nebeneinander. Übersichtstabelle, interaktiver Visualizer und Klausur-Quiz, das die Unterschiede festigt.
Der simpelste Suchalgorithmus: jedes Element prüfen bis Treffer oder Ende. Funktioniert auf jedem Array, sortiert oder nicht. O(n) im Worst Case.
Halbiere den Suchraum bei jedem Schritt. O(log n) statt O(n): bei einer Milliarde Einträgen reichen 30 Vergleiche. Voraussetzung: sortiertes Array.
Lineare und binäre Suche live nebeneinander. Bei welchem n lohnt sich der Aufwand des Sortierens? Wann ist Linear schneller? Klausur-Übersicht.
Zwei fundamentale Datenstrukturen: Stack (LIFO) wie ein Bücherstapel, Queue (FIFO) wie eine Schlange. Kernoperationen wie push/pop bzw. enqueue/dequeue sind O(1). Brücke zu Bäumen und Graphen.
Die wichtigste Datenstruktur überhaupt. Key-Value-Lookup in O(1) durch eine Hash-Funktion. Java HashMap, Python dict. Verstehe Buckets, Kollisionen und Chaining.
Knoten mit Pointern statt zusammenhängendem Speicher. Prepend in O(1), Index-Zugriff in O(n), die umgekehrte Stärke zum Array. Klausur-Klassiker.
Halbierte Suche durch sortierte Baumstruktur: O(log n) für Suche, Insert, Delete, wenn balanciert. Mit BST-Visualizer und allen vier Traversals (In/Pre/Post/Level-Order). Klausur-Liebling.
Knoten und Kanten, von Maps bis Social Networks. BFS (Queue, ebenenweise) vs. DFS (Stack, in die Tiefe), Adjacency-Repräsentation, kürzester Pfad. Mit Live-Traversal-Animation.
Faire Komplexitäts-Analyse für Datenstrukturen mit gelegentlich teuren Operationen. Drei Methoden (Aggregat, Accounting/Banker, Potential). Klassiker: ArrayList Resize O(1) amortisiert, Multi-Pop Stack, Union-Find, Binärzähler, Splay-Trees. Verdoppelungs-Strategie ist Schlüssel. Mit ArrayList-Resize-Lab.
Systematische Tiefensuche mit Rückzug bei Sackgassen. Klassiker für NP-schwere Probleme: 8-Damen, Sudoku, Knapsack, TSP, Graph-Färbung. Branch-and-Bound als Erweiterung für Optimierung. Pruning ist essentiell, ohne Pruning brute-force O(b^d). Mit 4-Damen-Stepper, der Try/Conflict/Backtrack live visualisiert.
Selbst-balancierender binärer Suchbaum mit garantiert O(log n) Operationen. Balance-Faktor |BF| ≤ 1, 4 Rotation-Fälle (LL/RR Single, LR/RL Double), Vergleich zu Rot-Schwarz-Bäumen. Mit Vorher/Nachher-Visualizer für jede der 4 Rotationen. Klausur-Klassiker zur Verhinderung von BST-Entartung.
Das algorithmische Paradigma hinter Mergesort, Quicksort, Binäre Suche, Karatsuba, FFT. Drei Phasen (Divide, Conquer, Combine), Master-Theorem für Laufzeit-Analyse, Unterschied zu DP (unabhängige vs. überlappende Teilprobleme), Parallelisierbarkeit. Mit Mergesort-Baum-Visualizer für Top-Down/Bottom-Up.
Untere Schranke Ω(n log n) gilt nur für VERGLEICHS-Sortierung. Counting Sort O(n+k), Radix Sort O(d·(n+b)), Bucket Sort O(n) average, alle linear bei richtigen Voraussetzungen. Wann welcher Algorithmus? Mit Radix-Sort-Stepper für stellenweise Sortierung über 3 Stellen.
Der billigste Baum, der alle Knoten eines gewichteten ungerichteten Graphen verbindet. Zwei Greedy-Algorithmen: Kruskal (Kanten sortieren + Union-Find für Zyklen-Check, O(E log E)) und Prim (wachsender Baum + Priority Queue, O((V+E) log V)). Cut-Eigenschaft als Korrektheits-Beweis. Mit Side-by-Side-Visualizer.
Die Standard-Datenstruktur für Priority Queues. Vollständig binärer Baum mit Heap-Eigenschaft (Eltern ≥ Kinder), Array-Repräsentation ohne Pointer, Operationen Insert/Extract-Max in O(log n), Build-Heap in O(n), Heapsort als einziger in-place O(n log n)-Sortier-Algorithmus. Mit interaktivem Stepper für Baum + Array parallel.
Lokal beste Entscheidungen ohne Zurückschauen. Voraussetzungen (Greedy-Auswahl-Eigenschaft + optimale Substruktur), klassische Probleme (Activity-Selection nach Endzeit, Huffman, MST, Fractional Knapsack), Beweise per Austauschargument, Greedy vs. DP. Mit Activity-Selection-Lab + 3 Strategie-Vergleich.
Eines der mächtigsten algorithmischen Paradigmen: zerlege Probleme in überlappende Teilprobleme, löse jedes nur einmal, speichere Ergebnisse. Memoization (Top-Down) vs. Tabulation (Bottom-Up), klassische Probleme: Fibonacci, Knapsack, LCS, Edit-Distanz, Münzwechsel. Mit Tabellen-Stepper für Fibonacci.
Der Standard-Algorithmus für kürzeste Wege in gewichteten Graphen mit nicht-negativen Kantengewichten. Single-Source-Shortest-Path mit Priority Queue, Relax-Schritt, Pfad-Rekonstruktion via Vorgänger. Mit Schritt-für-Schritt-Visualizer auf einem 5-Knoten-Graphen. Grundlage von Google Maps + Netzwerk-Routing.
Die wichtigste stetige Verteilung der Statistik. Glockenkurve, Standardisierung, Z-Score, 68-95-99,7-Regel und Tabellen-Lookup für Klausur-Aufgaben.
Binomialverteilung B(n,p) und Poisson-Verteilung Po(λ) mit Formel, Erwartungswert (np bzw. λ), Varianz und Approximationen Binomial→Poisson→Normal.
Bereich um den Stichprobenmittelwert, in dem der wahre Populationsmittelwert mit (1−α) Sicherheit liegt. Standard-Quantile, Wurzel-Gesetz, Stichprobenplanung, Klausur-Pflicht.
Datenbasierte Entscheidung über Behauptungen zur Population. Hypothesen H₀/H₁, einseitig vs. zweiseitig, z-Test, p-Wert, Fehler 1. und 2. Art, Klausur-Pflicht.
Hypothesentest für Mittelwerte bei unbekanntem σ. Drei Varianten (Ein-Stichproben, Zwei-Stichproben, Gepaart), t-Verteilung mit Freiheitsgraden, Klausur-Pflicht.
Misst Zusammenhänge zwischen zwei Variablen. Pearson für linearen Zusammenhang, Spearman für ordinale oder Ausreißer-behaftete Daten. Wertebereich −1 bis +1, plus Bestimmtheitsmaß r².
Regressionsgerade y = a + b·x mit OLS-Methode, Bestimmtheitsmaß R², Residuen-Plot, Gauss-Markov-Voraussetzungen + Klausur-Aufgaben. Mit interaktivem Plot.
Test für kategoriale Daten: passen beobachtete Häufigkeiten zu erwarteten? Drei Varianten (Anpassungs-, Unabhängigkeits-, Homogenitätstest), Σ(O−E)²/E, df = (r−1)(c−1).
Vergleich von Mittelwerten mehrerer Gruppen mit dem F-Test. Quadrat-Summen-Zerlegung SST = SSB + SSW, F = MSB/MSW, Voraussetzungen und Post-hoc-Tests.
Qualitativ vs. quantitativ, diskret vs. stetig, und vor allem die 4 Skalenniveaus (nominal/ordinal/intervall/verhältnis). Klausur-Klassifikator mit Entscheidungsbaum + Trainings-Spiel mit 12 Variablen. Pflicht-Basis für jede Statistik-Aufgabe, falsche Skala führt zu falschem Test und falschem Diagramm.
Mittelwert, Median, Modus + Spannweite, Varianz, Standardabweichung, IQR. Robustheits-Frage 'Mittelwert oder Median?' am interaktiven Lab mit Boxplot durchspielen, sieh wie ein Ausreißer den Mittelwert kippt, der Median ruhig bleibt. Klausur-Klassiker zu Stichproben- vs. Populationsvarianz und Quartil-Methoden.
Absolute vs. relative Häufigkeit, Histogramm-Erstellung, Bin-Breite-Wahl (Sturges/Scott/Freedman-Diaconis), kumulierte Häufigkeit als EDF. Interaktives Lab mit 4 Datensätzen (Normal/Bimodal/Schief/Ausreißer) und Bin-Slider, sieh wie Bimodalität bei zu wenigen Bins verschwindet und ab welcher Anzahl sie sichtbar wird.
Warum Stichprobenmittel annähernd normalverteilt sind, egal aus welcher Ausgangsverteilung. Wurzel-n-Regel, Standardfehler σ/√n, Z-Wert für Stichprobenmittel. Interaktiver Simulator mit Würfel/Exponential/Bimodal als Ausgang, der CLT in Echtzeit zeigt. Grundlage für jeden t-Test, jedes Konfidenzintervall und jede Stichproben-basierte Inferenz.
Bedingte Wahrscheinlichkeit P(A|B), Multiplikationssatz, Satz der totalen Wahrscheinlichkeit und Bayes-Theorem. Vier-Felder-Tafel als Klausur-Werkzeug, medizinischer Test als Klassiker, Falsch-Positiv-Falle bei seltenen Krankheiten.
Rechenregeln für E(X) und Var(X): Linearität, Skalierung mit a², Summen mit/ohne Unabhängigkeit, Verschiebungssatz, klassische E/Var je Verteilung.
Stetige Verteilungen: Dichte als Fläche, Exponentialverteilung mit Gedächtnislosigkeit, Gleichverteilung mit Erwartungswert und Varianz.
Maximum-Likelihood: Likelihood und Log-Likelihood, Score-Gleichung, ML-Schätzer für Bernoulli (p-Dach = k/n) und Normalverteilung, Eigenschaften (konsistent, effizient).
Multiple Regression: mehrere Prädiktoren, partielle Koeffizienten (ceteris paribus), OLS, R² und adjustiertes R², Multikollinearität und Dummy-Variablen.
Aus Worten Modelle machen: 4-Schritt-Schema (Variablen mit Einheiten → Restriktionen inkl. Nichtnegativität → Zielfunktion → Modell). 5 klassische LP-Typen (Produktion / Mischung / Transport / Zuordnung / Schicht). Standardform für Simplex mit Schlupf-/Überschussvariablen. Operator-Mapping (höchstens → ≤, mindestens → ≥). Mit interaktivem Modellierungs-Workshop an 3 Klausur-Klassikern (Möbel-Produktion / Tierfutter-Mischung / Call-Center-Schichten).
Integer Programming (IP) als LP mit Ganzzahligkeits-Restriktion. 3 Typen (reines IP / gemischt MIP / 0-1-IP binär). LP-Relaxation als Schranke (obere bei max, untere bei min). Integrality Gap. Klassische 0-1-Probleme (Knapsack, TSP, Set-Cover, Assignment). Big-M-Methode für logische Verknüpfungen. NP-Schwere vs. praktische Lösbarkeit (Gurobi/CPLEX). Hungarian Algorithm für Assignment in O(n³). Mit interaktivem Gitterpunkt-Visualizer LP-Relaxation vs. IP-Optimum.
Primal-Dual-Konstruktion (A → A^T, c ↔ b, max ↔ min, ≤ ↔ ≥). 3 Dualitätstheoreme (schwach / stark / komplementärer Schlupf). Schattenpreise als Dual-Variablen + Wert pro Ressourcen-Einheit. Sensitivitäts-Analyse (Δz* = y* · Δb innerhalb Bereich). Symmetrie Dual(Dual(P)) = P. Mit interaktivem Side-by-Side-Visualizer Primal/Dual + RHS-Slider + Live-Schattenpreise.
Klassisches Transport-Problem (Hitchcock 1941, Kantorovich 1939): min Kosten Σ Σ cᵢⱼ xᵢⱼ unter Angebot + Bedarf-Restriktionen. Balanciertheit + Dummy-Einsatz. 2-Phasen-Algorithmus: Start-Heuristiken (Nordwest-Ecke / Vogel-Approximation / Min-Kosten) + MODI-Optimierung mit Stepping-Stone-Pfad. Erweiterung zu Netzwerk-Flüssen: Max-Flow (Ford-Fulkerson), Min-Cost-Flow, Max-Flow-Min-Cut-Theorem. Kürzeste Pfade (Dijkstra / Bellman-Ford / Floyd-Warshall). Mit interaktivem Bipartit-Graph-Visualizer 3 Lager → 4 Filialen.
Standard-Algorithmus für ganzzahlige Programme (Land & Doig 1960): iteratives Aufteilen in Subprobleme (Branch) + LP-Relaxation als Schranke (Bound) + Pruning hoffnungsloser Äste. 3 Pruning-Regeln (Bound / Infeasibility / Integer-Solution). Inkumbent-Tracking. Knoten-Strategien (Best-First / Depth-First). Variable-Auswahl (Most Fractional / Strong Branching). Branch & Cut als Pro-Variante mit Schnittebenen (Gomory-Cuts). MIP-Solver-Praxis (Gurobi/CPLEX). Mit interaktivem Suchbaum-Visualizer + 7-Knoten-Beispiel komplett durchgerechnet.
Heuristiken vs. exakte Algorithmen vs. Approximations-Algorithmen vs. Meta-Heuristiken. Konstruktions-Heuristiken (Greedy: Nearest-Neighbor TSP / Greedy Knapsack / Set-Cover-Greedy). Verbesserungs-Heuristiken (Lokale Suche, 2-Opt für TSP). Meta-Heuristiken (Simulated Annealing Kirkpatrick 1983, Tabu Search Glover 1986, Genetic Algorithms Holland 1975, Ant Colony Dorigo 1992). Approximations-Garantien (1/2 für Knapsack-Greedy, 1.5 für Christofides metrisches TSP, ln(n) für Set-Cover). No-Free-Lunch-Theorem. Mit interaktivem TSP-6-Städte-Visualizer Greedy vs. 2-Opt.
Graphische Methode für 2-Variablen-LPs: 4-Schritt-Methode (Koordinatensystem + Nichtnegativität → Restriktionen als Geraden → Zulässigen Bereich schraffieren → Zielgerade verschieben). Fundamentalsatz: Optimum in einer Ecke des konvexen Polytops. Eckpunkt-Methode (alle Ecken berechnen) vs. Schieben-Methode (Zielgerade in Gradient-Richtung verschieben). Spezialfälle (Multipel-Optimum / Unbeschränkt / Leer / Entartet). Zusammenhang Simplex = systematisierte Ecken-Methode. Mit interaktivem 2D-Plot inkl. RHS-Slider für Zielgerade.
UML-Sequenzdiagramm (Zeit ↓, Lifelines + synchrone/asynchrone Nachrichten + Combined Fragments alt/opt/loop/par/break/ref) vs. UML-Aktivitätsdiagramm (Flow-Chart mit Diamanten/Fork-Join/Swimlanes). Wann was: Sequenz für Detail-Interaktionen zwischen Objekten, Aktivität für Workflow + Geschäftsprozesse. UML 2.5 mit 14 Diagrammtypen (7 Struktur + 7 Verhalten). Mit interaktivem Toggle-Visualizer Login-Use-Case in beiden Notationen.
Petri-Netze (Carl Adam Petri 1962): bipartiter Graph aus Stellen (Kreise, Zustände) + Transitionen (Rechtecke, Aktionen) + Marken (Tokens) + Kanten (Pfeile). Aktivierungs-Bedingung: alle Pre-Stellen ≥ 1 Marke. Klassisches Erzeuger-Verbraucher-Pattern. Eigenschaften (Erreichbarkeit / Beschränktheit / Lebendigkeit L0-L4 / Deadlock-Freiheit). Varianten (Gefärbte Petri-Netze Jensen 1981 / Zeitbehaftet / Stochastisch / Hierarchisch). Ausdrucksstärker als endliche Automaten. Mit interaktivem Petri-Netz-Simulator (Erzeuger-Verbraucher mit Puffer, klickbare Transitionen).
3-Ebenen-Architektur (ANSI-SPARC 1975): konzeptionell (WAS, ER + UML) → logisch (WIE, Relationen-Schema mit PK/FK) → physisch (WOMIT, SQL-DDL mit Datentypen + Indexen). Datenunabhängigkeit (logisch + physisch). External / Conceptual / Internal Schema. ARIS-Bezug (Fachkonzept/DV/Implementierung). Forward vs. Reverse Engineering. Werkzeuge pro Ebene (draw.io/Enterprise Architect für konzept, ERwin/dbdiagram.io für logisch, pgAdmin/Prisma für physisch). Mit interaktiver Pyramide-Visualisierung + Online-Shop-Beispiel auf 3 Ebenen.
