Rust weiter, SQL weiter, Massmatics begonnen

Lisp.md

@@ -55,3 +55,8 @@ setf - allgemeine Zuweisung
 ### 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

@@ -87,3 +87,26 @@ 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.

Rust.md

@@ -211,5 +211,173 @@ Im obigen Beispiel werden zwei boolesche Variablen namens `variable_true` und
 
 > 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);
+}
+```
 
 
+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

@@ -1392,3 +1392,128 @@ Dein Ergebnis sollte genau diese Spaltennamen haben:
 ```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
+### Challenge
+
+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  |
+select type, round(avg(pH),2) as ph_average from foods group by type
+

Schwedisch.md

@@ -162,3 +162,33 @@ Obwohl die Buchstaben Q, W und Z im schwedischen Alphabet vorkommen, sind sie de
 ### **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ß.