Python erweitert

Assembler.md

@@ -0,0 +1,106 @@
+# Assembler
+
+## Die Maschine
+
+### Was ist eine CPU
+
+Die CPU (Central Processing Unit) ist das Gehirn des Computers. Aber im Gegensatz zu einem menschlichen Gehirn ist sie tatsächlich sehr einfach. Sie tut nur eine Sache: Sie liest Anweisungen aus dem Speicher und führt sie eine nach der anderen sehr schnell aus. Wenn du Assembly-Code schreibst, gibst du der CPU direkte Anweisungen.
+
+Im Gegensatz zu Hochsprachen wie Python oder JavaScript, die Hardwaredetails verbergen, ermöglicht dir Assemblersprache, genau zu steuern, was die CPU Schritt für Schritt tut. 
+
+Stell dir die CPU als einen sehr schnellen Arbeiter vor, der:
+
+- Nicht selbstständig denken oder Entscheidungen treffen kann
+- Einfache Befehle wie „add these two numbers“ oder „move this value there“ befolgt
+- Jede Sekunde Millionen solcher einfachen Befehle ausführt
+
+Im Inneren der CPU gibt es winzige Speicherboxen, die **Register** genannt werden. Ein Register enthält eine einzelne Zahl. Die CPU kann auf Register extrem schnell zugreifen, viel schneller als auf den Hauptspeicher (RAM).
+
+Die CPU verfügt außerdem über ein spezielles Register namens **Program Counter (PC)**. Der PC enthält die Speicheradresse der nächsten auszuführenden Anweisung. Nach jeder Anweisung wechselt der PC automatisch zur nächsten Adresse.
+
+**Wichtige Fakten über eine CPU:**
+
+| Fakt                                              | Erklärung                                                      |
+| ------------------------------------------------- | -------------------------------------------------------------- |
+| Sie führt jeweils eine Anweisung aus              | Kein Multitasking auf Hardwareebene                            |
+| Sie versteht nur Zahlen                           | Alles (Anweisungen, Daten, Adressen) ist eine Zahl             |
+| Sie hat keinen eigenen Speicher (außer Registern) | Alles muss im RAM gespeichert werden                           |
+| Sie ist unglaublich schnell                       | Moderne CPUs führen Milliarden von Anweisungen pro Sekunde aus |
+
+### Speicher
+
+In der vorherigen Lektion hast du gelernt, dass die CPU Anweisungen eine nach der anderen ausführt. Aber wo werden diese Anweisungen gespeichert? Wo bewahrt die CPU die Daten auf, die sie verarbeiten muss?
+
+Die Antwort lautet **Speicher** (auch RAM genannt: Random Access Memory).
+
+Der Speicher ist wie ein riesiges Raster aus nummerierten Speicherplätzen. Jeder Speicherplatz hat eine eindeutige **Adresse** (wie eine Hausnummer) und kann ein Byte an Daten aufnehmen (eine Zahl von 0 bis 255). Wenn du etwas im Speicher speicherst, legst du es in einem bestimmten Speicherplatz mit einer bestimmten Adresse ab. Wenn du es wieder benötigst, rufst du die Daten an dieser Adresse ab.
+
+**Stell dir den Speicher wie ein Postamt mit nummerierten Postfächern vor:**
+
+- Jedes Fach hat eine eindeutige Nummer (die Adresse)
+- Jedes Fach kann einen Brief aufnehmen (ein Byte an Daten)
+- Du kannst einen Brief in jedes beliebige Fach legen
+- Du kannst jedes beliebige Fach öffnen und lesen, was sich darin befindet
+
+Die CPU kann die Daten an der Adresse 1000 anfordern, und der Speicher gibt sie zurück. Die CPU kann auch neue Daten an die Adresse 1000 schreiben und damit die zuvor dort vorhandenen Daten ersetzen.
+
+**Wichtige Fakten über den Speicher:**
+
+| Fakt                              | Erklärung                                                                                     |
+| --------------------------------- | --------------------------------------------------------------------------------------------- |
+| Jedes Byte hat eine Adresse       | Adressen beginnen bei 0 und reichen bis zu Millionen oder Milliarden                          |
+| Der Speicher ist flüchtig         | Wenn du den Computer ausschaltest, verschwindet alles im RAM                                  |
+| Lesen zerstört keine Daten        | Du kannst die Adresse 1000 eine Million Mal lesen, und sie enthält weiterhin denselben Wert   |
+| Schreiben überschreibt alte Daten | Wenn du neue Daten an die Adresse 1000 schreibst, sind die alten Daten für immer verschwunden |
+
+## Wie Befehle funktionieren
+
+Du weißt, dass die CPU Anweisungen eine nach der anderen ausführt. Aber woher weiß die CPU, welche Anweisung als Nächstes ausgeführt werden soll? Wo werden die Anweisungen gespeichert? Und wie sieht eine Anweisung eigentlich aus?
+
+**Anweisungen sind Zahlen.**
+
+Dies ist eine grundlegende Wahrheit über Computer. Alles ist eine Zahl. Die Daten, mit denen du arbeitest (wie die Zahl 42), sind eine Zahl. Die Adresse, an der die Daten gespeichert sind (wie 1000), ist eine Zahl. Und auch die Anweisungen selbst (wie `mov`, `add`, `cmp`) sind Zahlen.
+
+Wenn du Assemblercode wie `mov rax, 5` schreibst, wandelt der Assembler diesen für Menschen lesbaren Text in eine Zahl um, die die CPU versteht. Diese Zahl wird **Instruktionscode** genannt.
+
+**Wo werden Anweisungen gespeichert?**
+
+Anweisungen werden wie Daten im Speicher gespeichert. Es gibt keinen speziellen Ort für Anweisungen. Der Speicher enthält beides:
+
+- **Daten** (Zahlen, Zeichen, Arrays)
+- **Anweisungen** (das Programm selbst)
+
+Die CPU kennt den Unterschied nicht. Sie liest einfach, was sich an der Speicheradresse befindet, auf die der Program Counter zeigt. Du hast im Abschnitt 0.1 kurz etwas über den PC gelernt. Nun ist es an der Zeit, genau zu verstehen, wie er funktioniert.
+
+Der <mark>Program Counter</mark> (auch Instruction Pointer genannt) ist ein spezielles Register innerhalb der CPU. Seine einzige Aufgabe besteht darin, die <mark>Speicheradresse der nächsten auszuführenden Anweisung</mark> zu speichern.
+
+**Der Fetch-Execute-Zyklus:**
+
+Die CPU wiederholt diese drei Schritte für immer:
+
+| Schritt    | Was passiert                                         |
+| ---------- | ---------------------------------------------------- |
+| 1. FETCH   | Die Anweisung an der in PC angegebenen Adresse lesen |
+| 2. EXECUTE | Diese Anweisung ausführen                            |
+| 3. ADVANCE | PC zur nächsten Anweisung weiterbewegen              |
+
+**Einfaches Beispiel:**
+
+Wenn PC = 1000 ist, führt die CPU Folgendes aus:
+
+- Ruft die Anweisung an der Adresse 1000 ab
+- Führt sie aus
+- Verschiebt PC zur nächsten Adresse (1000 + Größe der Anweisung)
+
+Dann wird es mit dem neuen PC-Wert wiederholt.
+
+**Wie eine Instruktion aussieht:**
+
+Jede Instruktion besteht aus zwei Teilen:
+
+| Teil      | Was sie tut                       | Beispiel               |
+| --------- | --------------------------------- | ---------------------- |
+| Opcode    | Was AUSGEFÜHRT werden soll        | `mov`, `add`, `cmp`    |
+| Operanden | WORAUF sie angewendet werden soll | `rax`, `5`, `[result]` |
+
+Einige Anweisungen haben einen Operanden (wie `inc rax`, um 1 zu addieren). Einige haben zwei (wie `mov rax, 5`). Einige haben drei (wie `add rax, rbx, rcx` in manchen Architekturen).

Codesnippets.md

@@ -0,0 +1,51 @@
+# Codesnippets
+
+## PHP
+
+### IPV4 --> CIDR
+
+```php
+function subnetMaskToCidr(string $mask): int
+{
+    $long = ip2long($mask);
+
+    if ($long === false) {
+        throw new InvalidArgumentException("Ungültige Subnetzmaske");
+    }
+    
+    $cidr = 0;
+    
+    for ($i = 31; $i >= 0; $i--) {
+        if (($long & (1 << $i)) !== 0) {
+            $cidr++;
+        } else {
+            break;
+        }
+    }
+    
+    return $cidr;
+
+}
+```
+
+oder
+
+```php  
+function subnetMaskToCidr(string $mask): int
+{
+    $octets = explode('.', $mask);
+    $cidr = 0;
+
+    foreach ($octets as $octet) {
+        while ($octet > 0) {
+            $cidr++;
+            $octet &= $octet - 1;
+        }
+    }
+    
+    return $cidr;
+
+}
+```
+
+

Docker 2.md

@@ -0,0 +1,114 @@
+# Docker
+
+## Was ist Docker
+
+**Docker** ist ein Tool, um eine Anwendung zusammen mit allem, was sie zum Ausführen benötigt (Code, Bibliotheken, Einstellungen), in einer einzigen Einheit namens **Container** zu verpacken.
+
+Ein Container läuft immer auf die gleiche Weise, egal ob auf Ihrem Laptop, dem Rechner eines Teamkollegen oder einem Server in der Cloud. Dies löst das klassische „Auf meinem Rechner funktioniert es“-Problem.
+
+Sie steuern Docker über das Terminal mit dem `docker`-Befehl.
+
+Um zu prüfen, ob Docker verfügbar ist und um die Version anzuzeigen, führen Sie folgenden Befehl aus:
+
+```bash
+docker --version
+```
+
+Dies gibt die installierte Docker-Version aus und bestätigt, dass das Tool einsatzbereit ist.
+
+## Images und Container
+
+Docker hat zwei Kernkonzepte, die zusammenarbeiten: **Images** und **Container**.
+
+Ein **Image** ist eine schreibgeschützte Vorlage (ein Snapshot eines Dateisystems plus Anweisungen dazu, was ausgeführt werden soll). <mark>Ein **Container** ist eine laufende Instanz</mark>, die aus einem Image erstellt wurde. Ein Image kann viele Container starten, so wie eine Klasse viele Objekte erstellen kann.
+
+Der einfachste Weg, dies zu sehen, besteht darin, einen Container aus dem `hello-world` Image auszuführen:
+
+```bash
+docker run hello-world
+```
+
+Docker nimmt das `hello-world` Image, startet einen Container daraus, und der Container gibt eine kurze Willkommensnachricht aus, bevor er beendet wird.
+
+## Images pullen
+
+Bevor Sie einen Container ausführen können, benötigt Docker das Image auf Ihrem Rechner. Der Befehl `docker pull` lädt ein Image aus einer Registry (einer öffentlichen Bibliothek von Images) herunter:
+
+```bash
+docker pull alpine
+```
+
+Docker ruft das Image ab und meldet jede Ebene, sobald sie eintrifft, und schließt mit einer Statuszeile ab. Wenn Sie keine Version angeben, lädt Docker standardmäßig den Tag **latest** herunter.
+
+Sie können eine spezifische Version mit `image:tag` anfordern:
+
+```bash
+docker pull alpine:3.20
+```
+
+Das Pulling eines bereits vorhandenen Images bestätigt <mark>lediglich</mark>, dass es <mark>aktuell</mark> ist, anstatt es erneut herunterzuladen.
+
+## Images auflisten
+
+Um zu sehen, welche Images lokal verfügbar sind, verwendet man `docker images`:
+
+```bash
+docker images
+```
+
+Die Ausgabe ist eine Tabelle mit einer Zeile pro Image:
+
+```bash
+REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
+alpine       latest    c8be21c88f2a   1 day ago     7.34MB
+ubuntu       latest    75afc20638b6   4 days ago    81.8MB
+```
+
+- **REPOSITORY** und **TAG** benennen das Image
+- **IMAGE ID** ist eine kurze eindeutige Kennung
+- **SIZE** gibt an, wie viel Speicherplatz das Image belegt
+
+Um die Liste auf ein Repository einzugrenzen, übergibt man dessen Namen: 
+
+`docker images alpine` zeigt nur die `alpine`-Tags an.
+
+## Images taggen
+
+Ein **Tag** ist eine benutzerfreundliche Bezeichnung, die auf ein Image verweist. Der Befehl `docker tag` gibt einem bestehenden Image einen zusätzlichen Namen:
+
+```bash
+docker tag alpine:3.21 myalpine:v1
+```
+
+Dies kopiert das Image nicht. Es erstellt einen neuen Namen, `myalpine:v1`, der auf dasselbe zugrunde liegende Image verweist wie `alpine:3.21`. Beide erscheinen nun in `docker images`.
+
+Das Format ist `docker tag SOURCE:TAG TARGET:TAG`. Mit Tags geben Sie Ihren eigenen Builds aussagekräftige Versionsnamen wie `v1`, `dev` oder `stable`.
+
+## Einen Befehl ausführen
+
+Man kann einem Container genau sagen, welcher Befehl ausgeführt werden soll, indem man ihn nach dem Imagenamen hinzufügt:
+
+```bash
+docker run alpine echo "hello from a container"
+```
+
+Docker startet einen Container aus dem `alpine`-Image, führt darin `echo "hello from a container"` aus, gibt die Ausgabe aus und beendet anschließend den Container. Die Struktur lautet:
+
+```bash
+docker run IMAGE COMMAND [ARGUMENTS]
+```
+
+Dies ist das alltägliche Muster für die Verwendung eines Containers als Wegwerfumgebung: Starten, ausführen eines Befehls und stoppen.
+
+### Echte Ausführung
+
+Befehle innerhalb eines Containers werden tatsächlich ausgeführt und nicht nur als vorgetäuschte Ausgabe wiedergegeben. Du kannst das beweisen, indem du dem Container eine Shell und ein kleines Skript übergibst:
+
+```bash
+docker run alpine sh -c "echo abc | tr a-z A-Z"
+docker run alpine sh -c "seq 3"
+```
+
+Hier führt `sh -c` eine Shell-Befehlszeichenfolge innerhalb des Containers aus. Die Shell leitet `abc` an `tr` weiter, was es in Großbuchstaben umwandelt, sodass die Ausgabe `ABC` ist.
+
+Das bedeutet, dass Sie Pipes, Variablen und die Befehlszeilenwerkzeuge, die Sie bereits kennen, direkt im Container verwenden können.

LaTeX_Typst.md

