Alles erweitert

Assembler.md

@@ -52,3 +52,55 @@ Die CPU kann die Daten an der Adresse 1000 anfordern, und der Speicher gibt sie
 | 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).

Docker 2.md

@@ -71,3 +71,44 @@ ubuntu       latest    75afc20638b6   4 days ago    81.8MB
 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.

Lisp.md

@@ -30,6 +30,18 @@ defparameter *name* "Otto")
 (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.
+
+(setf *mein-wert* 100)
+
 
 
 ### Lokale Variablen

Python.md

@@ -37,3 +37,17 @@ 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.

Regular Expressions Cheat Sheet.md

@@ -2,29 +2,35 @@
 
 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
 
 |      |                                                                                 |
-| --- | ----------------------------------------------------------- |
+| ---- | ------------------------------------------------------------------------------- |
-| `\` | Escapes special characters or signals a special sequence.   |
+| `\`  | Escapet Sonderzeichen oder kennzeichnet eine spezielle Sequenz                  |
-| `.` | Matches any single character except a newline.              |
+| `.`  | 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.                                 |
 
 ​                
 
-`*?`              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.
@@ -77,3 +83,134 @@ A regular expression specifies a set of strings that matches it. This cheat shee
 ).
 \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) 

SQL.md

@@ -194,6 +194,26 @@ 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
@@ -935,7 +955,7 @@ 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            |
@@ -968,8 +988,6 @@ Bevor Sie mit der Lösung der Herausforderung beginnen, werfen Sie einen Blick a
 | 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');
 
 ##############################################################
@@ -991,7 +1009,7 @@ Ein schwerer Krimineller ist jemand, der alle folgenden Kriterien erfüllt:
 Benenne die Spalte als `worst_criminals`.
 
 | police_report |                   |        |               |              |
-| :-----------: | ----------------- | ------ | ------------- | ------------ |
+|:-------------:| ----------------- | ------ | ------------- | ------------ |
 |               | name              | report | map           | severe_score |
 | 1             | Domingos Holden   | VYyPJw | Lockinge      | 2            |
 | 2             | Isabel Enid       |        | Findochty     | 7            |
@@ -1046,7 +1064,7 @@ Führen Sie diese Schritte aus:
   - Verwenden Sie (current_year - expiration_year) zum Sortieren
 
 | beverages |     |              |                 |
-| :-------: | ---- | ------------ | --------------- |
+|:---------:| --- | ------------ | --------------- |
 |           | id  | current_year | expiration_year |
 | 1         | 145 | 2013         | 2014            |
 | 2         | 156 | 2001         | 2015            |
@@ -1081,14 +1099,10 @@ WHERE current_year - expiration_year > 6 OR current_year = expiration_year OR ex
 ORDER by current_year-expiration_year DESC
 ```
 
-
-
 ## Wiederholung – Neue Spalten erstellen
 
 ### Challenge
 
-
-
 > Verfügbare Tabellen und Spalten:
 > 
 > - `items`**:** `id`
@@ -1121,8 +1135,4 @@ a*a*a
 -- Potenz von 3
 ```
 
-
-
-
-
 `select id , (3*id*id*id*id + 5*id*id*id + 0.9*id*id + 2.2 * id +1 )as quartic from items`