From 7d8fd790a50128d6bf9609a3773ee737900da3d2 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 27 Oct 2022 14:51:03 +0200
Subject: [PATCH 01/12] feat: add de to menu, footer, troubleshooting

---
 i18n/de.json               | 24 ++++++++++++++++++++++++
 i18n/footer/de.md          |  1 +
 i18n/troubleshooting_de.md | 27 +++++++++++++++++++++++++++
 3 files changed, 52 insertions(+)
 create mode 100644 i18n/de.json
 create mode 100644 i18n/footer/de.md
 create mode 100644 i18n/troubleshooting_de.md

diff --git a/i18n/de.json b/i18n/de.json
new file mode 100644
index 00000000..84025ecc
--- /dev/null
+++ b/i18n/de.json
@@ -0,0 +1,24 @@
+{
+    "exercise": {
+          "INTRODUCTION":           "EINFÜHRUNG"
+        , "VARIABLES":              "VARIABLEN"
+        , "STRINGS":                "STRINGS/ZEICHENKETTEN"
+        , "STRING LENGTH":          "STRING LÄNGE"
+        , "REVISING STRINGS":       "STRINGS BEARBEITEN"
+        , "NUMBERS":                "NUMBERS/ZAHLEN"
+        , "ROUNDING NUMBERS":       "NUMBERS RUNDEN"
+        , "NUMBER TO STRING":       "NUMBER ZU STRING"
+        , "IF STATEMENT":           "IF STATEMENT"
+        , "FOR LOOP":               "FOR SCHLEIFE"
+        , "ARRAYS":                 "ARRAYS/LISTEN"
+        , "ARRAY FILTERING":        "ARRAYS FILTERN"
+        , "ACCESSING ARRAY VALUES": "AUF ARRAY WERTE ZUGREIFEN"
+        , "LOOPING THROUGH ARRAYS": "SCHLEIFE ÜBER EIN ARRAY"
+        , "OBJECTS":                "OBJEKTE"
+        , "OBJECT PROPERTIES":      "OBJEKT EIGENSCHAFTEN"
+        , "OBJECT KEYS":            "OBJEKT SCHLÜSSEL/KEYS"
+        , "FUNCTIONS":              "FUNKTIONEN"
+        , "FUNCTION ARGUMENTS":     "ARGUMENTE VON FUNKTIONEN"
+        , "SCOPE":                  "GELTUNGSBEREICH"
+    }
+}
diff --git a/i18n/footer/de.md b/i18n/footer/de.md
new file mode 100644
index 00000000..fc9a22dc
--- /dev/null
+++ b/i18n/footer/de.md
@@ -0,0 +1 @@
+__Du brauchst Hilfe?__ Lies die README für diesen Kurs: https://github.com/workshopper/javascripting
diff --git a/i18n/troubleshooting_de.md b/i18n/troubleshooting_de.md
new file mode 100644
index 00000000..222b29f1
--- /dev/null
+++ b/i18n/troubleshooting_de.md
@@ -0,0 +1,27 @@
+---
+# O-oh, etwas funktioniert nicht.
+# Aber keine Panik!  
+---
+
+## Überprüfe deine Lösung:
+
+`Lösung
+===================`
+
+%solution%
+
+`Dein Ansatz
+===================`
+
+%attempt%
+
+`Unterschied
+===================`
+
+%diff%
+
+## Weitere Lösungsansätze:
+ * Ist der Name der Datei richtig geschrieben? Teste dies mit `ls %filename%`. Wenn die Antwort `ls: cannot access %filename%: No such file or directory` ist, dann existiert die Datei nicht, hat einen anderen Namen, oder befindet sich in einem anderen Verzeichnis.
+ * Stelle sicher, dass du keine Klammern vergessen hast, sonst kann der Compiler die Datei nicht interpretieren.
+ * Stelle sicher, dass du dich nirgends vertippt hast.
+

From 08729e29424e2fa976dc53f80d3f0d93aac97273 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 27 Oct 2022 17:28:10 +0200
Subject: [PATCH 02/12] translate variables, strings, introduction

---
 problems/introduction/problem_de.md  | 46 ++++++++++++++++++++++++++++
 problems/introduction/solution_de.md | 19 ++++++++++++
 problems/strings/problem_de.md       | 31 +++++++++++++++++++
 problems/strings/solution_de.md      | 11 +++++++
 problems/variables/problem_de.md     | 33 ++++++++++++++++++++
 problems/variables/solution_de.md    | 11 +++++++
 6 files changed, 151 insertions(+)
 create mode 100644 problems/introduction/problem_de.md
 create mode 100644 problems/introduction/solution_de.md
 create mode 100644 problems/strings/problem_de.md
 create mode 100644 problems/strings/solution_de.md
 create mode 100644 problems/variables/problem_de.md
 create mode 100644 problems/variables/solution_de.md

