Schwedisch begonnen, die anderen erweitert

Python.md

@@ -50,4 +50,40 @@ Um einen Zeichenfolgenwert in einer Variablen zu initialisieren, schließe ihn i
 s1 = 'This is a string's2 = "This is also a string"
 ```
 
-Im obigen Beispiel werden zwei Zeichenfolgenvariablen initialisiert, die `s1` und `s2` heißen.
+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
+```

Rust.md

@@ -52,7 +52,9 @@ Die `function` `main` wird mit dem Schlüsselwort `fn`definiert, gefolgt von
 Hier ist eine einfache Aufschlüsselung eines grundlegenden Rust-Programms:
 
 ```rust
-fn main() { // Hauptfunktion    println!("Hello, Coddy!"); // Ausgabeanweisung}
+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.
@@ -151,3 +153,63 @@ 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.
+
+
+

SQL.md

@@ -595,7 +595,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).
@@ -620,8 +622,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:
 
@@ -1032,9 +1036,10 @@ Benenne die Spalte als `worst_criminals`.
 | 19            | Kshitija Ladislav | cSA0hA | Caerleon      | 2            |
 | 20            | Ha-Eun Tatiana    | YNYhHV | Kara's Vale   | 4            |
 
-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
 
-##############################################################
+```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
 
@@ -1135,7 +1140,10 @@ 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`
+
+```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
 
@@ -1194,4 +1202,193 @@ 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.
+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
+```

Schwedisch.md

@@ -0,0 +1,164 @@
+## 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.