Zum Inhalt springen
DE EN
Abonnieren

Informatik Advanced

Gymnasium / Matura- bzw. Abitur-Niveau.

15:40

Folge 2

Zahlensysteme & Zahlendarstellung – Advanced

Das lernst du

  • jede Basis: Wert = Ziffer · Basis^Stelle, das Horner-Schema als schneller Weg
  • Hexadezimal: 1 Hex-Ziffer = 4 Bit, 0x41 = 65, Farbcode #E08A4E = 224 / 138 / 78
  • Oktal und Dateirechte: chmod 755 = rwx r-x r-x
  • Zweierkomplement: −13 = 1111 0011, 7 − 13 = −6 mit nur einem Addierer
  • Wertebereich und Überlauf: 100 + 50 = −106, Pac-Man Level 256, Ariane 5, Jahr 2038
  • Gleitkomma: 5,75 nach IEEE 754 und warum 0.1 + 0.2 = 0.30000000000000004
  • fünf Prüfungsfallen, an denen in Tests die meisten Punkte verloren gehen
Auf YouTube ansehen
13:21

Folge 3

Codierung, Kompression & Fehlerkorrektur – Advanced

Das lernst du

  • Ein Bit = eine Ja-Nein-Frage: Zahlenraten bis 100 in sieben Fragen, Entropie
  • UTF-8 im Detail: Startbits, Folgebytes, ä = C3 A4 und der Umlaut-Fehler
  • Huffman-Baum für ABRAKADABRA: 23 statt 88 Bits – und warum nicht alles beliebig klein geht
  • JPEG, MP3/AAC und Video: weglassen, was wir nicht wahrnehmen
  • Paritätsbit, EAN-Prüfziffer an der Kasse, IBAN
  • Hamming-Code (7,4): Fehler finden und korrigieren · Reed-Solomon im QR-Code
  • fünf Prüfungsfallen
Auf YouTube ansehen
13:16

Folge 4

Boolesche Algebra & Gatter – Advanced

Das lernst du

  • boolesche Algebra: A·B, A + B, Ā – und warum 1 + 1 = 1 ist
  • Rechengesetze, das zweite Distributivgesetz und De Morgan
  • Mehrheitsschaltung: Tabelle → Minterme → DNF → vereinfachte Schaltung (mit KV-Diagramm)
  • NAND kann alles: NICHT, UND und ODER aus NAND – und der Apollo-Computer aus NOR
  • Volladdierer, 4-Bit-Addierer (5 + 6) und Subtraktion mit XOR-Reihe (7 − 3)
  • Schaltwerke: SR-Latch, Tastenentprellung, D-Flipflop, Register und Zähler
  • fünf Prüfungsfallen
Auf YouTube ansehen
12:54

Folge 5

Rechnerarchitektur & Von-Neumann – Advanced

Das lernst du

  • Von-Neumann-Architektur: fünf Teile, Programm und Daten im selben Speicher
  • im Prozessor: ALU, Akku, Befehlszähler, Befehlsregister, Statusflags und Steuerwerk
  • drei Busse – und warum 32 Leitungen nur 4 GiB adressieren
  • holen → decodieren → ausführen: ein Mini-Programm Takt für Takt (7 + 5 = 12)
  • Speicherhierarchie: wenn Cache eine Sekunde dauert, dauert die Festplatte vier Monate
  • Flaschenhals, Harvard, Pipeline (400 gegen 103 Takte), RISC und CISC, GPU
  • fünf Prüfungsfallen
Auf YouTube ansehen
14:35

Folge 6

Algorithmen & Big O – Advanced

Das lernst du

  • Schritte zählen statt Sekunden messen: bester, mittlerer und schlechtester Fall
  • lineare Suche O(n) gegen binäre Suche O(log n): 23 in drei statt sechs Vergleichen, 1 Million in 20
  • Selection, Insertion und Bubble Sort – und warum sie quadratisch sind
  • Rekursion: Basisfall, Fakultät, Aufrufstapel für 4! und die Türme von Hanoi
  • Mergesort: O(n log n) statt O(n²) – 2 · 10⁷ statt 5 · 10¹¹ Schritte
  • O-Notation: Wachstumskurven und Tabelle für n = 10, 1000 und 1 Million
  • Problem des Handlungsreisenden, P gegen NP, Näherungen im Navi, Schach
  • fünf Prüfungsfallen
Auf YouTube ansehen
12:19

Folge 7

Compiler & Interpreter – Advanced

Das lernst du

  • drei Sprachebenen: total = a + b → LADE, ADDIERE, SPEICHERE → 1E 2F 3D
  • Compiler (C, C++, Rust) gegen Interpreter · Python-Bytecode · Java mit JVM und JIT
  • der Lexer: 17 Zeichen werden 5 Tokens
  • Grammatik in EBNF und Syntaxbäume: 2 + 3 · 4 = 14, (2 + 3) · 4 = 20, 8 − 2 − 3 = 3
  • Python-Bytecode mit dis lesen – und warum Python 2 + 3 * 4 schon vorher ausrechnet
  • Syntax gegen Semantik, Logik- und Laufzeitfehler
  • Typsysteme: Java statisch, Python dynamisch; Python streng, JavaScript grosszügig ("3" + 4)
  • imperativ, deklarativ (SQL), objektorientiert, funktional
  • fünf Prüfungsfallen