diff --git a/problems/introduction/problem_de.md b/problems/introduction/problem_de.md
new file mode 100644
index 00000000..b859c1a1
--- /dev/null
+++ b/problems/introduction/problem_de.md
@@ -0,0 +1,46 @@
+Damit alles seine Ordnung hat, erstellen wir zuerst einen Ordner für diesen Workshop.
+
+Führe diesen Befehl in der Konsole aus, um ein Verzeichnis mit dem Namen `javascripting` zu erstellen (oder etwas anderes, wenn du möchtest):
+
+```bash
+mkdir javascripting
+```
+
+Wechsel in das Verzeichnis `javascripting`:
+
+```bash
+cd javascripting
+```
+
+Erstelle eine Datei mit dem Namen `introduction.js`:
+
+```bash
+touch introduction.js
+```
+
+Oder, für Windows: 
+```bash
+type NUL > introduction.js
+```
+(`type` ist Teil des Befehls!)
+
+Öffnen die Datei in deinem bevorzugten Editor und füge diesen Text ein:
+
+```js
+console.log('hello')
+```
+
+Speicher die Datei und überprüfen dann, ob dein Programm korrekt ist, indem du diese Befehl ausführst:
+
+```bash
+javascripting verify introduction.js
+```
+
+Übrigens, in diesem Tutorial kannst du der Datei, mit der du arbeitest, jeden beliebigen Namen geben.
+Wenn du also für jede Übung eine Datei Namens `catsAreAwesome.js` verwenden möchtest, kannst du das tun.
+Stelle dann sicher, dass du immer diesen Befehl ausführst:
+
+```bash
+javascripting verify catsAreAwesome.js
+```
+
diff --git a/problems/introduction/solution_de.md b/problems/introduction/solution_de.md
new file mode 100644
index 00000000..86a45754
--- /dev/null
+++ b/problems/introduction/solution_de.md
@@ -0,0 +1,19 @@
+---
+
+# GESCHAFFT! 🎉
+
+Alles, was zwischen den Klammern von `console.log()` steht, wird auf dem Terminal ausgegeben.
+
+Das hier: 
+
+```js
+console.log('Hallo')
+```
+
+gibt `Hallo` auf dem Terminal aus.
+
+Zur Zeit geben wir eine **Zeichenfolge** auf dem Terminal aus: `Hallo`.
+
+In der nächsten Aufgabe konzentrieren wir uns darauf, etwas über **Variablen** zu lernen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
diff --git a/problems/strings/problem_de.md b/problems/strings/problem_de.md
new file mode 100644
index 00000000..1436bac6
--- /dev/null
+++ b/problems/strings/problem_de.md
@@ -0,0 +1,31 @@
+Eine **Zeichenkette** oder auch ein **String** ist eine Folge von Zeichen. Ein ***Zeichen*** ist, grob gesagt,
+ein geschriebenes Symbol. Beispiele für Zeichen sind Buchstaben, Zahlen,
+Satzzeichen und Leerzeichen.
+
+String-Werte werden entweder von einfachen oder doppelten Anführungszeichen umgeben.
+
+```js
+'dies ist eine Zeichenkette'
+
+"dies ist auch eine Zeichenkette"
+```
+
+## HINWEIS
+
+Versuche, konsistent zu bleiben. In diesem Workshop werden wir nur einfache Anführungszeichen verwenden.
+
+## Die Aufgabe:
+
+Erstelle eine Datei namens `strings.js`.
+
+Erstelle in dieser Datei eine Variable namens `someString` wie folgt:
+
+```js
+const someString = 'this is a string'
+```
+
+Verwende `console.log`, um die Variable **someString** auf dem Terminal auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem due diesen Befehl ausführst:
+
+`javascripting verify strings.js`
diff --git a/problems/strings/solution_de.md b/problems/strings/solution_de.md
new file mode 100644
index 00000000..21168f89
--- /dev/null
+++ b/problems/strings/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# ERFOLG.
+
+Du gewöhnst dich langsam an die Sache mit den Strings!
+
+In den nächsten Aufgaben werden wir uns mit der Manipulation von Strings beschäftigen.
+
+Führen Sie `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---
diff --git a/problems/variables/problem_de.md b/problems/variables/problem_de.md
new file mode 100644
index 00000000..488cb592
--- /dev/null
+++ b/problems/variables/problem_de.md
@@ -0,0 +1,33 @@
+Eine Variable ist ein Name, der auf einen bestimmten Wert verweisen kann. Variablen werden mit `let` deklariert, gefolgt vom Namen der Variablen.
+
+Hier ist ein Beispiel:
+
+```js
+let example
+```
+
+Die obige Variable ist **deklariert**, aber sie ist nicht definiert (sie verweist noch nicht auf einen bestimmten Wert).
+
+Hier ist ein Beispiel für die Definition einer Variable, die auf einen bestimmten Wert verweist:
+
+```js
+const example = 'some string'
+```
+
+# HINWEIS 
+
+Eine Variable wird **mit `let` deklariert** und verwendet das Gleichheitszeichen, um den Wert, auf den sie verweist, **zu definieren**. Dies wird umgangssprachlich als "eine Variable gleich einem Wert machen" bezeichnet.
+
+## Die Aufgabe:
+
+Erstelle eine Datei namens `variables.js`.
+
+Deklariere in dieser Datei eine Variable mit dem Namen `example`.
+
+**Setze die Variable `example` gleich dem Wert `'some string'`.**
+
+Verwende dann `console.log()`, um die Variable `example` auf der Konsole auszugeben.
+
+Prüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+`javascripting verify variables.js`
diff --git a/problems/variables/solution_de.md b/problems/variables/solution_de.md
new file mode 100644
index 00000000..e9a597a1
--- /dev/null
+++ b/problems/variables/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# DU HAST EINE VARIABLE ERSTELLT!
+
+Gute Arbeit. 
+
+In der nächsten Aufgabe werden wir uns Strings genauer ansehen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---

From 4fa0b05f2393775c301a394d305b35d9fcb44a1b Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 27 Oct 2022 17:45:10 +0200
Subject: [PATCH 03/12] translate revising-strings

---
 problems/revising-strings/problem_de.md  | 29 ++++++++++++++++++++++++
 problems/revising-strings/solution_de.md | 11 +++++++++
 2 files changed, 40 insertions(+)
 create mode 100644 problems/revising-strings/problem_de.md
 create mode 100644 problems/revising-strings/solution_de.md

diff --git a/problems/revising-strings/problem_de.md b/problems/revising-strings/problem_de.md
new file mode 100644
index 00000000..33a3cdfb
--- /dev/null
+++ b/problems/revising-strings/problem_de.md
@@ -0,0 +1,29 @@
+Du wirst oft den Inhalt eines Strings ändern müssen.
+
+Strings verfügen über integrierte Funktionen, die es einem ermöglichen, ihren Inhalt zu prüfen und zu bearbeiten.
+
+Hier ist ein Beispiel, das die Methode `.replace()` verwendet:
+
+```js
+let example = 'dieses Beispiel existiert'
+example = example.replace('exists', 'super')
+console.log(example)
+```
+
+Um den Wert zu ändern, auf den die Variable `example` verweist, müssen wir  
+wieder das Gleichheitszeichen verwenden, diesmal mit der Methode `example.replace()` rechts vom  
+rechts vom Gleichheitszeichen.
+
+## Die Herausforderung:
+
+Erstelle eine Datei namens `revising-strings.js`.
+
+Definiere eine Variable namens `pizza`, die auf diese Zeichenkette verweist: `'pizza is alright'`
+
+Verwende die Methode `.replace()`, um `alright` in `wonderful` zu ändern.
+
+Verwende `console.log()`, um die Ergebnisse der Methode `.replace()` auf dem Terminal auszugeben.
+
+Überprüfe, ob Ihr Programm korrekt ist, indem du diesen Befehl ausführst:
+
+`javascripting verify revising-strings.js`
diff --git a/problems/revising-strings/solution_de.md b/problems/revising-strings/solution_de.md
new file mode 100644
index 00000000..d37e56ab
--- /dev/null
+++ b/problems/revising-strings/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# JA, PIZZA _IST_ WUNDERBAR.
+
+Gut gemacht, mit dieser `.replace()` Methode!
+
+Als nächstes werden wir **Zahlen** erforschen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---

From c92efd544cb364dabd78298ec4cccdb4fe372988 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Fri, 28 Oct 2022 11:31:18 +0200
Subject: [PATCH 04/12] translate for, if, numbers

---
 problems/for-loop/problem_de.md          | 40 ++++++++++++++++++++++++
 problems/for-loop/solution_de.md         | 11 +++++++
 problems/if-statement/problem_de.md      | 32 +++++++++++++++++++
 problems/if-statement/solution_de.md     | 11 +++++++
 problems/number-to-string/problem_de.md  | 24 ++++++++++++++
 problems/number-to-string/solution_de.md | 11 +++++++
 problems/numbers/problem_de.md           | 15 +++++++++
 problems/numbers/solution_de.md          | 11 +++++++
 8 files changed, 155 insertions(+)
 create mode 100644 problems/for-loop/problem_de.md
 create mode 100644 problems/for-loop/solution_de.md
 create mode 100644 problems/if-statement/problem_de.md
 create mode 100644 problems/if-statement/solution_de.md
 create mode 100644 problems/number-to-string/problem_de.md
 create mode 100644 problems/number-to-string/solution_de.md
 create mode 100644 problems/numbers/problem_de.md
 create mode 100644 problems/numbers/solution_de.md

diff --git a/problems/for-loop/problem_de.md b/problems/for-loop/problem_de.md
new file mode 100644
index 00000000..d448e361
--- /dev/null
+++ b/problems/for-loop/problem_de.md
@@ -0,0 +1,40 @@
+For-Schleifen ermöglichen es dir, einen Codeblock eine bestimmte Anzahl von Wiederholungen auszuführen. Diese for-Schleife loggt zehn Mal auf der Konsole:
+
+```js
+for (let i = 0; i < 10; i++) {
+  // gibt die Zahlen 0 bis 9 aus
+  console.log(i)
+}
+```
+
+Der erste Teil, `let i = 0`, wird einmal zu Beginn der Schleife ausgeführt. Die Variable `i` wird verwendet, um zu verfolgen, wie oft die Schleife gelaufen ist.
+
+Der zweite Teil, `i < 10`, wird zu Beginn jeder Schleifen-Iteration geprüft, bevor der Code innerhalb der Schleife ausgeführt wird. Wenn die Aussage wahr ist, wird der Code innerhalb der Schleife ausgeführt. Wen falsch ist, ist die Schleife beendet. Die Anweisung `i < 10;` bedeutet, dass die Schleife so lange fortgesetzt wird, wie `i` kleiner als `10` ist.
+
+Der letzte Teil, `i++`, wird am Ende jeder Schleife ausgeführt. Dadurch wird die Variable `i` nach jeder Schleife um 1 erhöht. Sobald `i` die Zahl `10` erreicht, wird die Schleife beendet.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `for-loop.js`.
+
+In dieser Datei definiere eine Variable namens `total` und setze sie gleich der Zahl `0`.
+
+Definiere eine zweite Variable mit dem Namen `limit` und mache sie gleich der Zahl `10`.
+
+Erstelle eine for-Schleife mit einer Variablen `i`, die bei 0 beginnt und bei jedem Durchlauf der Schleife um 1 erhöht wird. Die Schleife sollte so lange laufen, wie `i` kleiner als `limit` ist.
+
+Bei jeder Iteration der Schleife addiere die Zahl `i` zur Variablen `total`. Um dies zu tun, kannst du diese Anweisung verwenden:
+
+``js
+total += i
+```
+
+Wenn diese Anweisung in einer for-Schleife verwendet wird, kann man sie auch als _Akkumulator_ bezeichnen.  Stelle dir die Anweisung wie die laufende Summe einer Registrierkasse vor, bei der jeder Posten gescannt und addiert wird.  In dieser Aufgabe hast du 10 Artikel, die zufällig jeweils um 1 teurer werden (wobei der erste Artikel gratis ist!).
+
+Nach der for-Schleife gibst du mit `console.log()` die Variable `total` auf dem Terminal aus.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+``bash
+javascripting verify for-loop.js
+```
diff --git a/problems/for-loop/solution_de.md b/problems/for-loop/solution_de.md
new file mode 100644
index 00000000..70f6576c
--- /dev/null
+++ b/problems/for-loop/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# DIE SUMME IST 45
+
+Dies ist eine grundlegende Einführung in for-Schleifen, die in vielen Situationen nützlich sind, insbesondere in Kombination mit anderen Datentypen wie Strings und Arrays.
+
+In der nächsten Aufgabe werden wir anfangen, mit **Arrays** zu arbeiten.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---
diff --git a/problems/if-statement/problem_de.md b/problems/if-statement/problem_de.md
new file mode 100644
index 00000000..8a3f1722
--- /dev/null
+++ b/problems/if-statement/problem_de.md
@@ -0,0 +1,32 @@
+Bedingte Anweisungen werden verwendet, um den Kontrollfluss eines Programms auf der Grundlage einer bestimmten booleschen Bedingung zu ändern.
+
+Eine bedingte Anweisung sieht wie folgt aus:
+
+```js
+if (n > 1) {
+  console.log('die Variable n ist größer als 1.')
+} else {
+  console.log('die Variable n ist kleiner oder gleich 1.')
+}
+```
+
+Innerhalb der Klammern musst du eine logische Anweisung eingeben, was bedeutet, dass das Ergebnis der Anweisung entweder wahr oder falsch ist. 
+
+Der else-Block ist optional und enthält den Code, der ausgeführt wird, wenn die Anweisung falsch ist.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `if-statement.js`.
+
+Deklariere in dieser Datei eine Variable namens `fruit`.
+
+Weise der Variable `fruit` den String-Wert **"orange"** zu.
+
+Verwende dann `console.log()`, um "**The fruit name has more than five characters.**" zu drucken, wenn die Länge des Wertes von `fruit` größer als fünf ist.
+Andernfalls drucke "**The fruit name has five characters or less.**"
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify if-statement.js
+```
diff --git a/problems/if-statement/solution_de.md b/problems/if-statement/solution_de.md
new file mode 100644
index 00000000..b0df56a1
--- /dev/null
+++ b/problems/if-statement/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# CONDITIONAL MASTER
+
+Du hast es geschafft! Die Zeichenkette `orange` hat mehr als fünf Zeichen.
+
+Mach dich als nächstes bereit für die **for-Schleife**!
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---
diff --git a/problems/number-to-string/problem_de.md b/problems/number-to-string/problem_de.md
new file mode 100644
index 00000000..a618541a
--- /dev/null
+++ b/problems/number-to-string/problem_de.md
@@ -0,0 +1,24 @@
+Manchmal müsst du eine Zahl in einen String umwandeln.
+
+In diesen Fällen verwendest du die Methode `.toString()`. Hier ist ein Beispiel:
+
+```js
+let n = 256
+n = n.toString()
+```
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `number-to-string.js`.
+
+Definiere in dieser Datei eine Variable namens `n`, die auf die Zahl `128` verweist.
+
+Rufe die Methode `.toString()` für die Variable `n` auf.
+
+Verwende `console.log()`, um die Ergebnisse der Methode `.toString()` auf dem Terminal auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+``bash
+javascripting verify number-to-string.js
+```
diff --git a/problems/number-to-string/solution_de.md b/problems/number-to-string/solution_de.md
new file mode 100644
index 00000000..331324da
--- /dev/null
+++ b/problems/number-to-string/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# DIESE ZAHL IST JETZT EIN STRING!
+
+Ausgezeichnet. Gute Arbeit bei der Umwandlung dieser Zahl in eine Zeichenkette.
+
+In der nächsten Aufgabe werden wir einen Blick auf **if-Anweisungen** werfen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---
diff --git a/problems/numbers/problem_de.md b/problems/numbers/problem_de.md
new file mode 100644
index 00000000..8a4783f6
--- /dev/null
+++ b/problems/numbers/problem_de.md
@@ -0,0 +1,15 @@
+Numbers, oder auch Zahlen, können ganze Zahlen sein, wie `2`, `14` oder `4353`, oder sie können
+Dezimalzahlen sein, auch bekannt als Floats, wie `3.14`, `1.5`, oder `100.7893423`.
+Im Gegensatz zu Strings müssen Zahlen nicht in Anführungszeichen gesetzt werden.
+
+## Die Aufgabe:
+
+Erstelle eine Datei namens `numbers.js`.
+
+Definiere in dieser Datei eine Variable namens `example`, die auf die ganze Zahl `123456789` verweist.
+
+Verwende `console.log()`, um diese Zahl auf dem Terminal auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+`javascripting verify numbers.js`
diff --git a/problems/numbers/solution_de.md b/problems/numbers/solution_de.md
new file mode 100644
index 00000000..48bc08a7
--- /dev/null
+++ b/problems/numbers/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# YEAH! NUMBERS!
+
+Cool, du hast erfolgreich eine Variable als die Zahl `123456789` definiert.
+
+In der nächsten Aufgabe werden wir uns mit der Manipulation von Zahlen beschäftigen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe zu wählen.
+
+---

From f3b1b6fb6f054e5fcacb771f8780667a4a269c33 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 26 Jan 2023 09:27:46 +0100
Subject: [PATCH 05/12] translate accessing-array-values

---
 problems/accessing-array-values/problem_de.md | 40 +++++++++++++++++++
 .../accessing-array-values/solution_de.md     | 11 +++++
 2 files changed, 51 insertions(+)
 create mode 100644 problems/accessing-array-values/problem_de.md
 create mode 100644 problems/accessing-array-values/solution_de.md

diff --git a/problems/accessing-array-values/problem_de.md b/problems/accessing-array-values/problem_de.md
new file mode 100644
index 00000000..70a3f514
--- /dev/null
+++ b/problems/accessing-array-values/problem_de.md
@@ -0,0 +1,40 @@
+Array-Elemente können über die Indexnummer aufgerufen werden.
+
+Die Indexnummer beginnt bei Null und endet bei der Länge des Array-Properties minus eins.
+
+Hier ist ein Beispiel:
+
+```js
+const pets = ['Katze', 'Hund', 'Ratte']
+
+console.log(pets[0])
+```
+
+Der obige Code gibt das erste Element des Array pets aus - die Zeichenfolge Katze.
+
+Array-Elemente können ausschließlich über die Klammernotation aufgerufen werden.
+
+Die Punktnotation ist ungültig.
+
+Gültige Notation:
+```js
+console.log(pets[0])
+```
+Ungültige Notation:
+```js
+console.log(pets.1);
+```
+Die Herausforderung:
+
+Erstelle eine Datei mit dem Namen accessing-array-values.js.
+
+Definiere in dieser Datei das Array food:
+```js
+const food = ['Apfel', 'Pizza', 'Birne']
+```
+Verwende console.log(), um den zweiten Wert des Arrays in die Konsole auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+```js
+javascripting verify accessing-array-values.js
+```
\ No newline at end of file
diff --git a/problems/accessing-array-values/solution_de.md b/problems/accessing-array-values/solution_de.md
new file mode 100644
index 00000000..9a53dc57
--- /dev/null
+++ b/problems/accessing-array-values/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# ZWEITES ELEMENT DES ARRAYS AUSGEGEBEN!
+
+Gut gemacht!
+
+In der nächsten Aufgabe arbeiten wir mit einem Beispiel zum Durchlaufen von Arrays.
+
+Führe `javascripting` im Terminal aus, um die nächste Aufgabe auszuwählen.
+
+---
\ No newline at end of file

From 7e90babc55b1b4a027f3920fa2fefab52c6f3edc Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 26 Jan 2023 09:58:31 +0100
Subject: [PATCH 06/12] translate looping-through-arrays

---
 problems/looping-through-arrays/problem_de.md | 43 +++++++++++++++++++
 .../looping-through-arrays/solution_de.md     | 11 +++++
 2 files changed, 54 insertions(+)
 create mode 100644 problems/looping-through-arrays/problem_de.md
 create mode 100644 problems/looping-through-arrays/solution_de.md

diff --git a/problems/looping-through-arrays/problem_de.md b/problems/looping-through-arrays/problem_de.md
new file mode 100644
index 00000000..006d1a48
--- /dev/null
+++ b/problems/looping-through-arrays/problem_de.md
@@ -0,0 +1,43 @@
+Für diese Aufgabe werden wir eine **For-Schleife** verwenden, um auf eine Liste von Werten in einem Array zuzugreifen und diese zu manipulieren.
+
+Der Zugriff auf Array-Werte kann mit einem Integer erfolgen.
+
+Jedes Element in einem Array wird durch eine Nummer identifiziert, die bei `0` beginnt.
+
+In diesem Array wird `hi` also durch die Nummer `1` identifiziert:
+
+```js
+const greetings = ['Hallo', 'Hi', 'Guten Morgen']
+```
+
+Es kann so aufgerufen werden:
+
+```js
+greetings[1]
+```
+
+Daher verwenden wir in einer **For-Schleife** die Variable `i` innerhalb der eckigen Klammern anstatt direkt einen Integer zu verwenden.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `looping-through-arrays.js`.
+
+Definiere in dieser Datei eine Variable mit dem Namen pets, die auf folgendes Array verweist:
+
+```js
+['cat', 'dog', 'rat']
+```
+
+Erstelle eine Schleife, die jeden String im Array so verändert, dass er im Plural steht.
+Du wirst innerhalb der Schleife folgende Anweisung verwenden:
+
+```js
+pets[i] = pets[i] + 's'
+```
+
+Verwende nach der Schleife `console.log()`, um das Array `pets` im Terminal auszugeben.
+Überprüfe, ob dein Programm korrekt funktioniert, indem du folgenden Befehl ausführst:
+
+```bash
+javascripting verify looping-through-arrays.js
+```
\ No newline at end of file
diff --git a/problems/looping-through-arrays/solution_de.md b/problems/looping-through-arrays/solution_de.md
new file mode 100644
index 00000000..a5be3728
--- /dev/null
+++ b/problems/looping-through-arrays/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# Erfolg! Viele Tiere!
+
+Jetzt sind alle Elemente im Array `pets` im Plural!
+
+In der nächsten Aufgabe werden wir uns von Arrays zur Arbeit mit *Objekten* bewegen.
+
+Führe `javascripting` im Terminal aus, um die nächste Aufgabe auszuwählen.
+
+---

From 01a6111b45cfe4d0686f73ccf124fccd0d9bdd63 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 26 Jan 2023 10:02:14 +0100
Subject: [PATCH 07/12] fix formatting

---
 problems/accessing-array-values/problem_de.md | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/problems/accessing-array-values/problem_de.md b/problems/accessing-array-values/problem_de.md
index 70a3f514..0bdf51d8 100644
--- a/problems/accessing-array-values/problem_de.md
+++ b/problems/accessing-array-values/problem_de.md
@@ -5,36 +5,43 @@ Die Indexnummer beginnt bei Null und endet bei der Länge des Array-Properties m
 Hier ist ein Beispiel:
 
 ```js