@@ -0,0 +1,442 @@
+# LaTeX -- Typst
+
+## Griechische Buchstaben
+
+### kleine griechische Buchstaben
+
+| LaTeX         | Vorschau      | Typst                  |
+|:------------- | ------------- | ---------------------- |
+| `\alpha`      | $\alpha$      | alpha                  |
+| `\beta`       | $\beta$       | beta                   |
+| `\gamma`      | $\gamma$      | gamma                  |
+| `\delta`      | $\delta$      | delta                  |
+| `\epsilon`    | $\epsilon$    | epsilon.alt            |
+| `\zeta`       | $\zeta$       | zeta                   |
+| `\eta`        | $\eta$        | eta                    |
+| `\theta`      | $\theta$      | theta                  |
+| `\iota`       | $\iota$       | iota                   |
+| `\kappa`      | $\kappa$      | kappa                  |
+| `\lambda`     | $\lambda$     | lambda                 |
+| `\mu`         | $\mu$         | mu                     |
+| `\nu`         | $\nu$         | nu                     |
+| `\xi`         | $\xi$         | xi                     |
+| `\omicron`    | $\omicron$    | omnicron               |
+| `\pi`         | $\pi$         | pi                     |
+| `\rho`        | $\rho$        | rho                    |
+| `\sigma`      | $\sigma$      | sigma                  |
+| `\tau`        | $\tau$        | tau                    |
+| `\upsilon`    | $\upsilon$    | upsilon   <—- bis hier |
+| `\phi`        | $\phi$        | phi.alt                |
+| `\chi`        | $\chi$        | chi                    |
+| `\psi`        | $\rho$        | rho                    |
+| `\omega`      | $\omega$      | omega                  |
+| `\varepsilon` | $\varepsilon$ | epsilion               |
+| `\vartheta`   | $\vartheta$   | theta.alt              |
+| `\varpi`      | $\varpi$      | pi.alt                 |
+| `\varrho`     | $\varrho$     | rho.alt                |
+| `\varsigma`   | $\varsigma$   | sigma.alt              |
+| `\varphi`     | $\varphi$     | phi                    |
+
+### Grosse griechische Buchstaben 
+
+| LaTeX      | Vorschau   | Typst   |
+| :--------- | ---------- | ------- |
+| `\Gamma`   | $\Gamma$   | Gamma   |
+| `\Delta`   | $\Delta$   | Delta   |
+| `\Theta`   | $\Theta$   | Theta   |
+| `\Lambda`  | $\Lambda$  | Lambda  |
+| `\Xi`      | $\Xi$      | Xi      |
+| `\Pi`      | $\Pi$      | Pi      |
+| `\Sigma`   | $\Sigma$   | Sigma   |
+| `\Upsilon` | $\Upsilon$ | Upsilon |
+| `\Phi`     | $\Phi$     | Phi     |
+| `\Psi`     | $\Psi$     | Psi     |
+| `\Omega`   | $\Omega$   | Omega   |
+
+### Integral
+
+| LaTeX      | Vorschau   | Typst   |
+| :--------- | ---------- | ------- |
+| `\int_a^b f(x) \mathrm{d} x`   | $\int_a^b f(x) \mathrm{d} x$   | integral_a^b f(x) dif x  |
+| `\int` | $\int$ | integral |
+| `\oint` | $\oint$ | integral.cont |
+| `\iint` | $\iint$ | integral.double |
+| `\oiint` | $\oiint$ | integral.surf |
+| `\iiint` | $\iiint$ | integral.triple |
+| `\oiiint` | $\oiiint$ | integral.vol |
+
+### Fonts
+
+| LaTeX            | Vorschau         | Typst   |
+| :--------------- | ---------------- | ------- |
+| `\boldsymbol{A}` | $\boldsymbol{A}$ | bold(A) |
+| `\mathbb{A}`     | $\mathbb{A}$     | AA      |
+| `\mathbf{A}`     | $\mathbf{A}$     | upright(bold(A))      |
+| `\mathcal{A}`     | $\mathcal{A}$   | cal(A)      |
+| `\mathscr{A}`  | $\mathscr{A}$      | scr(A)       |
+| `\mathit{A}`   | $\mathit{A}$   | italic(A)        |
+| `\mathfrak{A}` | $\mathfrak{A}$     | frak(A)          |
+| `\mathrm{A}`   | $\mathrm{A}$     | upright(A)       |
+| `\mathsf{A}`   | $\mathsf{A}$     | sans(A)          |
+| `\mathtt{A}`   | $\mathtt{A}$     | mono(A)          |
+
+## Arrows
+| LaTeX                 | Preview               | Typst (Textual)       | Typst (Shorthand) |
+| --------------------- | --------------------- | --------------------- | ----------------- |
+| `\leftarrow`          | $\leftarrow$          | arrow.l               | <-                |
+| `\gets`               | $\gets$               | arrow.l               | <-                |
+| `\rightarrow`         | $\rightarrow$         | arrow.r               | ->                |
+| `\to`                 | $\to$                 | arrow.r               | ->                |
+| `\leftrightarrow`     | $\leftrightarrow$     | arrow.l.r             | <->               |
+| `\Leftarrow`          | $\Leftarrow$          | arrow.l.double        |                   |
+| `\Rightarrow`         | $\Rightarrow$         | arrow.r.double        | =>                |
+| `\Leftrightarrow`     | $\Leftrightarrow$     | arrow.l.r.double      | <=>               |
+| `\mapsto`             | $\mapsto$             | arrow.r.bar           | ->                |
+| `\hookleftarrow`      | $\hookleftarrow$      | arrow.l.hook          |                   |
+| `\leftharpoonup`      | $\leftharpoonup$      | harpoon.lt            |                   |
+| `\leftharpoondown`    | $\leftharpoondown$    | harpoon.lb            |                   |
+| `\rightleftharpoons`  | $\rightleftharpoons$  | harpoons.rtlb         |                   |
+| `\longleftarrow`      | $\longleftarrow$      | arrow.l.long          | <--               |
+| `\longrightarrow`     | $\longrightarrow$     | arrow.r.long          | -->               |
+| `\longleftrightarrow` | $\longleftrightarrow$ | arrow.l.r.long        | <-->              |
+| `\Longleftarrow`      | $\Longleftarrow$      | arrow.l.double.long   | <==               |
+| `\Longrightarrow`     | $\Longrightarrow$     | arrow.r.double.long   | ==>               |
+| `\Longleftrightarrow` | $\Longleftrightarrow$ | arrow.l.r.double.long | <==>              |
+| `\longmapsto`         | $\longmapsto$         | arrow.r.long.bar      |                   |
+| `\hookrightarrow`     | $\hookrightarrow$     | arrow.r.hook          |                   |
+| `\rightharpoonup`     | $\rightharpoonup$     | harpoon.rt            |                   |
+| `\rightharpoondown`   | $\rightharpoondown$   | harpoon.rb            |                   |
+| `\iff`                | $\iff$                | arrow.l.r.double.long | <==>              |
+| `\implies`            | $\implies$            | arrow.r.double.long   | ==>               |
+| `\uparrow`            | $\uparrow$            | arrow.t               |                   |
+| `\downarrow`          | $\downarrow$          | arrow.b               |                   |
+| `\updownarrow`        | $\updownarrow$        | arrow.t.b             |                   |
+| `\Uparrow`            | $\Uparrow$            | arrow.t.double        |                   |
+| `\Downarrow`          | $\Downarrow$          | arrow.b.double        |                   |
+| `\Updownarrow`        | $\Updownarrow$        | arrow.t.b.double      |                   |
+| `\nearrow`            | $\nearrow$            | arrow.tr              |                   |
+| `\searrow`            | $\searrow$            | arrow.br              |                   |
+| `\swarrow`            | $\swarrow$            | arrow.bl              |                   |
+| `\nwarrow`            | $\nwarrow$            | arrow.tl              |                   |
+| `\leadsto`            | $\leadsto$            | arrow.r.squiggly      | ~>                |
+| `\leftleftarrows`     | $\leftleftarrows$     | arrows.ll             |                   |
+| `\rightrightarrows`   | $\rightleftarrows$    | arrows.rr             |                   |
+## Set and Elements
+
+| LaTeX         | Preview       | Typst     |
+| ------------- | ------------- | --------- |
+| `\in`         | $\in$         | in        |
+| `\subset`     | $\subset$     | subset    |
+| `\subseteq`   | $\subseteq$   | subset.eq |
+| `\supset`     | $\supset$     | supset    |
+| `\supseteq`   | $\supseteq$   | supset.eq |
+| `\varnothing` | $\varnothing$ | diameter  |
+
+## Non-mathematical Symbols
+
+| LaTeX        | Preview      | Typst     |
+| ------------ | ------------ | --------- |
+| `\$`         | $\$$         | \\$       |
+| `\pounds`    | $\pounds$    | pound     |
+| `\yen`       | $\yen$       | yen       |
+| `\copyright` | $\copyright$ | copyright |
+| `\S`         | $\S$         | section   |
+| `\P`         | $\P$         | pilcrow   |
+
+## Verschiedene Symbole
+
+| LaTeX    | Preview  | Typst (Textual) | Typst (Shorthand) |
+| -------- | -------- | --------------- | ----------------- |
+| `\Cap`   | $\Cap$   | inter.double    |                   |
+| `\Cup`   | $\Cup$   | union.double    |                   |
+| `\Join`  | $\Join$  | join            |                   |
+| `\aleph` | $\aleph$ | alef            |                   |
+|          |          |                 |                   |
+
+# Temp
+
+## Miscellaneous Symbols
+
+| LaTeX                | Preview | Typst (Textual)    | Typst (Shorthand) |
+| -------------------- | ------- | ------------------ | ----------------- |
+| `\angle`             | ∠       | `angle`            | ``                |
+| `\approx`            | ≈       | `approx`           | ``                |
+| `\approxeq`          | ≊       | `approx.eq`        | ``                |
+| `\ast`               | ∗       | `ast`              | ``                |
+| `\bigcap`            | ⋂       | `inter.big`        | ``                |
+| `\bigcirc`           | ◯       | `circle.big`       | ``                |
+| `\bigcup`            | ⋃       | `union.big`        | ``                |
+| `\bigodot`           | ⨀       | `dot.o.big`        | ``                |
+| `\bigoplus`          | ⨁       | `xor.big`          | ``                |
+| `\bigotimes`         | ⨂       | `times.o.big`      | ``                |
+| `\bigsqcup`          | ⨆       | `union.sq.big`     | ``                |
+| `\bigtriangledown`   | ▽       | `triangle.b`       | ``                |
+| `\bigtriangleup`     | △       | `triangle.t`       | ``                |
+| `\biguplus`          | ⨄       | `union.plus.big`   | ``                |
+| `\bigvee`            | ⋁       | `or.big`           | ``                |
+| `\bigwedge`          | ⋀       | `and.big`          | ``                |
+| `\bullet`            | ∙       | `bullet`           | ``                |
+| `\cap`               | ∩       | `inter`            | ``                |
+| `\cdot`              | ⋅       | `dot.op`           | ``                |
+| `\cdots`             | ⋯       | `dots.c`           | ``                |
+| `\checkmark`         | ✓       | `checkmark`        | ``                |
+| `\circ`              | ∘       | `circle.small`     | ``                |
+| `\colon`             | :       | `colon`            | ``                |
+| `\cong`              | ≅       | `tilde.equiv`      | ``                |
+| `\coprod`            | ∐       | `product.co`       | ``                |
+| `\cup`               | ∪       | `union`            | ``                |
+| `\curlyvee`          | ⋎       | `or.curly`         | ``                |
+| `\curlywedge`        | ⋏       | `and.curly`        | ``                |
+| `\dagger`            | †       | `dagger`           | ``                |
+| `\dashv`             | ⊣       | `tack.l`           | ``                |
+| `\ddagger`           | ‡       | `dagger.double`    | ``                |
+| `\ddots`             | ⋱       | `dots.down`        | ``                |
+| `\diamond`           | ⋄       | `diamond`          | ``                |
+| `\div`               | ÷       | `div`              | ``                |
+| `\divideontimes`     | ⋇       | `times.div`        | ``                |
+| `\dotplus`           | ∔       | `plus.dot`         | ``                |
+| `\ell`               | ℓ       | `ell`              | ``                |
+| `\emptyset`          | ∅       | `nothing`          | ``                |
+| `\equiv`             | ≡       | `equiv`            | ``                |
+| `\exists`            | ∃       | `exists`           | ``                |
+| `\forall`            | ∀       | `forall`           | ``                |
+| `\ge`                | ≥       | `gt.eq`            | `>=`              |
+| `\geq`               | ≥       | `gt.eq`            | `>=`              |
+| `\geqslant`          | ⩾       | `gt.eq.slant`      | ``                |
+| `\gg`                | ≫       | `gt.double`        | `>>`              |
+| `\hbar`              | ℏ       | `planck`           | ``                |
+| `\imath`             | **     | `dotless.i`        | ``                |
+| `\infty`             | ∞       | `infinity`         | `oo`              |
+| `\intercal`          | ⊺       | `top`              | ``                |
+| `\jmath`             | **     | `dotless.j`        | ``                |
+| `\land`              | ∧       | `and`              | ``                |
+| `\langle`            | ⟨       | `chevron.l`        | ``                |
+| `\lbrace`            | {       | `brace.l`          | ``                |
+| `\lbrack`            | [       | `bracket.l`        | ``                |
+| `\ldots`             | …       | `dots.l`           | ``                |
+| `\le`                | ≤       | `lt.eq`            | `<=`              |
+| `\leftthreetimes`    | ⋋       | `times.three.l`    | ``                |
+| `\leq`               | ≤       | `lt.eq`            | `<=`              |
+| `\leqslant`          | ⩽       | `lt.eq.slant`      | ``                |
+| `\lhd`               | ⊲       | `triangle.l`       | ``                |
+| `\ll`                | ≪       | `lt.double`        | `<<`              |
+| `\ltimes`            | ⋉       | `times.l`          | ``                |
+| `\measuredangle`     | ∡       | `angle.arc`        | ``                |
+| `\mid`               | ∣       | `divides`          | ``                |
+| `\models`            | ⊨       | `models`           | ``                |
+| `\mp`                | ∓       | `minus.plus`       | ``                |
+| `\nRightarrow`       | ⇏       | `arrow.double.not` | ``                |
+| `\nabla`             | ∇       | `nabla`            | ``                |
+| `\ncong`             | ≆       | `tilde.nequiv`     | ``                |
+| `\ne`                | =      | `eq.not`           | `!=`              |
+| `\neg`               | ¬       | `not`              | ``                |
+| `\neq`               | =      | `eq.not`           | `!=`              |
+| `\nexists`           | ∄       | `exists.not`       | ``                |
+| `\ngeq`              | ≱       | `gt.eq.not`        | ``                |
+| `\ni`                | ∋       | `in.rev`           | ``                |
+| `\nleftarrow`        | ↚       | `arrow.l.not`      | ``                |
+| `\nleq`              | ≰       | `lt.eq.not`        | ``                |
+| `\nparallel`         | ∦       | `parallel.not`     | ``                |
+| `\nmid`              | ∤       | `divides.not`      | ``                |
+| `\notin`             | ∈/      | `in.not`           | ``                |
+| `\nrightarrow`       | ↛       | `arrow.not`        | ``                |
+| `\nsim`              | ≁       | `tilde.not`        | ``                |
+| `\nsubseteq`         | ⊈       | `subset.eq.not`    | ``                |
+| `\ntriangleleft`     | ⋪       | `lt.tri.not`       | ``                |
+| `\ntriangleright`    | ⋫       | `gt.tri.not`       | ``                |
+| `\odot`              | ⊙       | `dot.o`            | ``                |
+| `\ominus`            | ⊖       | `minus.o`          | ``                |
+| `\oplus`             | ⊕       | `xor`              | ``                |
+| `\otimes`            | ⊗       | `times.o`          | ``                |
+| `\parallel`          | ∥       | `parallel`         | ``                |
+| `\partial`           | ∂       | `partial`          | ``                |
+| `\perp`              | ⊥       | `perp`             | ``                |
+| `\pm`                | ±       | `plus.minus`       | ``                |
+| `\prec`              | ≺       | `prec`             | ``                |
+| `\preceq`            | ⪯       | `prec.eq`          | ``                |
+| `\prime`             | ′       | `prime`            | ``                |
+| `\prod`              | ∏       | `product`          | ``                |
+| `\propto`            | ∝       | `prop`             | ``                |
+| `\rangle`            | ⟩       | `chevron.r`        | ``                |
+| `\rbrace`            | }       | `brace.r`          | ``                |
+| `\rbrack`            | ]       | `bracket.r`        | ``                |
+| `\rhd`               | ⊳       | `triangle`         | ``                |
+| `\rightthreetimes`   | ⋌       | `times.three.r`    | ``                |
+| `\rtimes`            | ⋊       | `times.r`          | ``                |
+| `\setminus`          | ∖       | `without`          | ``                |
+| `\sim`               | ∼       | `tilde`            | ``                |
+| `\simeq`             | ≃       | `tilde.eq`         | ``                |
+| `\smallsetminus`     | ∖       | `without`          | ``                |
+| `\spadesuit`         | ♠       | `suit.spade`       | ``                |
+| `\sqcap`             | ⊓       | `inter.sq`         | ``                |
+| `\sqcup`             | ⊔       | `union.sq`         | ``                |
+| `\sqsubseteq`        | ⊑       | `subset.eq.sq`     | ``                |
+| `\sqsupseteq`        | ⊒       | `supset.eq.sq`     | ``                |
+| `\star`              | ⋆       | `star`             | ``                |
+| `\subsetneq`         | ⊊       | `subset.neq`       | ``                |
+| `\succ`              | ≻       | `succ`             | ``                |
+| `\succeq`            | ⪰       | `succ.eq`          | ``                |
+| `\sum`               | ∑       | `sum`              | ``                |
+| `\supsetneq`         | ⊋       | `supset.neq`       | ``                |
+| `\times`             | ×       | `times`            | ``                |
+| `\top`               | ⊤       | `top`              | ``                |
+| `\triangle`          | △       | `triangle.t`       | ``                |
+| `\triangledown`      | ▽       | `triangle.b.small` | ``                |
+| `\triangleleft`      | ◃       | `triangle.l.small` | ``                |
+| `\triangleright`     | ▹       | `triangle.r.small` | ``                |
+| `\twoheadrightarrow` | ↠       | `arrow.r.twohead`  | `->>`             |
+| `\upharpoonright`    | ↾       | `harpoon.tr`       | ``                |
+| `\uplus`             | ⊎       | `union.plus`       | ``                |
+| `\vdash`             | ⊢       | `tack.r`           | ``                |
+| `\vdots`             | ⋮       | `dots.v`           | ``                |
+| `\vee`               | ∨       | `or`               | ``                |
+| `\wedge`             | ∧       | `and`              | ``                |
+| `\wr`                | ≀       | `wreath`           |                   |
+
+
+
+# Implementing LaTeX macros unsupported by Typst
+
+## Background
+
+There is not always a Typst equivalent for every LaTeX macro. This document provides a guide on how to implement unsupported LaTeX macros in Typst.
+
+## The `\mathscr` macro
+
+`scr` is natively supported in Typst since version 0.14.0! [[1\]](https://qwinsi.github.io/tex2typst-webapp/impl-in-typst.html#fn1)
+
+## The `\LaTeX` and `\TeX` macro
+
+LaTeX: `\LaTeX` and `\TeX`
+
+Implementation in Typst [[2\]](https://qwinsi.github.io/tex2typst-webapp/impl-in-typst.html#fn2)
+
+```
+#let TeX = context {
+  set text(font: "New Computer Modern")
+  let e = measure("E")
+  let T = "T"
+  let E = text(1em, baseline: e.height * 0.31, "E")
+  let X = "X"
+  box(T + h(-0.15em) + E + h(-0.125em) + X)
+}
+
+#let LaTeX = context {
+  set text(font: "New Computer Modern")
+  let a-size = 0.66em
+  let l = measure("L")
+  let a = measure(text(a-size, "A"))
+  let L = "L"
+  let A = box(scale(x: 105%, text(a-size, baseline: a.height - l.height, "A")))
+  box(L + h(-a.width * 0.67) + A + h(-a.width * 0.25) + TeX)
+}
+```
+
+Usage example:
+
+```
+You can use #LaTeX in text environments.
+You can use $#LaTeX$ in math environments as well.
+```
+
+## Using the `op` function to define custom operators
+
+For example, if you want to define a custom operator `\myopr`.
+
+LaTeX: `\newcommand{\myopr}{\operatorname{myopr}}`
+
+Equivalent in Typst:
+
+```
+#let myopr = op("myopr");
+```
+
+Usage example:
+
+```
+$
+y = myopr x
+$
+```
+
+## A vertical bar for evaluation
+
+It's common to use a vertical bar to denote the evaluation of a function at a point. e.g.
+
+
+
+➣ LaTeX:
+
+```
+f(x) \bigg\rvert_{x = x_0}
+```
+
+Where `\bigg\rvert` may be replaced with `\bigg\vert`, `\bigg|` etc.
+
+➣ Walkaround in Typst:
+
+```
+f(x) lr(| vec(delim: #none, , , x = x_0))
+```
+
+Also it's common to use a vertical bar to denote the deference of function values at two points, especially when calculating definite integrals. e.g. [[3\]](https://qwinsi.github.io/tex2typst-webapp/impl-in-typst.html#fn3)
+
+
+
+➣ LaTeX:
+
+```
+F(x) \bigg\rvert_{a}^{b}
+```
+
+Where `\bigg\rvert` may be replaced with `\bigg\vert` , `\bigg|` etc.
+
+➣ Walkaround in Typst:
+
+```
+F(x) lr(| vec(delim: #none, b, , a))
+```
+
+## The `\cancelto` macro
+
+`\cancelto{value}{expression}` is a LaTeX command provided by the `cancel` package. It is used to place an arrow through an expression and annotate it with a value to which the expression is be evaluated.
+
+
+
+➣ LaTeX:
+
+```
+\cancelto{0}{\frac{\partial^2 Q}{\partial r^2}}
+```
+
+➣ Implementation in Typst (adapted from [[4\]](https://qwinsi.github.io/tex2typst-webapp/impl-in-typst.html#fn4) ):
+
+```
+#let cancelto(to, body) = {
+  let max(a, b) = if a > b { a } else { b };
+  context {
+    let m = measure(body)
+    let (w, h) = (m.width, m.height * 2)
+    let arrow = rotate(-55deg, math.stretch(sym.arrow.r, size: max(h*1.8, w*2.0)))
+    set place(center + horizon)
+    body
+    place(dx: -w * 0.5, dy: -h * 0.1, arrow)
+    place(dx: w * 0.3, dy: -h * 1.1, to)
+  }
+}
+```
+
+➣ Usage example:
+
+```
+$
+cancelto(0, (partial^2 Q)/(partial r^2))
+$
+```
+
+
+
+
+
+https://qwinsi.github.io/tex2typst-webapp/cheat-sheet.html
+

Linux-Sammelsurium.md

@@ -531,8 +531,6 @@ openssl req -new -days 1095 -key dlsea3tim01.server.key -out dlsea3tim01.server.
 
 openssl req -text -in dlsea3tim01.server.csr|less
 
-
-
 Bei Apache/mod_ssl ist der Unterschied:
 
 - **`SSLCertificateFile`** → enthält das **öffentliche Zertifikat** des Servers. Darin stecken u. a. der öffentliche Schlüssel, Domainname und die Signatur der CA. Dieses Zertifikat wird beim TLS-Handshake an den Client geschickt.
@@ -557,8 +555,6 @@ Dies sind optionale Flags, die das Verhalten des SCP-Befehls verändern. Sie kö
 **-v:** Ausführlicher Modus – zeigt Debugging-Meldungen während der Übertragung an.  
 **-o:** Übergibt eine Option an den SSH-Client. Sie kann verwendet werden, um die strenge Prüfung des Hostschlüssels zu deaktivieren.
 
-
-
 # Linux: `/etc/passwd` und `/etc/shadow`
 
 Unter Linux werden Benutzerinformationen hauptsächlich in den Dateien `/etc/passwd` und `/etc/shadow` gespeichert.
@@ -1016,3 +1012,7 @@ Zusammengefasst:
 ## Merksatz
 
 > **`/etc/passwd` beschreibt den Benutzer, `/etc/shadow` beschreibt vor allem seinen Passwort- und Ablaufstatus.**
+
+###############
+
+Änderungen an Profil-Dateien wie `~/.bashrc` erfordern eine neue Shell-Sitzung oder das explizite Ausführen von `source ~/.bashrc`, damit sie in der aktuellen Sitzung wirksam werden.

Lisp.md

@@ -0,0 +1,62 @@
+# Lisp
+
+## Variablen
+
+### Globale Variablen
+
+#### defparameter
+
+**`defparameter`**: Definiert eine globale Variable und weist ihr sofort einen Wert zu. Ein erneutes Laden überschreibt den Wert.
+
+```lisp
+(defparameter *Variable* Wert)
+```
+
+**Beispiel**
+
+```lisp
+(defparamter *a* 10)
+
+defparameter *name* "Otto")
+
+(+ *a*  *b*)
+```
+
+#### defvar
+
+**`defvar`**: Definiert eine globale Variable, setzt den Anfangswert aber nur, wenn sie noch keinen Wert hat. Überschreibt bestehende Werte beim Neuladen *nicht*.
+
+```lisp
+(defvar *Variable* Wert )
+```
+
+Beispiel
+
+```lisp
+(defvar *b*  101)
+```
+
+#### setq / setf
+
+**`setq` / `setf`**: Ändert den Wert einer bereits existierenden Variablen oder erzeugt (in manchen Lisp-Dialekten) implizit eine globale Variable, was jedoch unsauber ist. `setf` ist der universelle Zuweisungsoperator.
+
+`setq` - einfache Variablenzuweisung
+
+
+
+setf - allgemeine Zuweisung
+
+`setf` kann nicht nur Variablen setzen, sondern praktisch alles, wofür Lisp eine passende **Schreibstelle (place)** kennt:
+
+(setf *mein-wert* 100)
+
+
+
+### Lokale Variablen
+
+
+https://www.heise.de/blog/Lisp-lernen-Teil-1-Primzahlen-berechnen-3077388.html
+https://gigamonkeys.com/book/
+https://portacle.github.io/#get-mac
+https://github.com/rabbibotton/clog
+https://docs.google.com/presentation/d/16egmnPGA88RVOl0zhurxw6uLnA86v-lBe_SHZA7CWOg/edit?slide=id.gd400d95397ceaa_18#slide=id.gd400d95397ceaa_18

Massmatics/Massmatics.md

@@ -0,0 +1,20 @@
+## Mengenoperationen
+
+Hat man zwei oder mehrere Mengen gegeben, so kann man diese mit folgenden Operationen zusammenfassen:
+1. Vereinigung: “∪”
+2. Schnitt: “∩”
+3. Differenz: “∖”
+Das kartesische Produkt wird gesondert [hier](https://www.massmatics.de/merkzettel/#!16:Das_kartesische_Produkt_von_Mengen) behandelt. Ebenso das [Komplement einer Menge](https://www.massmatics.de/merkzettel/#!260:Komplement_einer_Menge)
+Wie man sich die Mengenoperationen grafisch veranschaulicht wird im Artikel zu den [Venn-Diagrammen](https://www.massmatics.de/merkzettel/#!262:Venn_Diagramme) behandelt.
+
+Zu den vorgestellten Operationen gibt es auch Regeln, wie man mit Klammern und mehreren verschiedenen Verknüpfungen umgeht - [diese findest du hier](https://www.massmatics.de/merkzettel/#!263:Rechenregeln_fuer_Mengen).
+## Vereinigung von Mengen
+
+Die Vereinigung von Mengen betrachtet alle Elemente die in der einen oder der anderen Menge enthalten sind.
+
+Sobald ein Element also in einer der beiden Mengen A oder B liegt, ist es automatisch auch in A∪B enthalten.
+
+Als Venn-Diagramm kann man diese Operation so darstellen. Die Vereinigung der beiden Mengen A und B:
+
+<img src="./Grafiken/t_14_0.png" style="zoom:33%;" />
+

Python.md

@@ -0,0 +1,215 @@
+# Python
+
+# Variablen
+
+### Zahlen
+
+**Variablen** sind Container, die Datenwerte enthalten. Sie werden verwendet, um Informationen innerhalb eines Programms zu speichern, zu bearbeiten und anzuzeigen.
+
+Kurz gesagt ist eine Variable wie eine Speichereinheit, auf die wir zugreifen können, indem wir den Namen der Variable eingeben. 
+
+Jede Variable hat einen eindeutigen **Namen** und einen **Wert** , der von unterschiedlichen Typen sein kann. Python kann den Variablentyp automatisch erkennen, wodurch das Programmieren effizienter wird.
+
+Um eine Variable zu initialisieren, verwenden wir das folgende **Format**:
+
+```python
+variable_name = value
+```
+
+Sehen wir uns die verschiedenen Zahlentypen an:
+
+`int` – eine Ganzzahl, wie etwa `1` oder `-2`.
+
+`float` – reelle Zahl, zum Beispiel `1.32` oder `0.98`.
+
+Zum Beispiel:
+
+Um eine Variable vom Typ `int` mit dem Namen `a` und dem Wert `3` zu initialisieren:
+
+```python
+a = 3
+```
+
+Um eine Variable vom Typ `float` mit dem Namen `b` und dem Wert `13.2` zu initialisieren:
+
+```python
+b = 13.2
+```
+
+**Hinweis:** Variablennamen dürfen nicht mit einer Zahl beginnen. Verwende Unterstriche, um Wörter zu trennen (z. B. `player_name`), keine Leerzeichen oder Bindestriche..
+
+## Strings
+
+Ein **Zeichen** ist ein einzelner Buchstabe, eine einzelne Ziffer oder ein einzelnes Symbol (zum Beispiel: 1, 6, %, b, p, ., T usw.). Python hat keinen separaten `char`-Typ: Ein einzelnes Zeichen ist einfach eine Zeichenkette der Länge 1.
+
+Der Typ **str** (Zeichenkette) ist eine Folge aus einem oder mehreren Zeichen.
+
+Um einen Zeichenfolgenwert in einer Variablen zu initialisieren, schließe ihn in einfache oder doppelte Anführungszeichen ein:
+
+```python
+s1 = 'This is a string's2 = "This is also a string"
+```
+
+Im obigen Beispiel werden zwei Zeichenfolgenvariablen initialisiert, die `s1` und `s2` heißen.
+
+## Boolean
+
+Ein **bool** (Boolean) Typ hat nur 2 mögliche Werte: `True` oder `False`.
+
+Beachten Sie, dass bei diesen Werten die **Groß-/Kleinschreibung beachtet werden muss** (case-sensitive), was bedeutet, dass sie mit einem Großbuchstaben beginnen müssen.
+
+Hier ist ein Beispiel für die Zuweisung eines booleschen Werts zu einer Variable:
+
+```python
+variable_true = Truevariable_false = False
+```
+
+Oben werden zwei Variablen namens `variable_true` und `variable_false` mit den Werten `True` bzw. `False` initialisiert.
+
+> Booleans sind die Bausteine für das Erstellen von Logik in den Programmen, die wir schreiben. Wir haben ein ganzes Kapitel über Logik und Bedingungen.
+
+## Benennungskonventionen
+
+Namenskonventionen sind eine Reihe von Richtlinien, denen Entwickler folgen, um ihren Code lesbarer und wartbarer zu machen. Verschiedene Programmiersprachen haben oft unterschiedliche Namenskonventionen. In Python werden Variablen in `snake case` geschrieben – Wörter werden durch Unterstriche getrennt.
+
+Beim Schreiben eines Variablennamens sei **beschreibend** und verwende **aussagekräftige** Wörter
+
+### Zum Beispiel 
+
+```python
+# Schlechte Namensgebung
+isActive = False # nicht im Snake-Case-Format
+a = 10
+b = "Hello"
+x = True
+# Gute Namensgebung
+age = 10
+greeting = "Hello"
+is_active = True
+```
+
+## Leere Variablen
+
+In Python ist `None` ein spezieller Wert, der „nichts“ oder „kein Wert“ darstellt. Es ist wie eine leere Box – sie existiert, aber in ihr befindet sich nichts. Zum Beispiel:
+
+```python
+empty_box = None
+```
+
+In einem realen Szenario könntest du `None` verwenden, um anzuzeigen, dass etwas noch nicht initialisiert wurde.
+
+Zum Beispiel:
+
+```python
+score = None  # Score wurde noch nicht berechnet
+name = None   # Name wurde noch nicht eingegeben 
+```
+
+**Hinweis:** `None` ist _nicht_ dasselbe wie `0`, eine leere Zeichenfolge `""` oder `False`. Das sind tatsächliche Werte: null, leerer Text und falsch. `None` bedeutet, dass _überhaupt kein Wert_ vorhanden ist. Das Fehlen eines Werts ist kein Fehler; es bedeutet einfach, dass bisher nichts zugewiesen wurde.
+
+`0` ist ein echter numerischer Wert, zum Beispiel eine Punktzahl von genau null, während `None` bedeutet, dass überhaupt kein Wert vorhanden ist, etwa eine Punktzahl, die noch nicht berechnet wurde. Ein häufiges Missverständnis ist, dass `0` „nichts“ bedeutet, aber in Python steht nur `None` tatsächlich für das Fehlen eines Werts. Ebenso sind `""` (leere Zeichenkette) und `False` weiterhin echte Werte ihrer jeweiligen Typen. Sie sind nicht dasselbe wie `None`.
+
+Die Verwendung von `None` signalisiert, dass die Variable als Platzhalter existiert, aber noch keinen sinnvollen berechneten Wert enthält.
+## Arithmetische Operatoren
+
+**Operatoren** werden verwendet, um Operationen mit Werten durchzuführen. 
+
+Zuerst besprechen wir die grundlegendsten **arithmetischen Operatoren**, die dir vielleicht aus dem Mathematikunterricht bekannt sind.
+
+|Operator|Operation|Beispiel|
+|---|---|---|
+|+|Addition|3 + 2 = 5|
+|-|Subtraktion|3 - 2 = 1|
+|*|Multiplikation|3 * 2 = 6|
+|/|Division|4 / 2 = 2.0|
+
+Sehen wir uns ein Anwendungsbeispiel an.
+
+```python
+a = 3
+b = 5
+c = a + b # c hält 8
+```
+
+Wenn ein Ausdruck mehrere Operatoren enthält, folgt Python der in der Mathematik verwendeten Reihenfolge: Multiplikation und Division werden vor Addition und Subtraktion berechnet, und alles innerhalb von Klammern wird zuerst berechnet.
+
+```python
+z = 7 + 3 * 2   # z hat den Wert 13, weil 3 * 2 zuerst berechnet wird
+z = (7 + 3) * 2 # z hat den Wert 20
+```
+### Challenge
+
+Schreibe einen Code, der zwei Variablen, `a` und `b`, mit den Werten `5.2` bzw. `2.6` initialisiert.
+
+Initialisiere danach eine weitere Variable `c`, die das Ergebnis von `a / b` enthält.
+
+```python
+a = 5.2
+b = 2.6
+c = a / b
+
+print(f"a = {a}, b = {b}, c = {c}");
+```
+## Modulo-Operator
+
+Der Modulo-Operator `%` gibt an, was nach der Division einer Zahl durch eine andere übrig bleibt.
+
+```python
+result = dividend % divisor
+```
+
+- **dividend:** Die zu teilende Zahl.
+- **divisor:** Die Zahl, durch die der Dividend geteilt wird.
+- **result:** Der Rest der Division.
+
+Zum Beispiel
+
+```python
+result = 10 % 3
+```
+
+Hier wird 10 durch 3 geteilt. 3 passt dreimal in 10, mit einem Rest von 1. Somit wird `result` 1 sein.
+
+Normalerweise wird Modulo verwendet, um zu prüfen, ob eine Zahl gerade oder ungerade ist:
+
+- Wenn eine Zahl gerade ist, lässt die Division durch 2 einen Rest von 0.
+- Wenn eine Zahl ungerade ist, lässt die Division durch 2 einen Rest von 1.
+
+Um dies im Code zu prüfen, verwenden wir den `==` Operator, der prüft, ob zwei Werte zueinander **gleich** sind. Zum Beispiel fragt `result == 0` „ist `result` gleich 0?“
+
+**Sonderfall:** Wenn der Dividend kleiner als der Divisor ist, ist das Ergebnis einfach der Dividend selbst.
+
+Zum Beispiel:  
+`5 % 8 = 5`  
+Warum? Da die 8 nicht einmal in die 5 passt, bleibt die gesamte 5 als Rest übrig.
+
+### Challenge
+
+Schreibe einen Code, der drei Variablen, `a`, `b` und `c` mit den Werten `9`, `2` und `11` (beziehungsweise) initialisiert.
+
+Initialisiere danach die folgenden Variablen:
+
+- `d`, die das Ergebnis von `a` Modulo `2` enthalten wird
+- `e`, die das Ergebnis von `b` Modulo `3` enthalten wird
+- `f`, die das Ergebnis von `c` Modulo `10` enthalten wird
+
+Sieh dir das Ergebnis an und beobachte, wie sich unterschiedliche Dividenden und Divisoren auf das Ergebnis auswirken.
+
+
+```python
+a = 9
+b = 2
+c = 11
+d = a % 2
+e = b % 3
+f = c % 10
+
+# Ändern Sie die folgende Zeile nicht
+
+print(f"a = {a}")
+print(f"b = {b}")
+print(f"c = {c}")
+print(f"d = {d}")
+print(f"e = {e}")
+print(f"f = {f}")
+```

Racket.md

@@ -0,0 +1,21 @@
+```racket
+#lang racket
+
+; https://dev.to/goober99/learn-racket-by-example-gui-programming-3epm
+
+(require racket/gui/base)
+
+; 1. Hauptfenster (Frame) erstellen
+(define frame (new frame% [label "Hallo Racket"]
+                          [width 300]
+                          [height 200]))
+
+; 2. Einen Button zum Fenster hinzufügen
+(define btn (new button% [parent frame]
+                         [label "Klick mich"]
+                         [callback (lambda (b e)
+                                     (printf "Button wurde geklickt!\n"))]))
+
+; 3. Fenster sichtbar machen
+(send frame show #t)
+```

Regular Expressions Cheat Sheet.md

@@ -0,0 +1,211 @@
+# Regular Expressions Cheat Sheet
+
+A regular expression specifies a set of strings that matches it. This cheat sheet is based off Python 3's Regular Expressions (http://docs.python.org/3/library/re.html) but is designed for searches within Sublime Text.
+
+https://gist.github.com/IsaacCisneros/d7f3cf4bf6c0573d0570
+
+https://ahkde.github.io/docs/v1/misc/RegEx-QuickRef.htm
+
+https://serverdiscounter.com/blog/2026-01-26-regex-grundlagen
+
+
+
+## Special Characters
+
+|          |                                                                                 |                                                                           |
+| :------: | :------------------------------------------------------------------------------ | :------------------------------------------------------------------------ |
+|   `\`    | Escapet Sonderzeichen oder kennzeichnet eine spezielle Sequenz                  |                                                                           |
+|   `.`    | Entspricht einem beliebigen einzelnen Zeichen mit Ausnahme eines Zeilenumbruchs |                                                                           |
+|   `^`    | Matches the start of the string.                                                |                                                                           |
+|   `$`    | Matches the end of the string​                                                  |                                                                           |
+|   `*`    | Greedily matches 0 or more repetitions of the preceding RE.                     |                                                                           |
+|   `*?`   | Matches 0 or more repetitions of the preceding RE.                              |                                                                           |
+|   `+`    | Greedily matches 1 or more repetitions of the preceding RE.                     |                                                                           |
+|   `+?`   | Matches 1 or more repetitions of the preceding RE.                              |                                                                           |
+|   `?`    | Greedily matches 0 or 1 repetitions of the preceding RE.                        |                                                                           |
+|   `??`   | Matches 0 or 1 repetitions of the preceding RE.                                 |                                                                           |
+|  `A\|B`  | Matches A, if A is unmatched then matches B, where A and B are arbitrary REs.   |                                                                           |
+|  `{m}`   | Matches exactly m many repetitions of the previous RE.                          |                                                                           |
+| `{m,n}`  | Greedily matches from m many to n many repetitions of the previous RE.          |                                                                           |
+| `{m,n}?` | Matches m many to n many repetitions of the previous RE.                        |                                                                           |
+| `[...]`  | Indicates a set of characters to match.                                         |                                                                           |
+|          | `[amk]`                                                                         | Matches 'a', 'm', or 'k'.                                                 |
+|          | `[a-z]`                                                                         | Matches 'a' through 'z'.                                                  |
+|          | `[a-f0-7]`                                                                      | Matches 'a' through 'f' or '0' through '7'.                               |
+|          | `[a\-z]`                                                                        | Matches 'a', '-', or 'z'.                                                 |
+|          | `[a-]`                                                                          | Matches 'a' or '-'.                                                       |
+|          | `[-a]`                                                                          | Matches 'a' or '-'.                                                       |
+|          | `[(+*)]`                                                                        | Matches '(', '+', '*', or ')'. `[]` matches special characters literally. |
+
+​                   
+                    
+    [\w]                Matches the character class for '\w'. See character classes.
+    [^5]                Matches anything other than '5'. '^' forms the complementary set only as the first character in a set.
+    []()]                Matches ']', '(', and ')'. ']' is taken literally only as the first character in a set.
+    [()\]]                Matches ']', '(', and ')'.
+
+(...)            Matches the RE inside the parenthesis and assigns a new group.
+(?P<name>...)    The RE matched is accessible by the group indicated by name.
+
+(?...)            Extension notation which changes a RE's behavior. These do not assign a new group.
+    (?aiLmsux)            Sets the corresponding flag to each letter. Does not work within Sublime Text.
+    (?:...)                A non-capturing version of parenthesis. The matched substring cannot be retrieved later.
+    (?P=name)            Matches the substring matched by the group named name.
+    (?#...)                A comment, the contents are ignored.
+    (?=...)                Lookahead assertion, the preceding RE only matches if this matches.
+    (?!...)                Negative lookahead assestion, the preceding RE only matches if this doesn't match.
+    (?<=...)            Positive lookbehind assertion, the following RE will only match if preceeded with this fixed length RE.
+    (?<!...)            Negative lookbehind assertion, the following RE will only match if not preceeded with this fixed length RE.
+    (?(id)true|false)    If group id exists then uses the true RE, else use the false RE.
+
+>    Character classes
+> \1                Matches the contents of the group labelled by the same number. Acceptable numbers are 1-99.
+> \A                Matches at the start of the current string.
+> \b                Matches the empty string at the beginning or end of a word. \b matches the boundary between \w and \W.
+> \B                Matches the empty string not at the beginning or end of a word.
+> \d                Matches any Unicode decimal digit, including 0-9.
+> \D                Matches any Unicode non-decimal digit.
+> \s                Matches any Unicode whitespace character, including ' ', \t, \n, \r, \f and \v.
+> \S                Matches any Unicode non-whitespace character.
+> \w                Matches any Unicode word character, including a-z, A-Z, and 0-9.
+> \W                Matches any Unicode non-word character.
+> \Z                Matches at the end of the string.
+
+\a                Matches the ASCII Bell ().
+\f                Matches the ASCII Formfeed ().
+\n                Matches the ASCII Linefeed.
+\r                Matches the ASCII Carriage Return (
+).
+\t                Matches the ASCII Horizontal Tab.
+\v                Matches the ASCII Vertical Tab ().
+
+#########################
+
+### Regular Expression Cheat Sheet with Examples
+
+Regular Expressions (regex) are patterns used to match strings in text. Below is a cheat sheet with common regex patterns and examples.
+---
+
+### **1. Anchors**
+
+| Pattern | Description         | Example  | Matches        |
+| ------- | ------------------- | -------- | -------------- |
+| `^`     | Start of the string | `^Hello` | `Hello world!` |
+| `$`     | End of the string   | `world$` | `Hello world!` |
+
+---
+
+### **2. Quantifiers**
+
+| Pattern | Description                     | Example   | Matches                  |
+| ------- | ------------------------------- | --------- | ------------------------ |
+| `*`     | 0 or more                       | `a*`      | `aaa`, `b`               |
+| `+`     | 1 or more                       | `a+`      | `aaa`, but not `b`       |
+| `?`     | 0 or 1                          | `colou?r` | `color`, `colour`        |
+| `{n}`   | Exactly `n` occurrences         | `a{3}`    | `aaa`, but not `aa`      |
+| `{n,}`  | At least `n` occurrences        | `a{2,}`   | `aa`, `aaa`              |
+| `{n,m}` | Between `n` and `m` occurrences | `a{2,3}`  | `aa`, `aaa`, but not `a` |
+
+---
+
+### **3. Character Classes**
+
+| Pattern | Description                              | Example | Matches         |
+| ------- | ---------------------------------------- | ------- | --------------- |
+| `.`     | Any character except newline             | `a.b`   | `acb`, `a9b`    |
+| `\d`    | Any digit (0-9)                          | `\d+`   | `123`, `9`      |
+| `\D`    | Any non-digit                            | `\D+`   | `abc`, `@#`     |
+| `\w`    | Any word character (alphanumeric or `_`) | `\w+`   | `hello_123`     |
+| `\W`    | Any non-word character                   | `\W+`   | `@!`, ` #`      |
+| `\s`    | Any whitespace                           | `\s+`   | ` `, `\t`, `\n` |
+| `\S`    | Any non-whitespace                       | `\S+`   | `abc`, `123`    |
+
+---
+
+### **4. Logical OR and Grouping**
+
+| Pattern | Description | Example                 | Matches |
+| ------- | ----------- | ----------------------- | ------- |
+| `a      | b`          | Match either `a` or `b` | `cat    |
+| `(ab    | cd)`        | Grouping                | `(ab    |
+
+---
+
+### **5. Escape Characters**
+
+| Pattern | Description | Example   | Matches |
+| ------- | ----------- | --------- | ------- |
+| `\.`    | Literal dot | `a\.b`    | `a.b`   |
+| `\[`    | Literal `[` | `\[abc\]` | `[abc]` |
+
+---
+
+### **6. Ranges**
+
+| Pattern        | Description                 | Example  | Matches      |
+| -------------- | --------------------------- | -------- | ------------ |
+| `[a-z]`        | Lowercase letters           | `[a-z]+` | `abc`, `xyz` |
+| `[A-Z]`        | Uppercase letters           | `[A-Z]+` | `ABC`, `XYZ` |
+| `[0-9]`        | Digits                      | `[0-9]+` | `123`, `456` |
+| `[a-zA-Z0-9_]` | Alphanumeric and underscore | `\w+`    | `hello123_`  |
+
+---
+
+### **7. Special Sequences**
+
+| Pattern    | Description         | Example       | Matches           |
+| ---------- | ------------------- | ------------- | ----------------- |
+| `(?=...)`  | Positive lookahead  | `foo(?=bar)`  | `foo` in `foobar` |
+| `(?!...)`  | Negative lookahead  | `foo(?!bar)`  | `foo` in `foobaz` |
+| `(?<=...)` | Positive lookbehind | `(?<=foo)bar` | `bar` in `foobar` |
+| `(?<!...)` | Negative lookbehind | `(?<!foo)bar` | `bar` in `bazbar` |
+
+---
+
+### **8. Common Patterns**
+
+| Use Case                | Regex                                            | Example               |
+| ----------------------- | ------------------------------------------------ | --------------------- |
+| Match email             | `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}` | `user@example.com`    |
+| Match URL               | `https?://[^\s]+`                                | `https://example.com` |
+| Match phone number      | `\d{3}-\d{3}-\d{4}`                              | `123-456-7890`        |
+| Match date (YYYY-MM-DD) | `\d{4}-\d{2}-\d{2}`                              | `2024-12-13`          |
+
+---
+
+### **9. Flags**
+
+| Flag | Description      | Example                        |
+| ---- | ---------------- | ------------------------------ |
+| `i`  | Case-insensitive | `/hello/i` matches `Hello`     |
+| `g`  | Global match     | `/hello/g` matches all `hello` |
+| `m`  | Multiline        | `/^hello/m` matches per line   |
+
+---
+
+### **10. Examples in Code**
+
+#### Python Example:
+
+```python
+import re
+# Match an email
+pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
+email = "contact@example.com"
+print(re.match(pattern, email))  # Output: <re.Match object>
+```
+
+#### JavaScript Example:
+
+```javascript
+// Match a URL
+let pattern = /https?:\/\/[^\s]+/g;
+let text = "Visit https://example.com for more info.";
+console.log(text.match(pattern)); // Output: [ 'https://example.com' ]
+```
+
+ [regular-expressions-v2.pdf](regular-expressions-v2.pdf) 
+
+ [regular-expressions-cheat-sheet-v1.pdf](regular-expressions-cheat-sheet-v1.pdf) 
+
+ [regex-cheatsheet.pdf](regex-cheatsheet.pdf) 

Rust.md

@@ -0,0 +1,464 @@
+# Rust
+Rust ist eine moderne Systemprogrammiersprache, die mit Fokus auf Performance, Speichersicherheit und Nebenläufigkeit entwickelt wurde. Sie ermöglicht es Entwicklern, zuverlässige und effiziente Software zu erstellen, von Betriebssystemen bis hin zu Webanwendungen.
+
+## Hello World!
+Das „Hello World!“ ist ein einfaches Programm, das Hello World! auf dem Bildschirm ausgibt.
+
+In Rust verwenden wir das Makro `println!()`, um eine Ausgabe auf der Konsole auszugeben. Beachte, dass `println!` mit `ln` endet: einem Kleinbuchstaben l (wie in „line“), nicht mit einem Großbuchstaben I. Der auszugebende Text wird innerhalb doppelter Anführungszeichen platziert und in Klammern eingeschlossen.
+
+Sehen wir uns das „Hello World!“-Programm in Rust an:
+
+```rust
+fn main() {
+    println!(„Hello World!“);
+}
+```
+## Kommentare
+
+**Comments** sind Notizen, die man in den Code schreibt. Der compiler ignoriert sie vollständig – sie existieren nur, um Menschen beim Verständnis des Codes zu helfen.
+
+Um einen einzeiligen Kommentar zu schreiben, verwendet man `//`. Alles nach `//` bis zum Ende der Zeile wird ignoriert:
+
+```rust
+// Das ist ein Kommentarprintln!("Hello, world!");
+```
+
+Ein Kommentar kann auch am Ende einer Zeile nach dem Code geschrieben werden:
+
+```rust
+println!("Hello, world!"); // Dies gibt Hello, world! aus!
+```
+
+Für Kommentare, die sich über mehrere Zeilen erstrecken, verwendet man `/*`, um zu beginnen, und `*/`, um zu enden:
+
+```rust
+/* Dies ist ein mehrzeiliger Kommentar.   Der Compiler ignoriert ihn vollständig. */println!("Welcome!");
+```
+
+Kommentare können eine Codezeile auch vorübergehend **deaktivieren**, ohne sie zu löschen:
+
+```rust
+// println!("This line will NOT run");println!("This line will run");
+```
+
+**Hinweis:** Jeder mehrzeilige Kommentar, der mit `/*` beginnt, muss mit `*/` geschlossen werden, andernfalls behandelt der Compiler alles danach als Kommentar.
+
+Grundlegende Programmstruktur
+
+In Rust beginnt jedes ausführbare Programm mit der Funktion `main`. Diese Funktion ist der Einstiegspunkt des Programms und dort beginnt die Ausführung.
+
+Die `function` `main` wird mit dem Schlüsselwort `fn`definiert, gefolgt von `main` und einem Klammerpaar `()`. Der auszuführende Code wird innerhalb geschweifter Klammern `{}` platziert.
+
+Hier ist eine einfache Aufschlüsselung eines grundlegenden Rust-Programms:
+
+```rust
+fn main() { // Hauptfunktion    
+println!("Hello, Coddy!"); // Ausgabeanweisung}
+}
+```
+
+Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast.
+
+Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern {} eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen.
+
+## Grundlegende Programmstruktur
+
+In Rust beginnt jedes ausführbare Programm mit der Funktion `main`. Diese Funktion ist der Einstiegspunkt des Programms und dort beginnt die Ausführung.
+
+Die `function` `main` wird mit dem Schlüsselwort `fn`definiert, gefolgt von `main` und einem Klammerpaar `()`. Der auszuführende Code wird innerhalb geschweifter Klammern `{}` platziert.
+
+Hier ist eine einfache Aufschlüsselung eines grundlegenden Rust-Programms:
+
+```rust
+fn main() { // Hauptfunktion    
+	println!("Hello, Coddy!"); // Ausgabeanweisung
+}
+```
+
+Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast.
+
+Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern `{}` eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen.
+
+## Zahlen
+
+**Variablen** sind Container, die Datenwerte enthalten. Sie werden verwendet, um Informationen innerhalb eines Programms zu speichern, zu manipulieren und anzuzeigen.
+
+Kurz gesagt ist eine Variable wie eine Speichereinheit, auf die wir zugreifen können, indem wir den Namen der Variable eingeben. 
+
+Jede Variable hat einen eindeutigen **Namen** und einen **Wert**, der von unterschiedlichem Typ sein kann. Rust verfügt über verschiedene integrierte Datentypen, die den Typ des Wertes definieren, den eine Variable enthalten kann.
+
+Um eine Variable zu initialisieren, verwenden wir das folgende **Format**:
+
+```rust
+let variable_name: variable_type = value;
+```
+
+In Rust werden Zahlen normalerweise mit zwei Hauptdatentypen dargestellt: `i32` und `f64`.
+
+`i32` wird verwendet, um ganze Zahlen ohne Dezimalpunkt zu speichern. Zum Beispiel:
+
+```rust
+let age: i32 = 30;
+let temperature: i32 = -5;
+let count: i32 = 100;
+```
+
+`f64` wird verwendet, um Zahlen mit einem Dezimalpunkt zu speichern. Zum Beispiel:
+
+```rust
+let price: f64 = 99.99;
+let pi: f64 = 3.14159;
+let fraction: f64 = 0.5;
+```
+
+Beim Deklarieren von Variablen in Rust müssen Sie den Typ der Variable nach dem Variablennamen angeben, gefolgt von einem Doppelpunkt. Dies wird als **Typdeklaration** bezeichnet. Sobald eine Variable mit einem bestimmten Typ deklariert wurde, kann sie nur Werte dieses Typs enthalten.
+
+### Challenge
+
+Schreiben Sie ein Rust-Programm, das die folgenden Variablen deklariert und initialisiert:
+
+- Deklarieren Sie eine `i32`-Variable namens `quantity`und initialisieren Sie diese mit dem Wert `5`.
+- Deklarieren Sie eine `f64`-Variable namens `item_price`und initialisieren Sie diese mit dem Wert `24.99`.
+
+Nachdem Sie diese Variablen deklariert und initialisiert haben, verwenden Sie `println!()`, um die Werte der Variablen im folgenden Format auf der Konsole auszugeben:
+
+```rust
+Quantity: [value of quantity]
+Price: [value of item_price]
+```
+
+#### Lösung:
+```rust
+fn main() {
+// Variablen hier deklarieren und initialisieren
+let quantity: i32 = 5;
+let item_price: f64 = 24.99;
+
+println!("Quantity: {}", quantity);
+println!("Price: {}", item_price);
+}
+```
+
+## Char
+
+Ein **char** ist ein einzelnes Zeichen (Zum Beispiel: `1, 6, %, b, p, ., T`, etc.)
+
+Der **char**-Typ ist ein spezieller Typ, der aus einem einzelnen Zeichen besteht.
+
+Um einen char-Wert in einer Variablen zu initialisieren, schließen Sie ihn in **einfache Anführungszeichen** ein:
+
+```rust
+let c1: char = 'h';
+```
+
+Im obigen Beispiel wird eine char-Variable namens `c1`initialisiert.
+
+## String
+
+Ein **char** ist ein einzelnes Zeichen (Zum Beispiel: 1, 6, %, b, p, ., T, etc.)
+
+Der Typ **String** ist ein spezieller Typ, der aus mehreren **char**s besteht.
+
+Um einen String-Wert in einer Variablen zu initialisieren, schließen Sie ihn in **doppelte Anführungszeichen** ein:
+
+```rust
+let s1 = "This is a string";
+```
+
+Im obigen Beispiel wird eine String-Variable namens `s1` initialisiert.
+
+Anders als bei Zahlen müssen wir bei der Arbeit mit Strings vorsichtiger mit Typen sein.
+
+Wenn Sie explizit einen String-Typ deklarieren möchten, müssen Sie die Zeichenfolge wie folgt konvertieren:
+
+```rust
+let s1: String = "This is a string".to_string();
+```
+######################################################
+<mark style="background:#ff4d4f">Rust unterscheidet zwischen String-Literalen und dem Typ String, was eine explizite Konvertierung erfordert.</mark> noch beschreiben
+
+String-Literal --> normaler String a = "hhhh"
+######################################################
+### Challenge
+
+Speichere den String `I am learning to code with Coddy!` in einer Variable namens `coddy` unter Verwendung eines String-Literals (mit doppelten Anführungszeichen)..
+
+> Stelle sicher, dass du den **exakten** String-Wert mit korrekter Groß- und Kleinschreibung speicherst.
+
+
+```rust
+fn main() {
+
+let coddy = "I am learning to code with Coddy!".to_string();
+
+println!("coddy = \"{}\"", coddy);
+
+}
+```
+
+## Boolean
+
+Ein **boolescher** Typ hat nur 2 mögliche Werte: `true` oder `false`.
+
+Um einer Variablen einen booleschen Wert zuzuweisen, verwenden Sie das Schlüsselwort `let` gefolgt vom Variablennamen:
+
+```rust
+let variable_true: bool = true;
+let variable_false: bool = false;
+```
+
+Im obigen Beispiel werden zwei boolesche Variablen namens `variable_true` und `variable_false` jeweils mit den Werten `true` und `false` initialisiert.
+
+> Booleans sind die Bausteine für die Erstellung von Logik in den Programmen, die wir schreiben. Wir haben ein ganzes Kapitel über Logik und Bedingungen.
+
+## Veränderbare Variablen
+
+In Rust sind Variablen standardmäßig unveränderlich. Das bedeutet, dass man einen Wert, sobald er einer Variablen zugewiesen wurde, nicht mehr ändern kann. Man kann eine Variable jedoch veränderlich machen, indem man bei der Deklaration der Variablen das Schlüsselwort `mut` verwendet.
+
+Zum Beispiel:
+
+```rust
+let x = 5; // x ist unveränderlich
+let mut y = 10; // y ist veränderlich
+```
+
+In diesem Beispiel ist `x` unveränderlich, sodass Sie seinen Wert nach der Initialisierung nicht mehr ändern können. Andererseits ist `y` veränderlich, sodass Sie seinen Wert später im Code ändern können.
+
+```rust
+y = 20; // Dies ist erlaubt, da y veränderbar ist
+x = 15; // Dies wird einen Fehler verursachen, da 
+```
+
+### Challenge
+Deklariere eine veränderbare Variable namens `add` und weise ihr den Wert 13 zu.
+
+Ändere den Wert von 13 auf 16.
+### Lösung
+```rust
+#[allow(unused_assignments)]
+
+fn main() {
+// Variable add initialisieren
+let mut add = 13;
+
+// Wert von 13 auf 16 ändern
+add = 16;
+
+println!("add = {}", add);
+}
+```
+
+##  Typdeklaration
+
+Sobald eine Variable mit einem bestimmten Typ deklariert wurde, kann sie nur Werte dieses Typs enthalten. Beispielsweise kann eine `i32`-Variable nur Ganzzahlwerte enthalten, und eine `String`-Variable kann nur Text enthalten.
+
+Zum Beispiel:
+
+```rust
+let mut age: i32 = 25;  // Kann nur ganze Zahlen speichern
+let mut name: &str = "Alice";  // Kann nur Text speichern
+```
+
+Diese würden Fehler verursachen:
+
+```rust
+age = "Bob";  // Fehler: Text kann nicht in eine i32-Variable geschrieben werden
+name = 30;  // Fehler: Eine Zahl kann nicht in eine String-Variable geschrieben werden
+```
+
+Diese sind gültig:
+
+```rust
+age = 26;  // OK: Zuweisen einer neuen Ganzzahl
+name = "Jane";  // OK: Zuweisen einer neuen Textzeichenkette
+```
+
+### Challenge
+Deklariere die folgenden Variablen mit ihren entsprechenden Typen und Werten:
+
+- Eine `i32`-Variable namens `count` mit dem Wert `10`.
+- Eine `f64`-Variable namens `total` mit dem Wert `150.75`.
+- Eine `char`-Variable namens `grade` mit dem Wert `'A'`.
+- Eine `bool`-Variable namens `is_active` mit dem Wert `false`.
+- Eine `String`-Variable namens `user_name` mit dem Wert `"Bob123"`.
+
+Verwende nach der Deklaration dieser Variablen `println!()`, um die Werte der Variablen im folgenden Format auf der Konsole auszugeben:
+
+```rust
+Count: [value of count]
+Total: [value of total]
+Grade: [value of grade]
+Active: [value of is_active]
+User Name: [value of user_name]
+```
+
+### Lösung
+
+```rust
+fn main() {
+// Variablen hier deklarieren
+	let count: i32 = 10;
+	let total: f64 = 150.75;
+	let grade: char = 'A';
+	let is_active: bool = false;
+	let user_name: String = "Bob123".to_string();
+
+	println!("Count: {}", count);
+	println!("Total: {}", total);
+	println!("Grade: {}", grade);
+	println!("Active: {}", is_active);
+	println!("User Name: {}", user_name);
+}
+```
+
+## Namenskonventionen
+
+In Rust gibt es mehrere Benennungskonventionen, die Sie befolgen sollten, um Ihren Code lesbarer und wartbarer zu machen. Sie sind in der Rust-Community weitgehend akzeptiert.
+
+Hier sind einige gängige Namenskonventionen:
+
+- Variablen sollten mit `snake_case` benannt werden, was bedeutet, dass alle Buchstaben kleingeschrieben und Wörter durch Unterstriche getrennt werden. Zum Beispiel: `my_variable`, `calculate_total`.
+
+- Vermeiden Sie zu kurze oder kryptische Namen. Wählen Sie aussagekräftige Namen, die den Zweck der Variable klar angeben.
+
+- Namen können Buchstaben, Ziffern und Unterstriche enthalten.
+
+- Namen müssen mit einem Buchstaben oder einem Unterstrich `_` beginnen.
+
+- Einfache Zähler verwenden normalerweise einzelne Buchstaben wie `i`, `j`, obwohl es erwähnenswert ist, dass aussagekräftigere Namen besser sein könnten, wenn der Kontext komplexer ist.
+
+## Typinferenz
+
+In Rust ermöglicht die Typinferenz dem Compiler, den Typ einer Variablen basierend auf ihrem Wert und ihrer Verwendung automatisch abzuleiten. Das bedeutet, dass Sie den Typ beim Deklarieren einer Variablen oft nicht explizit angeben müssen, was Ihren Code prägnanter und leichter lesbar macht.
+
+Zum Beispiel:
+
+```rust
+let x = 5;// Rust leitet ab, dass x ein i32 ist
+let y = 3.14;// Rust leitet ab, dass y ein f64 ist
+let message = "Hello, world!";// Rust leitet ab, dass message ein &str (String) ist
+let is_true = true;// Rust leitet ab, dass is_true ein bool ist
+```
+
+In diesen Beispielen haben wir die Typen von `x`, `y`, `message` und `is_true` nicht angegeben. Der Rust-Compiler hat ihre Typen automatisch basierend auf den ihnen zugewiesenen Werten abgeleitet.
+
+Typinferenz ist nicht nur praktisch, sondern hilft auch dabei, Fehler zu vermeiden. Der Compiler prüft, wie die Variablen verwendet werden, und stellt sicher, dass die abgeleiteten Typen im gesamten Code konsistent sind. Wenn ein Konflikt auftritt, erzeugt der Compiler eine Fehlermeldung.
+### Challenge
+
+Schreibe ein Rust-Programm, das Typinferenz demonstriert. Deklariere und initialisiere die folgenden Variablen ohne explizite Typanmerkungen:
+
+- Eine Variable namens `quantity` mit dem Wert `10`.
+- Eine Variable namens `price` mit dem Wert `99.99`.
+- Eine Variable namens `message` mit dem Wert `"Coddy is awesome!"`.
+- Eine Variable namens `is_available` mit dem Wert `true`.
+
+Verwende nach der Deklaration dieser Variablen `println!()`, um ihre Werte auf der Konsole auszugeben. Beobachte, wie Rust die Typen dieser Variablen basierend auf ihren Werten ableitet.
+
+### Lösung
+
+```rust
+fn main() {
+// Variablen hier deklarieren
+let quantity = 10;
+let price = 99.99;
+let message = "Coddy is awesome!";
+let is_available = true;
+
+// Die Werte ausgeben
+println!("Quantity: {}", quantity);
+println!("Price: {}", price);
+println!("Message: {}", message);
+println!("Is available: {}", is_available);
+}
+```
+
+## Typumwandlung
+
+Typumwandlung bezeichnet den Vorgang, einen Wert von einem Datentyp in einen anderen umzuwandeln. In Rust verwenden wir das Schlüsselwort <mark style="background:#40a9ff">`as`</mark> für eine explizite Typumwandlung (auch als Typkonvertierung bezeichnet). 
+
+Die häufigsten Typumwandlungen finden zwischen numerischen Typen statt:
+
+```rust
+// Umwandlung von Integer zu Float
+let number: i32 = 5;
+let decimal: f64 = number as f64;// wird zu 5.0
+```
+
+```rust
+// Umwandlung von Gleitkommazahl in Ganzzahl
+let decimal: f64 = 9.7;
+let number: i32 = decimal as i32;// wird zu 9 (Dezimalteil wird abgeschnitten)
+```
+### Challenge
+Schreiben Sie ein Rust-Programm, das Typumwandlung demonstriert. Führen Sie die folgenden Operationen aus:
+
+1. Deklarieren Sie eine `f64`-Variable namens `price` und initialisieren Sie diese mit dem Wert `99.99`.
+2. Wandeln Sie die Variable `price` in einen `i32` um und speichern Sie das Ergebnis in einer neuen Variable namens `int_price`.
+3. Geben Sie die Werte von `price` und `int_price` auf der Konsole aus.
+
+```rust
+fn main() {
+// Variablen deklarieren und initialisieren
+let price: f64 = 99.99;
+let int_price: i32 = price as i32;
+
+// Die Werte ausgeben
+println!("Price: {}", price);
+println!("Int Price: {}", int_price);
+}
+```
+## Arithmetische Operatoren
+
+**Operatoren** werden verwendet, um Operationen auf Werten auszuführen.
+
+Zuerst werden wir die grundlegendsten **arithmetischen Operatoren** besprechen; sie sind Ihnen vielleicht aus dem Mathematikunterricht bekannt.
+
+| Operator | Operation      | Beispiel  |
+| -------- | -------------- | --------- |
+| +        | Addition       | 3 + 2 = 5 |
+| -        | Subtraktion    | 3 - 2 = 1 |
+| *        | Multiplikation | 3 * 2 = 6 |
+| /        | Division       | 4 / 2 = 2 |
+
+Sehen wir uns ein Verwendungsbeispiel an,
+
+```rust
+let a: i32 = 3;
+let b: i32 = 5;
+let c: i32 = a + b// c enthält 8
+```
+
+Beim Arbeiten mit Dezimalzahlen in Rust verwenden wir den Datentyp f64, der Zahlen mit Nachkommastellen speichern kann. Die gleichen arithmetischen Operatoren (+, -, *, /) funktionieren mit f64 genauso wie mit Ganzzahlen:
+
+```rust
+let x: f64 = 3.3;
+let y: f64 = 4.1;
+let z: f64 = x + y;// z enthält 7.4
+```
+### Challenge
+
+Schreibe einen Code, der zwei Variablen, `a` und `b`, mit den Werten `5.2` und `2.6` (in dieser Reihenfolge) initialisiert.
+
+Initialisiere danach eine weitere Variable `c`, die das Ergebnis von `a / b` enthalten wird.
+
+```rust
+fn main() {
+// Schreibe deinen Code unten
+let a: f64 = 5.2;
+let b: f64 = 2.6;
+let c: f64 = a / b;
+
+// Ändere die folgende Zeile nicht
+println!("a = {}, b = {}, c = {}", a, b, c);
+}
+```
+
+
+https://rust-lernen.de/blog/zeichenketten.html
+
+https://www.reddit.com/r/rust/comments/13wzjoq/media_difference_between_string_str_and_string/?tl=de#lightbox
+
+https://cheats.rs/#pointer-meta
+
+https://rust-lang-de.github.io/rustbook-de/title-page.html
+

SQL.md

@@ -194,6 +194,24 @@ Um anzugeben, wie diese Daten sortiert werden sollen, können wir die `DESC`- od
 
 `ORDER BY avg_speed ASC`
 
+## Datumsangaben behandeln
+
+Daten in SQL haben ein bestimmtes Format und wir können sie ähnlich wie Zahlen abfragen. Um ein Datum in einer Abfrage zu schreiben, verwendet man das Format: YYYY-MM-DD (2012-09-24)
+
+Um Datumsangaben abzufragen, kann man alle Operatoren verwenden, wie – größer (`>`), kleiner (`<`) oder gleich (`=`) innerhalb des Schlüsselworts WHERE:  
+
+```sql
+SELECT * FROM table1WHERE col1 > '2011-01-13'
+```
+
+Wir können sogar das Schlüsselwort BETWEEN verwenden:  
+
+```sql
+SELECT * FROM table1WHERE col1 BETWEEN '2010-01-01' AND '2010-02-25
+```
+
+#############################################################
+
 ## Eigenschaften einer Tabelle
 
 ```sql
@@ -518,31 +536,31 @@ Der Rest bei der Division durch 7 ist immer kleiner als 7 und reicht von 0 bis 6
 
 #####################################################
 
-Challenge zu modulo
+#### Challenge zu modulo
 
-> Verfügbare Tabellen und Spalten:
-> 
-> - `**products**`**:** `**id**`**,** `**price**`, `quantity`
-> - | products |     |       |          |
->   | -------- | --- | ----- | -------- |
->   |          | id  | price | quantity |
->   | 1        | 1   | 154   | 18       |
->   | 2        | 2   | 98    | 3        |
->   | 3        | 3   | 54    | 15       |
->   | 4        | 4   | 142   | 14       |
->   | 5        | 5   | 70    | 2        |
->   | 6        | 6   | 189   | 7        |
->   | 7        | 7   | 44    | 3        |
->   | 8        | 8   | 62    | 16       |
->   | 9        | 9   | 101   | 8        |
->   | 10       | 10  | 192   | 9        |
->   | 11       | 11  | 4     | 21       |
->   | 12       | 12  | 208   | 3        |
->   | 13       | 13  | 144   | 5        |
->   | 14       | 14  | 68    | 98       |
->   | 15       | 15  | 5     | 14       |
+Verfügbare Tabellen und Spalten:
 
-Erstellen Sie eine Abfrage, die:
+- `**products**`**:** `**id**`**,** `**price**`, `quantity`
+- Products
+
+| id                               | price | quantity |
+|:-------------------------------- |:----- |:-------- |
+| 1                                | 154   | 18       |
+| 2                                | 98    | 3        |
+| 3                                | 54    | 15       |
+| 4                                | 142   | 14       |
+| 5                                | 70    | 2        |
+| 6                                | 189   | 7        |
+| 7                                | 44    | 3        |
+| 8                                | 62    | 16       |
+| 9                                | 101   | 8        |
+| 10                               | 192   | 9        |
+| 11                               | 4     | 21       |
+| 12                               | 208   | 3        |
+| 13                               | 144   | 5        |
+| 14                               | 68    | 98       |
+| 15                               | 5     | 14       |
+| Erstellen Sie eine Abfrage, die: |       |          |
 
 1. Die Produkt-ID anzeigt
 2. Jedes Produkt einem von drei Qualitätskontrollteams (0, 1 oder 2) **basierend auf der Produkt-ID unter Verwendung des Modulo-Operators** zuweist; nennen Sie diese Spalte `quality_control`
@@ -575,7 +593,9 @@ ROUND(number, decimal_places)
 Zum Beispiel einfaches Runden auf ganze Zahlen:  
 
 ```sql
-SELECT ROUND(3.7);-- Returns 4.0SELECT ROUND(3.3);-- Returns 3.0SELECT ROUND(3.5);  -- Returns 4.0 (rounds up from .5)
+SELECT ROUND(3.7); -- Returns 4.0
+SELECT ROUND(3.3); -- Returns 3.0
+SELECT ROUND(3.5); -- Returns 4.0 (rounds up from .5)
 ```
 
 **Hinweis:** Die `ROUND()`-Funktion in SQLite gibt immer einen Fließkommawert (REAL) zurück. Aus diesem Grund enthalten die obigen Ergebnisse ein Komma bzw. einen Dezimalpunkt (z. B. 4.0 statt 4).
@@ -600,8 +620,10 @@ SELECT ROUND(3.14159, 2);-- Returns 3.14SELECT ROUND(3.14159, 1);-- Retur
 
 Prüfen, ob das General Log aktiviert ist:
 
+```sql
 SHOW VARIABLES LIKE 'general_log';
 SHOW VARIABLES LIKE 'log_output'
+```
 
 Oder beide Werte gemeinsam anzeigen:
 
@@ -920,13 +942,9 @@ next 100 rows only;
 
 ##############################################################
 
-Recap - Parliamentary Election
+## Recap - Parliamentary Election
 
-![challenge icon](https://coddy.tech/icons/challenge-white.svg)
-
-Challenge
-
-Einfach
+### Challenge
 
 > Verfügbare Tabellen und Spalten:
 > 
@@ -938,8 +956,673 @@ Das Ergebnis sollte nur die relevanten Sitze enthalten.
 
 Bevor Sie mit der Lösung der Herausforderung beginnen, werfen Sie einen Blick auf die Tabellendaten. **Sie sind nicht sauber**. Die Spalten `is_next_gov` und `is_spoke_bad` enthalten Einsen und Nullen sowie auch yes's und no's.
 
-
+| ministers |      |             |              |
+|:---------:| ---- | ----------- | ------------ |
+|           | seat | is_next_gov | is_spoke_bad |
+| 1         | 1    | 0           | 0            |
+| 2         | 2    | 0           | 1            |
+| 3         | 3    | yes         | no           |
+| 4         | 4    | no          | no           |
+| 5         | 5    | 1           | no           |
+| 6         | 6    | yes         | no           |
+| 7         | 7    | 1           | no           |
+| 8         | 8    | 0           | yes          |
+| 9         | 9    | 0           | 1            |
+| 10        | 10   | no          | 1            |
+| 11        | 11   | yes         | yes          |
+| 12        | 12   | 1           | 1            |
+| 13        | 13   | 1           | 1            |
+| 14        | 14   | 1           | 1            |
+| 15        | 15   | yes         | 0            |
+| 16        | 16   | 0           | 0            |
+| 17        | 17   | 0           | 0            |
+| 18        | 18   | 0           | no           |
+| 19        | 19   | 1           | yes          |
+| 20        | 20   | 1           | no           |
+| 21        | 21   | 0           | 0            |
+| 22        | 22   | 1           | 0            |
+| 23        | 23   | yes         | 1            |
+| 24        | 24   | yes         | 1            |
+| 25        | 25   | no          | yes          |
+| 26        | 26   | 1           | no           |
+| 27        | 27   | 0           | yes          |
+| 28        | 28   | yes         | no           |
+| 29        | 29   | no          | 0            |
+| 30        | 30   | yes         | 0            |
 
 select seat from ministers where (seat % 2 = 0) and (is_spoke_bad = 0 or is_spoke_bad = 'no' )and (is_next_gov = 1 or is_next_gov = 'yes');
 
 ##############################################################
+
+## Recap - Police Criminal Arrest
+
+### Challenge
+
+> Verfügbare Tabellen und Spalten:
+> 
+> - `**police_report**`**:** `**name**`**,** `**report**`**,** `**map**`**,** `**severe_score**`
+
+Rufe die Namen der **5 schwersten Kriminellen** ab und sortiere sie nach `severe_score` in absteigender Reihenfolge  
+Ein schwerer Krimineller ist jemand, der alle folgenden Kriterien erfüllt:
+
+- `report` ist entweder null oder `report` enthält einen der folgenden Buchstaben: `g`, `b`, `G` oder `B`.
+- `map` ist einer der folgenden Orte: `Caerleon`, `Dewsbury`, `Kirkwall`, `Findochty`.
+
+Benenne die Spalte als `worst_criminals`.
+
+| police_report |                   |        |               |              |
+|:-------------:| ----------------- | ------ | ------------- | ------------ |
+|               | name              | report | map           | severe_score |
+| 1             | Domingos Holden   | VYyPJw | Lockinge      | 2            |
+| 2             | Isabel Enid       |        | Findochty     | 7            |
+| 3             | Tadgán Musa       | FgDqud | Kara's Vale   | 10           |
+| 4             | Filip Baxter      | D1rJqH | Kirkwall      | 3            |
+| 5             | Edorta Elias      | pQ53RC | Dewsbury      | 9            |
+| 6             | Kəmal Davy        | BsI86j | Kara's Vale   | 2            |
+| 7             | Isokrates Bituin  |        | Findochty     | 5            |
+| 8             | Kassy Ramirus     | Pkjv7J | Kirkwall      | 7            |
+| 9             | Doris Blessing    | 0kJXq1 | Dalmerlington | 6            |
+| 10            | Nedeljka Ganesh   | EVe9ha | Kara's Vale   | 8            |
+| 11            | Karlene Timotheus | 2HUBHz | Dewsbury      | 7            |
+| 12            | Emerens Raman     | PAGdHl | Findochty     | 1            |
+| 13            | Mijo Ambrosios    |        | Luton         | 5            |
+| 14            | Karlene Jairus    | 4Z63Q5 | Dalmerlington | 8            |
+| 15            | Khordad Peter     |        | Findochty     | 2            |
+| 16            | Biagio Mai        |        | Findochty     | 9            |
+| 17            | Liwen Sigiward    | B51ETs | Mansfield     | 3            |
+| 18            | Svante Mona       | DC0kGh | Caerleon      | 5            |
+| 19            | Kshitija Ladislav | cSA0hA | Caerleon      | 2            |
+| 20            | Ha-Eun Tatiana    | YNYhHV | Kara's Vale   | 4            |
+
+```sql
+select name as worst_criminals from police_report where (report like '%g%' or report like '%b%' or report is null ) and map in ('Caerleon', 'Dewsbury', 'Kirkwall', 'Findochty') order by severe_score desc limit 5
+```
+
+## Recap - Bar Beverage Container
+
+### Challenge
+
+> Verfügbare Tabellen und Spalten:
+> 
+> - `**beverages**`**:** `**id**`**,** `**current_year**`**,** `**expiration_year**`
+
+Ihre Bar lagert eine umfangreiche Auswahl an Säften, und Sie müssen feststellen, welche davon Aufmerksamkeit benötigen. Identifizieren und sortieren Sie diese Säfte basierend auf den folgenden klaren Kriterien:
+
+1. `Old Expired Juices`
+   1. Säfte, deren Ablaufjahr MEHR als 6 Jahre vor dem aktuellen Jahr liegt (`current_year - expiration_year > 6`)
+   2. Diese müssen sofort recycelt werden
+2. `Almost Expired Juices`
+   1. Säfte, die im aktuellen Jahr ablaufen
+   2. ODER Säfte, die nächstes Jahr ablaufen (`expiration_year = current_year + 1`)
+   3. Diese müssen zur Erneuerung geschickt werden
+
+Führen Sie diese Schritte aus:
+
+- Extrahieren Sie die IDs der Säfte, die eines dieser Kriterien erfüllen
+- Benennen Sie die ID-Spalte in 'to_renew' um
+- Sortieren Sie die Ergebnisse nach Bearbeitungs-Priorität:
+  - Dringendste zuerst (älteste abgelaufene Säfte)
+  - Dann fast abgelaufene Säfte
+  - Verwenden Sie (current_year - expiration_year) zum Sortieren
+
+| beverages |     |              |                 |
+|:---------:| --- | ------------ | --------------- |
+|           | id  | current_year | expiration_year |
+| 1         | 145 | 2013         | 2014            |
+| 2         | 156 | 2001         | 2015            |
+| 3         | 167 | 2009         | 2004            |
+| 4         | 178 | 2005         | 2000            |
+| 5         | 124 | 2013         | 2006            |
+| 6         | 189 | 2002         | 2014            |
+| 7         | 198 | 2007         | 2013            |
+| 8         | 201 | 2004         | 2007            |
+| 9         | 206 | 2000         | 2000            |
+| 10        | 112 | 2011         | 2002            |
+| 11        | 209 | 2008         | 2004            |
+| 12        | 125 | 2015         | 2012            |
+| 13        | 980 | 2008         | 2005            |
+| 14        | 402 | 2010         | 2011            |
+| 15        | 391 | 2008         | 2009            |
+| 16        | 144 | 2015         | 2013            |
+| 17        | 213 | 2014         | 2007            |
+| 18        | 100 | 2001         | 2000            |
+| 19        | 145 | 2002         | 2004            |
+| 20        | 981 | 2011         | 2014            |
+| 21        | 210 | 2002         | 2007            |
+| 22        | 392 | 2010         | 2006            |
+| 23        | 393 | 2007         | 2013            |
+| 24        | 113 | 2010         | 2002            |
+| 25        | 255 | 2001         | 2008            |
+
+```sql
+SELECT id as to_renew
+FROM beverages
+WHERE current_year - expiration_year > 6 OR current_year = expiration_year OR expiration_year = current_year + 1
+ORDER by current_year-expiration_year DESC
+```
+
+## Wiederholung – Neue Spalten erstellen
+
+### Challenge
+
+> Verfügbare Tabellen und Spalten:
+> 
+> - `items`**:** `id`
+
+Eine quartische Funktion ist definiert:
+
+```
+f(x) = ax4+bx3+cx2+dx+e
+```
+
+Definieren wir die konstanten Parameter:
+
+- `a = 3`
+- `b = 5`
+- `c = 0.9`
+- `d = 2.2`
+- `e = 1`
+
+Rufe die IDs und die quartische Funktion ab, wobei x die ID ist, und benenne die Spalte in `quartic` um.
+
+> Verwende keine integrierten Funktionen wie `POWER()`!
+
+Um die Potenz von 2 oder die Potenz von 3 zu berechnen, verwende das folgende Beispiel:
+
+```sql
+a*a
+-- Potenz von 2
+
+a*a*a
+-- Potenz von 3
+```
+
+```sql
+select id , (3*id*id*id*id + 5*id*id*id + 0.9*id*id + 2.2 * id +1 )as quartic from items
+```
+
+### Datumsangaben behandeln – Teil 1
+
+Daten in SQL haben ein bestimmtes Format und wir können sie ähnlich wie Zahlen abfragen. Um ein Datum in einer Abfrage zu schreiben, verwenden wir das Format: YYYY-MM-DD (2012-09-24)
+
+Um Datumsangaben abzufragen, können wir alle Operatoren verwenden, die wir bereits kennen – größer (`>`), kleiner (`<`) oder gleich (`=`) innerhalb des Schlüsselworts WHERE:  
+
+```sql
+SELECT * FROM table1WHERE col1 > '2011-01-13'
+```
+
+Wir können sogar das Schlüsselwort BETWEEN verwenden:  
+
+```sql
+SELECT * FROM table1WHERE col1 BETWEEN '2010-01-01' AND '2010-02-25'
+```
+
+Verfügbare Tabellen und Spalten:
+
+`**games**`: `**id**`, `**date**`
+
+Rufe alle Spiel-IDs ab, die **nicht** im Winter gespielt werden.  
+Winterdaten sind: `2022-12-21` – `2023-03-20`. Nur diese Tage sollten nicht enthalten sein.
+
+Sortiere sie nach dem Datum in absteigender Reihenfolge und benenne die Spalte in **game** um.
+
+| id  | date                     |
+| --- | ------------------------ |
+| 5   | 2022-11-20T22:00:00.000Z |
+| 6   | 2022-01-11T22:00:00.000Z |
+| 7   | 2023-01-01T22:00:00.000Z |
+| 8   | 2023-02-12T22:00:00.000Z |
+| 9   | 2022-10-28T21:00:00.000Z |
+| 10  | 2022-08-31T21:00:00.000Z |
+| 11  | 2022-12-21T22:00:00.000Z |
+| 12  | 2022-12-19T22:00:00.000Z |
+| 13  | 2022-10-31T22:00:00.000Z |
+| 14  | 2023-03-19T22:00:00.000Z |
+
+```sql
+select id as game from games where date < "2022-12-21" or date > "2023-03-20" order by date desc
+```
+
+### Datumsangaben behandeln – Teil 2
+
+Datumsangaben können nicht wie Zahlen addiert oder subtrahiert werden. Um Berechnungen mit Datumsangaben durchzuführen, müssen wir sie mithilfe der Funktion JULIANDAY in Zahlen umwandeln.
+
+Diese Funktion wandelt Datumsangaben in den julianischen Tag um, eine fortlaufende Zählung der Tage seit dem 1. Januar 4713 v. Chr., die von Astronomen für Zeitintervalle und Vergleiche zwischen verschiedenen Kalendern verwendet wird.
+
+Beachte, dass im Julianischen Tagessystem der Tag mittags (12:00:00) beginnt, sodass ein Bruchteil von .5 genau Mittag darstellt.
+
+Um es zu verwenden, schreiben wir:
+
+```sql
+SELECT JULIANDAY('2023-02-20 12:00:00')
+```
+
+Dies gibt `2459996.0` Tage zurück
+
+Julianische Tage beginnen mittags, daher steht `.0` für Mittag, wie im Unterrichtsbeispiel gezeigt, in dem `'2023-02-20 12:00:00'` `2459996.0` zurückgibt. Daher steht `.5` für Mitternacht (auf halbem Weg durch den `JULIANDAY`), nicht für Mittag.
+
+#### Challenge
+
+verfügbare Tabellen und Spalten:
+
+- `events`**:** `id`**,** `start`**,** `end`
+
+| id                                                                 | start | end                      |
+| ------------------------------------------------------------------ | ----- | ------------------------ |
+| 1                                                                  | 13    | 2009-01-12T22:00:00.000Z |
+| 2                                                                  | 14    | 2009-10-11T22:00:00.000Z |
+| 3                                                                  | 15    | 2009-09-14T21:00:00.000Z |
+| 4                                                                  | 16    | 2009-02-19T22:00:00.000Z |
+| 5                                                                  | 17    | 2009-08-07T21:00:00.000Z |
+| 6                                                                  | 18    | 2010-12-23T22:00:00.000Z |
+| 7                                                                  | 19    | 2009-07-13T21:00:00.000Z |
+| 8                                                                  | 20    | 2009-07-25T21:00:00.000Z |
+| 9                                                                  | 21    | 2008-04-02T21:00:00.000Z |
+| 10                                                                 | 22    | 2010-01-01T22:00:00.000Z |
+| Rufe die IDs aller Ereignisse ab, die weniger als drei Tage dauern |       |                          |
+
+```sql
+select id from events where (JULIANDAY(end) - JULIANDAY(start)) < 3
+```
+
+### Datumsangaben behandeln – Teil 3
+
+SQL bietet mehrere nützliche Funktionen zum Bearbeiten und Formatieren von Datumsangaben. Hier sind einige häufig verwendete Datumsfunktionen:
+
+1. `DATE()` – Wandelt eine Zeichenfolge in ein Datum um
+2. `STRFTIME()` – Formatiert Datumsangaben gemäß den angegebenen Parametern
+3. `DATE('now')` – Ruft das aktuelle Datum ab:
+
+Zum Beispiel einen String in ein Datum umwandeln:
+
+```sql
+SELECT DATE('2023-05-15 13:45:00') -- Gibt zurück: 2023-05-15
+SELECT DATE('now') -- Gibt das aktuelle Datum zurück
+```
+
+Zum Beispiel Jahr, Monat und Tag aus einem Datum extrahieren:
+
+```sql
+-- Jahr abrufen
+SELECT STRFTIME('%Y', '2023-05-15')
+-- Gibt zurück: 2023
+
+-- Monat abrufen
+SELECT STRFTIME('%m', '2023-05-15')
+-- Gibt zurück: 05
+
+-- Tag abrufen
+SELECT STRFTIME('%d', '2023-05-15')
+-- Gibt zurück: 15
+
+-- Kombination aus Jahr und Tag anzeigen (beliebiger Trenner kann verwendet werden)
+SELECT STRFTIME('%Y:%d', '2023-05-15')
+-- Gibt zurück: 2023:15
+
+-- Stattdessen einen Bindestrich als Trenner verwenden
+SELECT STRFTIME('%d-%m-%Y', '2023-05-15')
+-- Gibt zurück: 15-05-2023
+
+-- Wochentag abrufen
+SELECT STRFTIME('%w', '2023-05-15')
+-- Gibt zurück: 1 (Montag; Sonntag ist 0)
+```
+
+Häufige Formatbezeichner:
+
+- `%Y`: Jahr (4 Ziffern)
+- `%m`: Monat (01–12)
+- `%d`: Tag des Monats (01–31)
+- `%w`: Wochentag (0–6, Sonntag ist 0)
+- `%H`: Stunde (00–23)
+- `%M`: Minute (00–59)
+- `%S`: Sekunde (00–59)
+
+Du kannst **jedes Trennzeichen** zwischen den Bezeichnern verwenden (z. B. `-`, `:`, `/`). Zum Beispiel kombinieren `STRFTIME('%d-%m-%Y', date)` und `STRFTIME('%d:%m:%Y', date)` beide Tag, Monat und Jahr, lediglich mit unterschiedlichen Trennzeichen.
+
+Du kannst diese Funktionen in Abfragen kombinieren:
+
+```sql
+-- Finde alle Datensätze aus dem aktuellen Jahr
+SELECT * FROM table1 WHERE STRFTIME('%Y', date_column) = STRFTIME('%Y', 'now')
+```
+
+### Datumsangaben behandeln – Teil 3
+
+Verfügbare Tabellen und Spalten:
+
+- `events`**:** `id`**,** `start`**,** `end`
+
+| Id  | start                              | end                                |
+| --- | ---------------------------------- | ---------------------------------- |
+| 13  | 2009-01-12T22:00:00.000Z           | 2009-01-14T22:00:00.000Z           |
+| 14  | 2009-10-11T22:00:00.000Z           | 2009-10-18T22:00:00.000Z           |
+| 15  | 2009-09-14T21:00:00.000Z           | 2009-09-30T22:00:00.000Z           |
+| 16  | 2009-02-19T22:00:00.000Z           | 2010-02-20T22:00:00.000Z           |
+| 17  | 2009-08-07T21:00:00.000Z           | 2009-08-08T21:00:00.000Z           |
+| 18  | 2010-12-23T22:00:00.000Z           | 2010-12-31T22:00:00.000Z           |
+| 19  | 2009-07-13T21:00:00.000Z           | 2009-07-15T21:00:00.000Z           |
+| 20  | 2009-07-25T21:00:00.000Z           | 2009-07-30T21:00:00.000Z           |
+| 21  | 2008-04-02T21:00:00.000Z           | 2008-04-02T21:00:00.000Z           |
+| 22  | 2010-01-01T22:00:00.000Z           | 2010-01-04T22:00:00.000Z           |
+| 23  | 2009-08-01T10:00:00.000Z           | 2009-08-01T20:00:00.000Z           |
+| 24  | 2009-08-022009-08-01T03:00:00.000Z | 2009-08-022009-08-01T11:00:00.000Z |
+| 25  | 2009-08-10T03:00:00.000Z           | 2009-08-12T03:00:00.000Z           |
+| 26  | 2009-08-23T09:00:00.000Z           | 2009-08-25T06:00:00.000Z           |
+| 27  | 2009-09-01T01:00:00.000Z           | 2009-09-12T01:00:00.000Z           |
+
+Schreibe eine Abfrage, die Folgendes anzeigt:
+
+- Die Ereignis-ID
+- Das Startdatum, formatiert als "DD-MM-YYYY". Nenne diese Spalte `formatted_start`
+- Das Enddatum, formatiert als "DD-MM-YYYY". Nenne diese Spalte `formatted_end`
+- Die Dauer in Tagen zwischen start und end, auf die nächste ganze Zahl gerundet. Nenne diese Spalte `duration_days`
+
+Filtere nur die Zeilen, in denen das Jahr der Spalte `start` `2009` ist (`STRFTIME()` gibt eine Zeichenfolge und keine Zahl zurück).
+
+Sortiere die Ergebnisse nach der Dauer in Tagen in absteigender Reihenfolge.
+
+Hinweis: Um die Differenz zwischen Datumsangaben zu berechnen, verwende: `JULIANDAY(end) - JULIANDAY(start)` und verwende `ROUND()`, um auf ganze Zahlen zu runden.
+
+#### Lösung
+
+```sql
+select id , STRFTIME('%d-%m-%Y', start) as formatted_start, STRFTIME('%d-%m-%Y', end) as formatted_end, ROUND(JULIANDAY(end) - JULIANDAY(start)) AS duration_days from events where STRFTIME('%Y',start) == '2009' order by duration_days desc
+```
+
+## Integrierte Aggregatfunktionen Teil 1
+
+SQL verfügt über viele integrierte Funktionen, aber in dieser Lektion behandeln wir die Aggregatfunktionen.
+
+Eine Aggregatfunktion erhält ein Feld als Eingabe und berechnet etwas über dieses Feld. Die häufigsten Aggregatfunktionen sind:
+
+- `MAX` - Gibt den Maximalwert eines Feldes zurück
+
+- `MIN` - Gibt den Minimalwert eines Feldes zurück
+
+- `AVG` - Gibt den Durchschnittswert eines Feldes zurück
+
+- `COUNT` – Gibt die Gesamtzahl der Datensätze zurück
+
+- `SUM` – Gibt die Summe aller Nicht-Null-Werte in einem Feld zurück
+
+Du kannst diese Funktionen in deiner SELECT-Anweisung wie folgt verwenden:
+
+```sql
+SELECT MAX(col1), MIN(col2), AVG(col3), …
+```
+
+Zum Beispiel, um das höchste Gehalt in einer Mitarbeitertabelle zu finden:
+
+```sql
+SELECT MAX(salary) FROM employees
+```
+
+Oder um mehrere Aggregatfunktionen gleichzeitig zu erhalten:
+
+```sql
+SELECT MAX(salary), MIN(salary), AVG(salary) FROM employees
+```
+
+### Challenge
+
+> Verfügbare Tabellen und Spalten:
+> 
+> - `sales`**:** `product_id`**,** `price_per_unit`**,**  `quantity`
+
+Schreibe eine Abfrage, die Folgendes zurückgibt:
+
+- Die Gesamtzahl der Verkaufstransaktionen
+- Die durchschnittliche Menge pro Verkauf
+- Den maximalen Preis pro Einheit
+- Den Gesamtumsatz (Summe aus quantity * price_per_unit)
+
+Dein Ergebnis sollte genau diese Spaltennamen haben:
+
+- `total_transactions`
+- `avg_quantity`
+- `max_unit_price` 
+- `total_revenue`
+
+| product_id | price_per_unit | quantity |
+|:---------- |:-------------- |:-------- |
+| 4          | 19             | 1        |
+| 5          | 16             | 3        |
+| 6          | 13             | 2        |
+| 7          | 21             | 1        |
+| 8          | 16             | 3        |
+| 9          | 23             | 5        |
+| 10         | 27             | 1        |
+| 11         | 18             | 2        |
+| 12         | 21             | 3        |
+| 13         | 22             | 2        |
+
+```sql
+select count(product_id) as total_transactions, avg(quantity) as avg_quantity, max(price_per_unit) as max_unit_price, sum(price_per_unit * quantity) as total_revenue from sales
+```
+
+## Integrierte Aggregatfunktionen Teil 2
+
+Manchmal müssen wir Aggregatfunktionen auf komplexere Weise verwenden, etwa indem wir jede Zeile mit einem Aggregatwert vergleichen. Hier kommen verschachtelte Abfragen ins Spiel.
+
+Wenn du Berechnungen durchführen möchtest, die einzelne Zeilen mit aggregierten Werten kombinieren, musst du eine verschachtelte Abfrage verwenden. Hier ist der Grund:  
+Dies liefert nicht das gewünschte Ergebnis pro Zeile:
+
+```sql
+SELECT value + MIN(value) FROM table1
+```
+
+Der Grund ist, dass Aggregatfunktionen auf der gesamten Spalte arbeiten, während der Verweis „value“ versucht, zeilenweise zu arbeiten. Um dies zu lösen, verwenden wir eine verschachtelte Abfrage:
+
+```sql
+SELECT value + (SELECT MIN(value) FROM table1) FROM table1
+```
+
+Das funktioniert, weil die verschachtelte Abfrage `(SELECT MIN(value) FROM table1)` zuerst ausgeführt wird und einen einzelnen Wert zurückgibt, der dann in der Hauptabfrage für jede Zeile verwendet werden kann.
+
+Häufige Anwendungsfälle für verschachtelte Aggregationen:  
+
+1. Jeden Wert mit dem Durchschnitt vergleichen
+
+2. Prozentsatz der Gesamtsumme berechnen
+
+3. Unterschiede zu Maximal- oder Minimalwerten finden
+
+#################################################
+
+`SELECT name, `
+
+       `amount + AVG(amount)` <-- Fehler
+
+`FROM orders`
+
+In SQLite führt dies nicht zu einem Syntaxfehler, aber die Kombination einer spaltenbezogenen Zeile mit einem unqualifizierten Aggregat reduziert das Ergebnis auf eine einzelne Aggregatzeile statt auf ein Ergebnis pro Zeile. Verwende eine Unterabfrage: `amount + (SELECT AVG(amount) FROM orders)`.
+
+#################################################
+
+Verfügbare Tabellen und Spalten:
+
+> - `items`**:** `id`**,** `price`
+
+| id                                                                                                                                                                                                                                   | price |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----- |
+| 4                                                                                                                                                                                                                                    | 19    |
+| 5                                                                                                                                                                                                                                    | 16    |
+| 6                                                                                                                                                                                                                                    | 13    |
+| 7                                                                                                                                                                                                                                    | 21    |
+| 8                                                                                                                                                                                                                                    | 16    |
+| 9                                                                                                                                                                                                                                    | 23    |
+| 10                                                                                                                                                                                                                                   | 27    |
+| 11                                                                                                                                                                                                                                   | 18    |
+| 12                                                                                                                                                                                                                                   | 21    |
+| 13                                                                                                                                                                                                                                   | 22    |
+| Berechne, um wie viel der Preis jedes Elements den Durchschnittspreis aller Elemente **übersteigt**. Zeige die ID des Elements, seinen Preis und die Differenz zum Durchschnitt an. Benenne die Differenzspalte als `diff_from_avg`. |       |
+
+Sortiere die Ergebnisse nach der Differenz in absteigender Reihenfolge.
+
+```sql
+select id, price, price - (select avg(price) from items) as diff_from_avg from items order by diff_from_avg desc
+```
+
+## Gruppierung Teil 1
+
+Wir haben bisher Daten für das gesamte Feld berechnet und werden nun die Möglichkeit einführen, Daten für spezifische Gruppen zu berechnen.
+
+---
+
+**workers**
+
+| id  | area | age |
+| --- | ---- | --- |
+| 1   | A    | 35  |
+| 2   | A    | 37  |
+| 3   | B    | 29  |
+| 4   | B    | 39  |
+
+Wenn wir 
+
+```sql
+SELECT AVG(age) as avg_age FROM workers
+```
+
+schreiben, erhalten wir nur das Durchschnittsalter aller workers zusammen. 
+
+Was wäre, wenn wir das Durchschnittsalter für jeden **Bereich** berechnen wollten?
+
+Dafür können wir die `GROUP BY` Schlüsselwörter verwenden
+
+```sql
+SELECT area, AVG(age) as avg_age FROM workers GROUP BY area
+```
+
+Das Ergebnis:
+
+| Bereich | Durchschnittsalter |
+| ------- | ------------------ |
+| A       | 36                 |
+| B       | 34                 |
+
+Jetzt wissen wir, dass das Durchschnittsalter in Bereich `A 36` und das Durchschnittsalter in Bereich `B 34` ist.
+
+Gegeben sei eine **sales**-Tabelle mit den Spalten `region` und `amount`, wie würden Sie den Gesamtumsatz pro Region ermitteln?
+SELECT region, SUM(amount) FROM sales GROUP BY region
+GROUP BY region erstellt Gruppen für jede Region, und SUM berechnet die Gesamtsumme innerhalb jeder Gruppe.
+
+Was macht `GROUP BY`?
+Berechnet Aggregatwerte für jede Gruppe separat
+
+Was würde diese Abfrage zurückgeben?
+
+```sql
+SELECT COUNT(id) FROM workers GROUP BY area
+```
+
+Die Anzahl der Arbeiter in jedem Bereich, aber ohne anzuzeigen, welcher Bereich
+Die Abfrage gruppiert nach Bereich und zählt, aber da der Bereich nicht in SELECT enthalten ist, siehst du nur die Zählungen, ohne zu wissen, welchen Bereich sie repräsentieren.
+
+### Challenge
+
+| name         | type      | pH   |
+| ------------ | --------- | ---- |
+| Celery       | vegetable | 5.8  |
+| Peas         | vegetable | 6.5  |
+| Corn         | vegetable | 7    |
+| Kale         | vegetable | 6.4  |
+| Pepper       | vegetable | 5.15 |
+| Cabbage      | vegetable | 5.5  |
+| Banana       | fruit     | 4.8  |
+| Mango        | fruit     | 4.3  |
+| Peaches      | fruit     | 3.5  |
+| Apricot      | fruit     | 3.7  |
+| Oranges      | fruit     | 3.6  |
+| Cherries     | berry     | 3.7  |
+| Raspberries  | berry     | 3.5  |
+| Strawberries | berry     | 3.3  |
+| Blueberries  | berry     | 3.7  |
+| Grapes       | berry     | 3.9  |
+
+```sql
+select type, round(avg(pH),2) as ph_average from foods group by type
+```
+
+## Gruppierung Teil 2
+
+Das Schlüsselwort `WHERE` führt eine Bedingung für jeden Datensatz einzeln aus. Zum Beispiel:
+
+```sql
+SELECT * FROM table1 WHERE col1 > col2
+```
+
+`col1 > col2` wird für jeden Datensatz ausgeführt und prüft, ob die Bedingung erfüllt ist.
+
+Aber was ist, wenn wir aggregierte Ergebnisse filtern möchten? Zum Beispiel:
+
+```sql
+SELECT category, AVG(price) FROM table1 WHERE AVG(price) > 40 GROUP BY category
+```
+
+**Das wird nicht funktionieren**, weil `WHERE` keine Aggregationen überprüfen kann. Dafür haben wir das Schlüsselwort<mark> `HAVING`. Es filtert Daten nach der Aggregatbedingung.</mark>
+
+```sql
+SELECT category, AVG(price) FROM table1 GROUP BY category HAVING AVG(price) > 40
+```
+
+Dadurch werden alle Kategorien herausgefiltert, deren Durchschnittspreis größer als 40 ist.
+
+Wenn wir die `HAVING`- und `WHERE`-Klausel kombinieren möchten, schreiben wir:
+
+```sql
+SELECT category, AVG(price) FROM table1 WHERE price > 25 GROUP BY category HAVING AVG(price) > 40
+```
+
+Zuerst wird Datensatz für Datensatz vorgegangen und alle Datensätze gefiltert, bei denen der Preis größer als 25 ist, und erst danach wird die `GROUP BY`-Klausel ausgeführt und jede Kategorie gefiltert, deren Durchschnittspreis größer als 40 ist.
+
+
+
+####################################################
+
+Warum schlägt diese Abfrage fehl?
+
+```sql
+SELECT category, AVG(price) FROM productsWHERE AVG(price) > 50GROUP BY category
+```
+
+`WHERE` kann keine Aggregatfunktionen filtern
+
+####################################################
+
+### Challenge
+
+Verfügbare Tabellen und Spalten:
+
+> - `earthquakes`**:** `location`**,** `amplitude`**,** `period`
+
+Die Richterskala ist eine logarithmische Skala, die zur Messung der Magnitude von Erdbeben verwendet wird.
+
+Wir müssen für jeden Ort die durchschnittliche Magnitude aller schweren Erdbeben zurückgeben.
+
+Ein schweres Erdbeben ist definiert als:
+
+- Die Amplitude ist größer oder gleich 1.
+- Die Periode der Wellen ist größer oder gleich 1 Minute.
+
+Für diese Herausforderung verwenden wir eine andere Formel: `M = (A/T)^2 / T`, die äquivalent zu `M = ((A/T)*(A/T)) / T` ist. Hier ist `M` die Magnitude, `A` die Spalte `amplitude` und `T` die Spalte `period`.
+
+Gib den Ort und die durchschnittliche Magnitude jedes Ortes zurück und berücksichtige dabei nur die schweren Erdbeben (benenne die Spalte `avg_magnitude`). Nimm in dein Ergebnis nur die Orte auf, bei denen `avg_magnitude` größer als 1 ist.
+
+Runde die Ergebnisse auf 2 Dezimalstellen.
+
+| location | amplitude | period |
+| --- | --- | --- |
+| Stonebri | 0.01 | 1   |
+| Readat | 0.003 | 24  |
+| Chelten | 5   | 0.2 |
+| Stonebri | 74  | 49  |
+| Stonebri | 11  | 62  |
+| Readat | 0.008 | 0.34 |
+| Chelten | 73  | 13  |
+| Hamwyawi | 68  | 72  |
+| Chelten | 3   | 1.2 |
+| Hamwyawi | 64  | 45  |
+| Hamwyawi | 0.0005 | 1.2 |
+| Stonebri | 13  | 1.6 |

Scheme.md

@@ -0,0 +1,19 @@
+# Scheme
+
+## Definition von Variablen
+
+### Globale Variablen
+
+```scheme
+(define variablenname wert)
+```
+
+
+
+Beispiel: 
+
+```scheme
+(define a 10)
+
+(define name "Otto")
+```

Schwedisch.md

@@ -0,0 +1,194 @@
+## Die Vokale
+
+Obwohl es weniger Vokale als Konsonanten im schwedischen Alphabet gibt, sind es die Vokale, die dir die meisten Schwierigkeiten bereiten werden. Zunächst wird jeder Vokal entweder weich oder hart ausgesprochen, was die Aussprache des davor stehenden Konsonanten beeinflusst. Obwohl uns durchaus auffällt, ob ein Vokal weich oder hart ist, wird der Unterschied erst richtig klar, wenn wir uns die Konsonanten ansehen.
+
+Außerdem kann jeder Vokal auf mindestens zwei verschiedene Arten ausgesprochen werden. Steht der Vokal vor zwei Konsonanten, vor einem M oder N am Ende eines Wortes oder befindet sich in der letzten, unbetonten Silbe eines Wortes, so ist der Vokal kurz. Steht der Vokal vor einem Konsonanten oder in einem einsilbigen Wort, das auf einen Vokal endet, ist der Vokal lang. Das hört sich erst einmal verwirrend an, aber hör dir hier die Beispiele an und du wirst den Dreh bestimmt herausbekommen.
+
+### **A**
+
+Der Buchstabe A ist ein harter Vokal. Meistens klingt er wie das „a” in „Vater“.
+
+- Kurz ausgesprochen: _t**a**ck_ („danke”)
+- Lang ausgesprochen: _br**a**_ (“good”)
+### **E**
+
+Der Buchstabe E ist ein weicher Vokal. Ein kurzes E klingt wie das „e“ in „Bett“, wohingegen das lange E wie das „e“ in „Beet“ klingt.
+
+- Kurz ausgesprochen: _m**e**llan_ („zwischen”)
+- Lang ausgesprochen: _r**e**sa_ („Reise”)
+
+### **I**
+
+Der Buchstabe I ist ein weicher Vokal. Das I klingt immer wie in „Liebe“.
+
+- Kurz ausgesprochen: _t**i**ll_ („bis”)
+- Lang ausgesprochen: _b**i**l_ („Auto”)
+
+### **O**
+
+Der Buchstabe O ist ein harter Vokal. Das kurze O klingt wie das „o“ in „Stopp“, wohingegen das lange O wie das „u“ in „Mut“ klingt.
+
+- Kurz ausgesprochen: _k**o**mma_ („kommen“)
+- Lang ausgesprochen: _**o**säker_ („unsicher”)
+
+### **U**
+
+Der Buchstabe U ist ein harter Vokal. Das schwedische U wird ähnlich wie das U im Deutschen ausgesprochen.
+
+- Kurz ausgesprochen: _buss_ („Bus”)
+- Lang ausgesprochen: _du_ („du“)
+
+### **Y**
+
+Der Buchstabe Y ist ein weicher Vokal. Er klingt ähnlich wie das deutsche „i“, mit einem leichten Einschlag von „ü“.
+
+- Kurz ausgesprochen: _fl**y**tta_ („bewegen”)
+- Lang ausgesprochen:  _s**y**_ („nähen”)
+
+### **Å**
+
+Der Buchstabe Å ist ein harter Vokal. Obwohl er wie das deutsche „A“ aussieht, wird er eher wie das „o“ wie in „oder“ ausgesprochen.
+
+- Kurz ausgesprochen:  _G**å**rdsby_ (ein Ort in Schweden)
+- Lang ausgesprochen: _hej d**å**_ („tschüss”)
+
+### **Ä**
+
+Der Buchstabe Ä ist ein weicher Vokal und wird wie das deutsche „ä“ in „ähnlich“ ausgesprochen.
+
+- Kurz ausgesprochen: _G**ä**llivare_ (ein Ort in Schweden)
+- Lang ausgesprochen: _**ä**ta_ („essen”)
+
+### **Ö**
+
+Der Buchstabe Ö ist ein weicher Vokal und wird wie das deutsche „ö“ in „gewöhnlich“ ausgesprochen.
+
+- Kurz ausgesprochen: _k**ö**ttbullar_ („Fleischbällchen bzw. Fleischbrötchen”)
+- Lang ausgesprochen: _**ö**l_ („Bier”)
+
+> 💡 [In 10 Schritten schwedisch werden: So geht’s!](https://de.babbel.com/de/magazine/schwedisch-werden)
+
+## Schwedisches Alphabet: die Konsonanten
+
+Die schwedischen Konsonanten sind wirklich unkompliziert. Viele Buchstaben werden ähnlich wie im Deutschen ausgesprochen. Es gibt jedoch auch einige Ausnahmen. Also, sehen wir uns die häufigsten Buchstaben und Buchstabenkombinationen an, über die man beim Lernen der Sprache stolpert.
+
+### **G, GN und NG**
+
+Das G wird hauptsächlich auf zwei verschiedene Arten ausgesprochen. Im ersten Fall klingt es wie der Buchstabe „g“ in „gehen“ und wird vor den harten Vokalen (A, O, U und Å) auf diese Weise ausgesprochen.
+
+- _**g**ata_ — Straße
+- _**G**otland_ — eine schwedische Insel
+
+Steht das G vor einem weichen Vokal (E, I, Y, Ä oder Ö), klingt es wie das „j“ in „jeder“.
+
+- _**g**ärna_ — gern
+- _**g**ift_ — verheiratet
+
+Der Buchstabe G wird ebenfalls weich ausgesprochen, wenn er nach einem R oder einem L steht.
+
+- _äl**g**_ — Elch
+- _Ber**g**a_ — ein Ort in Schweden
+
+Die Buchstabenkombination NG wird genauso wie im Deutschen ausgesprochen, wie das „ng“ in „jung“.
+
+- _u**ng**_ — jung
+- _si**ng**el_ — Single
+
+Komplizierter wird es beim GN, das wie das „ng“ in „jung“ mit einem noch schnell angehängten „n“ klingt.
+
+- _re**gn**_ — Regen
+- _si**gn**al_ — Signal
+
+### **J**
+
+Der Buchstabe J ist einer der schwierigsten des schwedischen Alphabets. Wie er ausgesprochen wird hängt nämlich davon ab, auf welchen Buchstaben er folgt. Steht er am Anfang eines Wortes oder nach einem Vokal, klingt er wie ein „j“.
+
+- _he**j** då_ — tschüss
+- _**j**äst_ — Hefe
+
+Die Buchstabenkombination SJ gibt es nur im Schwedischen. Um sie auszusprechen nimmst du das „h“ wie in „Hut“, schiebst es jedoch in deinem Mund weiter nach hinten und machst einen runden Mund. Dieselbe Aussprache wird für den ersten Laut der Wortendungen _-tion_ und _-sion_ genutzt.
+
+- _**sj**ö_ — See
+- _**sj**ukhus_ — Krankenhaus
+- _sta**tion**_ — Bahnhof
+- _diskus**sion**_ — Diskussion
+
+Die Kombination TJ wird ähnlich dem „sch“ in „Schiff“ ausgesprochen.
+
+- _**tj**ugo_ — zwanzig
+- _**tj**ena_ — Hey
+
+Bei den Buchstabenkombinationen LJ, DJ, GJ und HJ wird jeweils der erste Buchstabe ignoriert und dann das „j“ wie in „jetzt“ ausgesprochen.
+
+- _**gj**orde_ — gemacht
+- _**Lj**usdal_ — ein Ort in Schweden
+- _**Dj**urmo_ — ein Ort in Schweden
+- _**Hj**o_ — ein Ort in Schweden
+
+### **K und SK**
+
+Genau wie im Falle des G wird das K im Schwedischen auf zwei verschiedene Arten ausgesprochen, abhängig von dem auf es folgenden Vokal. Vor harten Vokalen (A, O, U und Å) sowie am Ende eines Wortes wird es wie das „k“ in „Kuss“ ausgesprochen.
+
+- _**k**ul_ — lustig
+- _**k**ål_ — Kohl
+
+Vor weichen Vokalen (E, I, Y, Ä oder Ö) und dem Buchstaben J wird es wie das „sch“ in „Schiff“ ausgesprochen (genau wie das TJ, siehe oben).
+
+- _**K**ina_ — China
+- _**k**öra_ — fahren
+- _**kj**ol_ — Rock
+
+Die Buchstabenkombination SK hat ebenso zwei Varianten: Vor harten Vokalen klingt es wie das „sk“ in „Skateboard“.
+
+- _**Sk**ara_ — ein Ort in Schweden
+- _**sk**o_ — Schuh
+
+Vor weichen Vokalen oder einem J klingt es wie der oben besprochene SJ-Laut.
+
+- _**sk**ön_ — schön
+- _**sk**iva_ — Scheibe
+
+### **RS**
+
+Die Buchstabenkombination RS wird wie das „sch“ in „Schuh“ ausgesprochen.
+
+- _ko**rs**ning_ — Kreuzung
+- _va**rs**ågod_ — bitte sehr, gern geschehen
+
+### **Q, W und Z**
+
+Obwohl die Buchstaben Q, W und Z im schwedischen Alphabet vorkommen, sind sie dennoch relativ selten. Normalerweise kommen sie nur in alten Ausdrücken und Lehnwörtern vor. Das W wurde bis vor kurzem als identisch mit dem V angesehen, das Q wurde in den meisten Fällen durch das K und das Z meistens durch das S ersetzt.
+
+### **Verschluckte Buchstaben**
+
+Das Letzte, was wir dir noch über das schwedische Alphabet mitgeben möchten, ist, dass die Buchstaben häufig „verschluckt“ werden. Das macht das Schwedischlernen natürlich umso verwirrender. Es gibt einige Regeln, die du lernen kannst – das „k“ in der Buchstabenkombination „skr“ ist oft stumm, das R hört man kaum, wenn es vor dem D, L, T oder N steht – doch es gibt vieles, das du einfach lernen musst, indem du Menschen mit Schwedisch als Erstsprache zuhörst.
+
+
+
+#######################
+
+Schwedische Vokale haben unterschiedliche Laute:
+
+- **A:** wie das lange „a“ in „raten“ oder das kurze „a“ in „Mann“
+- **E:** ähnlich dem langen „e“ in „See“ oder dem kurzen „e“ in „Bett“
+- **I:** wie das lange „i“ in „Igel“ oder das kurze „i“ in „mit“
+- **O:** kann wie das „u“ in „gut“ oder das „o“ in „Post“ klingen
+- **U:** ein Laut zwischen „i“ und „ü“, der im Deutschen keine direkte Entsprechung hat
+- **Y:** wie das deutsche „ü“ in „Tür“
+- **Å:** ähnlich dem langen „o“ in „Boot“
+- **Ä:** wie das deutsche „ä“ in „spät“
+- **Ö:** ähnlich dem deutschen „ö“ in „schön“
+
+### Häufige Verwechslungen
+
+- **Å und Ä verwechseln:** Das sind keine Varianten von A. Å klingt wie ein langes, offenes „o“, während Ä wie das deutsche „ä“ klingt.
+- **Ö falsch aussprechen:** Deutsche Muttersprachige haben hier einen Vorteil, da der Laut dem deutschen „ö“ entspricht. Achte darauf, ihn nicht wie ein kurzes „o“ auszusprechen.
+- **Den Unterschied zwischen W und V ignorieren:** Obwohl sie für viele Menschen aus Schweden ähnlich klingen, ist die Unterscheidung für die Rechtschreibung wichtig. W kommt hauptsächlich in Lehnwörtern und Namen vor, während V im Alltag viel häufiger ist.
+- **Y- und J-Laute verwechseln:** Das schwedische J klingt wie das deutsche J (wie in „ja“), während Y wie das deutsche „ü“ ausgesprochen wird. Diese Vertauschung kann am Anfang zu lustigen Missverständnissen führen.
+- **Vergessen, dass C seine Aussprache ändert:** C klingt wie „s“ vor e, i, y, ä und ö, aber wie „k“ vor a, o, u und å.
+
+### Hilfreiche Erinnerungen
+
+Für Å, Ä und Ö kannst du dir Eselsbrücken bauen: Der Kreis über dem Å sieht aus wie ein kleiner See, passend zum tiefen „o“-Laut. Die zwei Punkte auf dem Ä erinnern an weit geöffnete Augen, was zu seinem offeneren Klang passt.
+
+Der knifflige sj-Laut (/ɧ/) in Wörtern wie _sjö_ (See) – stell dir vor, du zischst leise, während du den hinteren Teil deines Rachens leicht verengst. Es braucht zwar Übung, macht aber schnell Spaß.

Vi.md

@@ -183,3 +183,54 @@ a ist nur Beispiel
 ### Mehrfaches Ausführen
 
 100@a
+
+# Aus alter Datei
+
+## Bestimmte Phrasen in Kleinbuchstaben umwandeln
+
+```
+:%s/\(Zum Beispiel[^.!?]*[.!?]\)/\L\1/g
+```
+
+**Erläuterung:**
+
+- `:%s/…/…/g` – Sucht und ersetzt global in der ganzen Datei.
+- `\(…\)` – Gruppiert den Treffer, um ihn als `\1` später referenzieren zu können.
+- `Zum Beispiel` – Die Zielphrase am Satzanfang.
+- `[^.!?]*` – Beliebig viele Zeichen, bis zu einem Satzendezeichen.
+- `[.!?]` – Der Satz endet mit Punkt, Ausrufezeichen oder Fragezeichen.
+- `\L\1` – Wandelt den Inhalt von `\1` (dem gefundenen Satzteil) in Kleinbuchstaben um
+
+## Jede leere Zeile löschen
+
+ ```
+:g/^$/d
+ ```
+
+- `:g` – Wendet den Befehl auf alle Zeilen an, die einem Muster entsprechen.
+- `^$` – Das Muster für eine leere Zeile: Zeilenanfang (^) gefolgt von Zeilenende ($), also nichts dazwischen.
+- `d` – Löscht die jeweilige Zeile.
+
+oder aber **alternativ**:
+
+- mit `v` —> nicht passende Zeilen behalten, so also `:v/\S/d` 
+  - `\S` bedeutet nicht-Leerzeichen
+
+oder 
+
+- mit `:g/^\s*$/d`
+  - `:g` → global: wende auf alle Zeilen an, die passen
+  - `^\s*$` → Zeilen, die nur aus Leerzeichen/Tabs (oder gar nichts) bestehen
+  - `d` → lösche diese Zeilen
+
+
+## Zeile in ein Register kopieren
+
+- `”ayy`
+
+## Zeile aus einem Register einfügen
+
+- `<ESC>”ap`
+
+
+