Auf YouTube ansehen
11:56

Folge 8

Automaten & Halteproblem – Advanced

Das lernst du

  • Zustandsdiagramme: Drehkreuz und Getränkeautomat (1,50 €, mit Rückgeld)
  • Automaten, die prüfen: Ist eine Binärzahl durch 3 teilbar? 110 und 1001 Schritt für Schritt
  • reguläre Ausdrücke: [0-9]{4} für die Postleitzahl, ^ $ + * ? und ein Muster für Autokennzeichen
  • warum endliche Automaten keine beliebig tiefen Klammern prüfen können – und wie ein Stapel hilft
  • die Turingmaschine rechnet 1011 + 1 = 1100
  • das Halteproblem: der Halte-Tester und der Trotzkopf
  • warum es keinen perfekten Virenscanner geben kann
  • fünf Prüfungsfallen
Auf YouTube ansehen
13:58

Folge 9

Datenstrukturen – Advanced

Das lernst du

  • Array: Adresse = Start + Index · Grösse, Zugriff in O(1), Einfügen in O(n)
  • verkettete Liste: Knoten mit Zeiger, zwei Zeiger umhängen
  • Stapel: push, pop, peek · Rückgängig, Aufrufstapel, Klammerprüfung (2 + [3 · 4]) · 5
  • Warteschlange: enqueue, dequeue, Ringpuffer, deque in Python
  • binärer Suchbaum aus 50, 30, 70, 20, 40, 60, 80 – Suche nach 45 in drei Vergleichen
  • Hashtabelle mit zehn Fächern: Ben → 7, Anna und Nana → 2 (Kollision)
  • Kostentabelle: welche Struktur wofür
  • fünf Prüfungsfallen
Auf YouTube ansehen
11:50

Folge 10

OOP: Klassen & Vererbung – Advanced

Das lernst du

  • eine Klasse BankAccount entwerfen: owner, balance, deposit(), withdraw()
  • Kapselung: withdraw(150) wird abgelehnt, withdraw(30) → 70 € · Python _balance und @property, Java private
  • Vererbung: Character → Knight, Archer, Mage · super().__init__()
  • Polymorphie: for c in party: c.attack() – drei verschiedene Angriffe
  • Duck Typing in Python
  • abstrakte Klassen mit ABC und @abstractmethod · Interfaces in Java
  • UML-Klassendiagramm: − privat, + öffentlich, Dreieck, Rauten, Multiplizitäten
  • fünf Prüfungsfallen
Auf YouTube ansehen
16:04

Folge 11

TCP/IP, OSI & Subnetze – Advanced

Das lernst du

  • Kapselung: HTTP in TCP in IP in Ethernet – wie Brief, Umschlag, Paket und Lastwagen
  • MAC-Adresse, Switch und ARP: «Wer hat 192.168.1.1?»
  • Subnetze: /24, /26 und /28 – Netzadresse = Adresse UND Maske
  • Dijkstra Schritt für Schritt: A–C–B–D–E mit 10 ms
  • TCP-Handshake SYN, SYN-ACK, ACK · UDP für Spiele und Videocalls
  • Ports 80, 443, 53, 22 und Sockets
  • DNS-Hierarchie und Caching · HTTP 200, 301, 404, 500
  • NAT, Portfreigabe und IPv6 mit 128 Bit
  • https://www.example.com: DNS → TCP → TLS → GET
  • fünf Prüfungsfallen
Auf YouTube ansehen
15:00

Folge 12

Datenbanken & SQL – Advanced

Das lernst du

  • Relation, Tupel, Attribut, Schlüsselkandidat, Domäne
  • ER-Modell: 1 : n mit Fremdschlüssel, n : m mit Zwischentabelle
  • SELECT … FROM … WHERE … ORDER BY, LIKE '%Potter%', BETWEEN, IN
  • COUNT, MIN, AVG, GROUP BY – und warum HAVING statt WHERE
  • INNER JOIN, LEFT JOIN und das Kreuzprodukt (9 × 6 = 54)
  • Ausleihen pro Buch Zeile für Zeile – auch mit 0
  • INSERT, UPDATE, DELETE – und DELETE ohne WHERE
  • Transaktionen mit COMMIT und ROLLBACK, ACID
  • Anomalien und 1., 2., 3. Normalform an der Ausleihliste
  • fünf Prüfungsfallen
Auf YouTube ansehen
15:29

Folge 13

Kryptografie: AES, RSA & Hashing – Advanced