-const pets = ['Katze', 'Hund', 'Ratte']
+const pets = ['cat', 'dog', 'rat']
 
 console.log(pets[0])
 ```
 
-Der obige Code gibt das erste Element des Array pets aus - die Zeichenfolge Katze.
+Der obige Code gibt das erste Element des Array `pets` aus - die Zeichenfolge `cat`.
 
 Array-Elemente können ausschließlich über die Klammernotation aufgerufen werden.
 
 Die Punktnotation ist ungültig.
 
 Gültige Notation:
+
 ```js
 console.log(pets[0])
 ```
+
 Ungültige Notation:
+
 ```js
 console.log(pets.1);
 ```
-Die Herausforderung:
 
-Erstelle eine Datei mit dem Namen accessing-array-values.js.
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `accessing-array-values.js`.
 
 Definiere in dieser Datei das Array food:
+
 ```js
-const food = ['Apfel', 'Pizza', 'Birne']
+const food = ['apple', 'pizza', 'pear']
 ```
-Verwende console.log(), um den zweiten Wert des Arrays in die Konsole auszugeben.
+
+Verwende `console.log()`, um den `zweiten` Wert des Arrays auf der Konsole auszugeben.
 
 Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
-```js
+
+```bash
 javascripting verify accessing-array-values.js
 ```