Das lernst du

  • Vertraulichkeit, Integrität, Verfügbarkeit, Authentizität
  • Vigenère mit KEY und die Häufigkeitsanalyse (E ≈ 17 %)
  • XOR: 0101 ⊕ 1100 = 1001 und zurück · One-Time-Pad · AES mit 2¹²⁸ Schlüsseln
  • Diffie-Hellman mit Farben und mit p = 23, g = 5 → Geheimnis 2
  • RSA mit n = 55: 7 → 13 → 7
  • SHA-256: «Erklärbär» und «Erklärbar» – Lawineneffekt
  • Passwörter mit Salt, bcrypt und Argon2
  • digitale Signaturen und signierte Updates
  • TLS-Handshake, Zertifikate, Signal-Protokoll, Man-in-the-Middle
  • SQL-Injection und Prepared Statements · Post-Quanten-Kryptografie
  • fünf Prüfungsfallen
Auf YouTube ansehen
14:52

Folge 14

KI & Machine Learning – Advanced

Das lernst du

  • drei Lernarten: Labels, Gruppen, Belohnungen (Go, 2016)
  • Äpfel und Birnen im Merkmalsraum · k nächste Nachbarn mit k = 3
  • Daten aufteilen: 70 % Training, 15 % Validierung, 15 % Test
  • das Perzeptron: UND-Gatter mit Gewichten 1 und 1, Bias −1,5 · Lernregel Schritt für Schritt
  • XOR ist nicht linear trennbar – und wird mit ODER, NAND und UND doch gelöst
  • Gradientenabstieg: F(w) = (w − 3)², w = 0 → 0,6 → 1,08 → … · Lernrate zu gross, zu klein
  • Overfitting erkennen und früher aufhören
  • Spamfilter mit 1000 Mails: Genauigkeit 96 %, Präzision 75 %, Recall 90 %
  • CNNs, Transformer, Tokens und Aufmerksamkeit
  • Bias, Erklärbarkeit, Urheberrecht, Deepfakes und der EU AI Act
  • fünf Prüfungsfallen
Auf YouTube ansehen
14:03

Folge 15

Rechner mit Parser & Stack bauen – Advanced

Das lernst du

  • Architektur wie im Compiler: Lexer → Parser → Auswerter · Klassendiagramm
  • der Lexer als endlicher Automat: «3,5» und «3.5», Operatoren, Klammern, Vorzeichen
  • Postfix (UPN): 3 4 2 1 − · + ohne Klammern – Auswertung mit einem Stack
  • Shunting-Yard (Dijkstra, 1961) Zeichen für Zeichen für 3 + 4 · (2 − 1)
  • Linksassoziativität: 8 − 2 − 3 = 3 · Potenzen rechtsassoziativ: 2 ^ 3 ^ 2 = 512
  • rekursiver Abstieg: expression, term, factor – Aufrufbaum für (3 + 4) · 2
  • eigene Ausnahmen, decimal statt float – und warum eval() tabu ist
  • Unit-Tests mit unittest: 10 Fälle, davon 3 Fehlerfälle
  • fünf Prüfungsfallen
Auf YouTube ansehen
13:17

Folge 16

Datenbank-App mit SQL & Python – Advanced

Das lernst du

  • Anforderungen → ER-Modell mit sechs Entitäten, 3. Normalform
  • PRIMARY KEY, FOREIGN KEY, NOT NULL, UNIQUE, CHECK – und PRAGMA foreign_keys = ON
  • überfällige Ausleihen, Top 5, nie ausgeliehen (LEFT JOIN), Unterabfrage mit NOT IN
  • die Python-App mit sqlite3 und einer Klasse LibraryRepository
  • SQL-Injection am eigenen Übungsprojekt – und warum Platzhalter schützen
  • Passwörter mit Salt und scrypt, Rollen für Lehrperson und Schüler
  • EXPLAIN QUERY PLAN: SCAN gegen SEARCH USING INDEX – bei uns rund 13× schneller
  • Transaktionen: COMMIT, ROLLBACK, alles oder nichts
  • «Wer dieses Buch lieh, lieh auch …» mit einem Self-Join
  • fünf Prüfungsfallen
Auf YouTube ansehen
15:31

Folge 17

Eigene CPU bauen – Advanced

Das lernst du

  • der Bauplan: Bus, Register, ALU, Speicher, Befehlszähler, Befehlsregister, Takt
  • die ALU: 8 Volladdierer, XOR-Reihe und Zweierkomplement – 4 − 1 mit derselben Schaltung
  • der Befehlssatz: 1 Byte = 4 Bit Opcode + 4 Bit Adresse · LDA 14 = 0x1E · JZ 8 = 0x78
  • das Steuerwerk: Mikroschritte T0 bis T4, Steuersignale im ROM, ein Automat
  • das Programm: 3 · 4 ohne Multiplizierbefehl, als Schleife in 11 Bytes
  • Takt für Takt: die erste Runde mit leuchtendem Bus, dann Zeitraffer bis zur 12
  • 5 · 7: nur zwei Bytes ändern → 35 = 0x23
  • Grenzen und echte CPUs: 64 Bit, Caches, Pipeline, ARM, RISC-V, FPGA
  • fünf Prüfungsfallen
Auf YouTube ansehen