\ No newline at end of file

From 44870e128b19738695c22d585ba6c4f5ae4cae50 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 26 Jan 2023 10:14:50 +0100
Subject: [PATCH 08/12] translate objects

---
 problems/objects/problem_de.md  | 32 ++++++++++++++++++++++++++++++++
 problems/objects/solution_de.md | 11 +++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 problems/objects/problem_de.md
 create mode 100644 problems/objects/solution_de.md

diff --git a/problems/objects/problem_de.md b/problems/objects/problem_de.md
new file mode 100644
index 00000000..e4b63cea
--- /dev/null
+++ b/problems/objects/problem_de.md
@@ -0,0 +1,32 @@
+Objekte sind Listen von Werten, ähnlich wie Arrays, aber die Werte werden durch Schlüssel statt durch Ganzzahlen identifiziert.
+
+Hier ist ein Beispiel:
+
+```js
+const foodPreferences = {
+  pizza: 'yum',
+  salad: 'gross'
+}
+```
+
+## The challenge:
+
+Erstelle eine Datei mit dem Namen `objects.js.`
+
+In dieser Datei definiere eine Variable mit dem Namen `pizza` wie folgt:
+
+```js
+const pizza = {
+  toppings: ['cheese', 'sauce', 'pepperoni'],
+  crust: 'deep dish',
+  serves: 2
+}
+```
+
+Verwende `console.log()`, um das pizza-Objekt im Terminal auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du folgenden Befehl ausführst:
+
+```bash
+javascripting verify objects.js
+```
diff --git a/problems/objects/solution_de.md b/problems/objects/solution_de.md
new file mode 100644
index 00000000..ac28c074
--- /dev/null
+++ b/problems/objects/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# PIZZA OBJEKT IST DA.
+
+Du hast erfolgreich ein Objekt erstellt!
+
+In der nächsten Aufgabe werden wir uns auf den Zugriff auf Objekteigenschaften konzentrieren.
+
+Führe `javascripting` in der Konsole aus, um die nächste Herausforderung auszuwählen.
+
+---

From 49ee3de2d620e55bf0e8e8e305ff965ca9906279 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 23 Feb 2023 09:18:57 +0100
Subject: [PATCH 09/12] fix wording

---
 problems/objects/problem_de.md          | 2 +-
 problems/objects/solution_de.md         | 2 +-
 problems/revising-strings/problem_de.md | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/problems/objects/problem_de.md b/problems/objects/problem_de.md
index e4b63cea..062b760b 100644
--- a/problems/objects/problem_de.md
+++ b/problems/objects/problem_de.md
@@ -9,7 +9,7 @@ const foodPreferences = {
 }
 ```
 
-## The challenge:
+## Die Aufgabe:
 
 Erstelle eine Datei mit dem Namen `objects.js.`
 
diff --git a/problems/objects/solution_de.md b/problems/objects/solution_de.md
index ac28c074..3234db01 100644
--- a/problems/objects/solution_de.md
+++ b/problems/objects/solution_de.md
@@ -6,6 +6,6 @@ Du hast erfolgreich ein Objekt erstellt!
 
 In der nächsten Aufgabe werden wir uns auf den Zugriff auf Objekteigenschaften konzentrieren.
 
-Führe `javascripting` in der Konsole aus, um die nächste Herausforderung auszuwählen.
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe auszuwählen.
 
 ---
diff --git a/problems/revising-strings/problem_de.md b/problems/revising-strings/problem_de.md
index 33a3cdfb..5c69dba7 100644
--- a/problems/revising-strings/problem_de.md
+++ b/problems/revising-strings/problem_de.md
@@ -14,7 +14,7 @@ Um den Wert zu ändern, auf den die Variable `example` verweist, müssen wir
 wieder das Gleichheitszeichen verwenden, diesmal mit der Methode `example.replace()` rechts vom  
 rechts vom Gleichheitszeichen.
 
-## Die Herausforderung:
+## Die Aufgabe:
 
 Erstelle eine Datei namens `revising-strings.js`.
 

From d7ac00132aa52d547d801e4c9bfaa8774cc887b0 Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 9 Mar 2023 10:01:17 +0100
Subject: [PATCH 10/12] translate object-properties

---
 problems/object-properties/problem_de.md  | 43 +++++++++++++++++++++++
 problems/object-properties/solution_de.md | 11 ++++++
 problems/objects/problem_de.md            |  2 +-
 3 files changed, 55 insertions(+), 1 deletion(-)
 create mode 100644 problems/object-properties/problem_de.md
 create mode 100644 problems/object-properties/solution_de.md

diff --git a/problems/object-properties/problem_de.md b/problems/object-properties/problem_de.md
new file mode 100644
index 00000000..2404bcc1
--- /dev/null
+++ b/problems/object-properties/problem_de.md
@@ -0,0 +1,43 @@
+Du kannst auf Objekteigenschaften zugreifen und sie manipulieren –– die Schlüssel und Werte, die ein Objekt enthält –– indem du eine Methode verwendest, die sehr ähnlich zu Arrays ist.
+
+Hier ist ein Beispiel mit **eckigen Klammern**:
+
+```js
+const example = {
+  pizza: 'yummy'
+}
+
+console.log(example['pizza'])
+```
+
+Der obige Code wird den String `'yummy'` auf der Konsole ausgeben.
+
+Alternativ kannst du **Punkt-Notation** verwenden, um identische Ergebnisse zu erzielen:
+
+```js
+example.pizza
+
+example['pizza']
+```
+
+Die beiden Codezeilen oben geben beide `yummy` zurück.
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `object-properties.js`.
+
+Definiere in dieser Datei eine Variable namens `food` wie folgt:
+
+```js
+const food = {
+  types: 'only pizza'
+}
+```
+
+Verwende `console.log()`, um die Eigenschaft `types` des `food`-Objekts auf der Konsole auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du folgenden Befehl ausführst:
+
+```bash
+javascripting verify object-properties.js
+```
diff --git a/problems/object-properties/solution_de.md b/problems/object-properties/solution_de.md
new file mode 100644
index 00000000..bf6a7696
--- /dev/null
+++ b/problems/object-properties/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# KORREKT. PIZZA IST DAS EINZIGE ESSEN.
+
+Du hast erfolgreich auf diese Eigenschaft zugegriffen.
+
+In der nächsten Aufgabe dreht sich alles um **Objektschlüssel** bzw **Object keys**.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe auszuwählen.
+
+---
diff --git a/problems/objects/problem_de.md b/problems/objects/problem_de.md
index 062b760b..b1c1496a 100644
--- a/problems/objects/problem_de.md
+++ b/problems/objects/problem_de.md
@@ -23,7 +23,7 @@ const pizza = {
 }
 ```
 
-Verwende `console.log()`, um das pizza-Objekt im Terminal auszugeben.
+Verwende `console.log()`, um das `pizza`-Objekt im Terminal auszugeben.
 
 Überprüfe, ob dein Programm korrekt ist, indem du folgenden Befehl ausführst:
 

From 553942d1790571bbdea8c8c1cc201d30f50ed6ef Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 9 Mar 2023 10:08:17 +0100
Subject: [PATCH 11/12] translate object-keys

---
 problems/object-keys/problem.md     |  2 +-
 problems/object-keys/problem_de.md  | 43 +++++++++++++++++++++++++++++
 problems/object-keys/solution_de.md | 11 ++++++++
 3 files changed, 55 insertions(+), 1 deletion(-)
 create mode 100644 problems/object-keys/problem_de.md
 create mode 100644 problems/object-keys/solution_de.md

diff --git a/problems/object-keys/problem.md b/problems/object-keys/problem.md
index 1b07c63f..0c58b56e 100644
--- a/problems/object-keys/problem.md
+++ b/problems/object-keys/problem.md
@@ -14,7 +14,7 @@ const keys = Object.keys(car)
 console.log(keys)
 ```
 
-The above code will print an array of strings, where each string is a key in the car object. `['make', 'model', 'year']`
+The above code will print an array of strings, where each string is a key in the `car` object. `['make', 'model', 'year']`
 
 ## The challenge:
 
diff --git a/problems/object-keys/problem_de.md b/problems/object-keys/problem_de.md
new file mode 100644
index 00000000..6e5ac83c
--- /dev/null
+++ b/problems/object-keys/problem_de.md
@@ -0,0 +1,43 @@
+JavaScript bietet eine native Möglichkeit, alle verfügbaren Schlüssel/Keys eines Objekts aufzulisten. Dies kann nützlich sein, um durch alle Eigenschaften eines Objekts zu iterieren und ihre Werte entsprechend zu manipulieren.
+
+Hier ist ein Beispiel zum Auflisten aller Objektschlüssel mit der Methode des Prototyps **Object.keys()**:
+
+```js
+const car = {
+  make: 'Toyota',
+  model: 'Camry',
+  year: 2020
+}
+const keys = Object.keys(car)
+
+console.log(keys)
+```
+
+Der obige Code gibt ein Array von Strings aus, wobei jeder String ein Key im `car`-Objekt ist. `['make', 'model', 'year']`
+
+## Die Aufgabe:
+
+Erstelle eine Datei mit dem Namen `object-keys.js`.
+
+Definiere in dieser Datei eine Variable namens `car` wie folgt:
+
+```js
+const car = {
+  make: 'Honda',
+  model: 'Accord',
+  year: 2020
+}
+```
+
+Definiere dann eine weitere Variable namens `keys` wie folgt:
+```js
+const keys = Object.keys(car)
+```
+
+Verwende `console.log()`, um die Variable `keys` auf der Konsole auszugeben.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify object-keys.js
+```
diff --git a/problems/object-keys/solution_de.md b/problems/object-keys/solution_de.md
new file mode 100644
index 00000000..64c7e7ed
--- /dev/null
+++ b/problems/object-keys/solution_de.md
@@ -0,0 +1,11 @@
+---
+
+# KORREKT.
+
+Gut gemacht, dass du die Object.keys() Prototype-Methode verwendet hast. Denke daran, sie zu verwenden, wenn du die Keys eines Objekts auflisten musst.
+
+In der nächsten Aufgabe geht es um Funktionen.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe auszuwählen.
+
+---

From c8d0a2c0dc57645ff61434af855ebfa6eacd676c Mon Sep 17 00:00:00 2001
From: aubcel <celestine.auburger@peerigon.com>
Date: Thu, 9 Mar 2023 10:37:28 +0100
Subject: [PATCH 12/12] translate functions

---
 problems/functions/problem_de.md  | 37 +++++++++++++++++++++++++++++++
 problems/functions/solution_de.md |  9 ++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 problems/functions/problem_de.md
 create mode 100644 problems/functions/solution_de.md

diff --git a/problems/functions/problem_de.md b/problems/functions/problem_de.md
new file mode 100644
index 00000000..f2544fe3
--- /dev/null
+++ b/problems/functions/problem_de.md
@@ -0,0 +1,37 @@
+Eine Funktion ist ein Block von Code, der eine Eingabe entgegennimmt, diese Eingabe verarbeitet und dann eine Ausgabe produziert.
+
+Hier ist ein Beispiel:
+
+```js
+function example (x) {
+  return x * 2
+}
+```
+
+Wir können diese Funktion wie folgt **aufrufen**, um die Zahl 10 zu erhalten:
+
+```js
+example(5)
+```
+
+Das obige Beispiel geht davon aus, dass die Funktion `example` eine Zahl als Argument -- als Eingabe -- entgegennimmt und diese Zahl mit 2 multipliziert zurückgibt.
+
+## Die Aufgabe:
+
+Erstelle eine Datei namens `functions.js`.
+
+Definiere in dieser Datei eine Funktion namens `eat`, die ein Argument namens `food` annimmt und erwartet, dass es sich dabei um einen String handelt.
+
+Gib innerhalb der Funktion das `food`-Argument auf folgende Weise zurück:
+
+```js
+return food + ' tasted really good.'
+```
+
+Rufe die `eat()`-Funktion mit dem String `bananas` als Argument innerhalb der Klammern von `console.log()` auf.
+
+Überprüfe, ob dein Programm korrekt ist, indem du diesen Befehl ausführst:
+
+```bash
+javascripting verify functions.js
+```
diff --git a/problems/functions/solution_de.md b/problems/functions/solution_de.md
new file mode 100644
index 00000000..ab97f02a
--- /dev/null
+++ b/problems/functions/solution_de.md
@@ -0,0 +1,9 @@
+---
+
+# WOOO BANANEN
+
+Du hast es geschafft! Du hast eine Funktion erstellt, die Eingaben entgegennimmt, verarbeitet und Ausgaben liefert.
+
+Führe `javascripting` in der Konsole aus, um die nächste Aufgabe auszuwählen.
+
+---