/g).length
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
CatPhotoApp
+
+ Click here to view more cat photos .
+
+
+
Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+
Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md
new file mode 100644
index 00000000000..998488caefd
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md
@@ -0,0 +1,60 @@
+---
+id: bd7123c8c441eddfaeb5bdef
+title: Sag Hallo zu HTML Elementen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cE8Gpt2'
+forumTopicId: 18276
+dashedName: say-hello-to-html-elements
+---
+
+# --description--
+
+Willkommen zu den HTML-Programmieraufgaben von freeCodeCamp. Diese werden dich Schritt für Schritt durch die Webentwicklung führen.
+
+Zuerst wirst du eine einfache Webseite mit HTML erstellen. Du kannst Code in deinem Code-Editor bearbeiten, der in diese Webseite eingebettet ist.
+
+Siehst du den Code in deinem Code-Editor, der `
Hello ` sagt? Das ist ein HTML-Element.
+
+Die meisten HTML-Elemente haben einen öffnenden Tag und einen schließenden Tag.
+
+Öffnende Tags sehen so aus:
+
+```html
+
+```
+
+Schließende Tags sehen so aus:
+
+```html
+
+```
+
+Der einzige Unterschied zwischen öffnenden und schließenden Tags ist der Schrägstrich nach der öffnenden Klammer eines schließenden Tags.
+
+Für jede Aufgabe gibt es Tests, die du jederzeit ausführen kannst, indem du auf den Button "Tests ausführen" klickst. Wenn du alle Tests bestanden hast, wirst du aufgefordert, deine Lösung einzureichen und zur nächsten Programmieraufgabe zu gehen.
+
+# --instructions--
+
+Um den Test für diese Aufgabe zu bestehen, ändere den Text deines `h1`-Elements zu `Hello World`.
+
+# --hints--
+
+Dein `h1`-Element sollte den Text `Hello World` enthalten.
+
+```js
+assert.isTrue(/hello(\s)+world/gi.test($('h1').text()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
Hello
+```
+
+# --solutions--
+
+```html
+
Hello World
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md
new file mode 100644
index 00000000000..043f8b4456d
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md
@@ -0,0 +1,80 @@
+---
+id: bad87fee1348bd9aedf08820
+title: Ein Bild in einen Link umwandeln
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cRdBnUr'
+forumTopicId: 18327
+dashedName: turn-an-image-into-a-link
+---
+
+# --description--
+
+Du kannst Elemente zu Links werden lassen, indem du sie innerhalb eines `a`-Elements einbettest.
+
+Bette dein Bild in ein `a`-Element ein. Hier ist ein Beispiel:
+
+```html
+
+```
+
+Denke daran, `#` als `a`-Eigenschaft des Elements `href` zu verwenden, um es in einen toten Link zu verwandeln.
+
+# --instructions--
+
+Platziere das vorhandene Bildelement in einem `a` (*anchor*) Element.
+
+Wenn du dies getan hast, fahre mit dem Mauszeiger über dein Bild. Der normale Mauszeiger sollte sich zum Mauszeiger für das Anklicken von Links ändern. Das Foto ist jetzt ein Link.
+
+# --hints--
+
+Das vorhandene `img` Element sollte innerhalb eines `a` Elements eingebettet sein.
+
+```js
+assert($('a').children('img').length > 0);
+```
+
+Dein `a`-Element sollte ein toter Link mit einem `href`-Attribut sein, das auf `#` gesetzt ist.
+
+```js
+assert(new RegExp('#').test($('a').children('img').parent().attr('href')));
+```
+
+Jedes deiner `a`-Elemente sollte einen schließenden Tag besitzen.
+
+```js
+assert(
+ code.match(/<\/a>/g) &&
+ code.match(/
/g).length === code.match(/ CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+ Purr jump eat the grass rip the couch scratched sunbathe, shed everywhere rip the couch sleep in the sink fluffy fur catnip scratched.
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+ Purr jump eat the grass rip the couch scratched sunbathe, shed everywhere rip the couch sleep in the sink fluffy fur catnip scratched.
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/uncomment-html.md b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/uncomment-html.md
new file mode 100644
index 00000000000..7f57e3ca1a3
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/uncomment-html.md
@@ -0,0 +1,70 @@
+---
+id: bad87fee1348bd9aedf08802
+title: HTML-Kommentare aufheben
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cBmG9T7'
+forumTopicId: 18329
+dashedName: uncomment-html
+---
+
+# --description--
+
+Das Kommentieren ist eine Möglichkeit, Kommentare für andere Entwickler innerhalb deines Codes zu hinterlassen, ohne die resultierende Ausgabe, die dem Endbenutzer angezeigt wird, zu beeinflussen.
+
+Kommentieren ist auch eine bequeme Möglichkeit, Code inaktiv zu machen, ohne ihn vollständig löschen zu müssen.
+
+Kommentare in HTML beginnen mit ``
+
+# --instructions--
+
+Entfernen die Kommentierung der Elemente `h1`, `h2` und `p`.
+
+# --hints--
+
+Dein `h1`-Element sollte auf der Seite sichtbar sein, indem du die Kommentierung aufhebst.
+
+```js
+assert($('h1').length > 0);
+```
+
+Dein `h2`-Element sollte auf der Seite sichtbar sein, indem du die Kommentierung aufhebst.
+
+```js
+assert($('h2').length > 0);
+```
+
+Dein `p`-Element sollte auf der Seite sichtbar sein, indem du die Kommentierung aufhebst.
+
+```js
+assert($('p').length > 0);
+```
+
+Auf der Seite sollten keine schließenden Kommentar-Tags sichtbar sein (d. h. `-->`).
+
+```js
+assert(!$('*:contains("-->")')[1]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+# --solutions--
+
+```html
+Hello World
+
+CatPhotoApp
+
+Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md
new file mode 100644
index 00000000000..5f1d1c86cce
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md
@@ -0,0 +1,86 @@
+---
+id: bad87fee1348bd9aedc08830
+title: Verwende HTML5, um eine Eingabe in einem Feld zu verlangen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cMd4EcQ'
+forumTopicId: 18360
+dashedName: use-html5-to-require-a-field
+---
+
+# --description--
+
+Du kannst bestimmte Formularfelder erforderlich machen, so dass dein Benutzer dein Formular nicht abschicken kann, bevor er oder sie es ausgefüllt hat.
+
+Wenn du zum Beispiel ein Texteingabefeld erforderlich machen willst, kannst du einfach das Attribut `required` innerhalb deines `input`-Elements hinzufügen, etwa so: `CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md
new file mode 100644
index 00000000000..38c618857d5
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md
@@ -0,0 +1,148 @@
+---
+id: 5c6c06847491271903d37cfd
+title: Verwende das value-Attribut bei Radiobuttons und Checkboxen
+challengeType: 0
+forumTopicId: 301099
+dashedName: use-the-value-attribute-with-radio-buttons-and-checkboxes
+---
+
+# --description--
+
+Wenn ein Formular abgeschickt wird, werden die Daten an den Server gesendet und enthalten Angaben zu den ausgewählten Optionen. Input-Elemente vom Typ `radio` und `checkbox` melden ihre Werte aus dem `value`-Attribut.
+
+Zum Beispiel:
+
+```html
+
+
+
+
+```
+
+Hier gibt es zwei `radio`-Inputs. Wenn der Benutzer das Formular mit der ausgewählten Option `indoor` absendet, enthalten die Formulardaten die Zeile: `indoor-outdoor=indoor`. Dies ergibt sich aus den Attributen `name` und `value` des Inputs "indoor".
+
+Wenn du das `value`-Attribut weglässt, verwenden die übermittelten Formulardaten den Standardwert `on`. Wenn der Benutzer in diesem Szenario auf die Option "indoor" klickt und das Formular abschickt, würden die resultierenden Formulardaten `indoor-outdoor=on` lauten, was nicht sinnvoll ist. Daher muss das `value`-Attribut auf etwas gesetzt werden, um die Option zu identifizieren.
+
+# --instructions--
+
+Gib jedem der vorhandenen Inputs `radio` und `checkbox` das Attribut `value`. Erstelle keine neuen Radio- oder Checkbox-Elemente. Verwende den Labeltext des Inputs, in Kleinbuchstaben, als Wert für das Attribut.
+
+# --hints--
+
+Einer deiner Radiobutton sollte das `value`-Attribut `indoor` besitzen.
+
+```js
+assert(
+ $('label:contains("Indoor") > input[type="radio"]').filter("[value='indoor']")
+ .length > 0
+);
+```
+
+Einer deiner Radiobutton sollte das `value`-Attribut `outdoor` besitzen.
+
+```js
+assert(
+ $('label:contains("Outdoor") > input[type="radio"]').filter(
+ "[value='outdoor']"
+ ).length > 0
+);
+```
+
+Eine deiner Checkboxen sollte das `value`-Attribut `loving` besitzen.
+
+```js
+assert(
+ $('label:contains("Loving") > input[type="checkbox"]').filter(
+ "[value='loving']"
+ ).length > 0
+);
+```
+
+Eine deiner Checkboxen sollte das `value`-Attribut `lazy` besitzen.
+
+```js
+assert(
+ $('label:contains("Lazy") > input[type="checkbox"]').filter("[value='lazy']")
+ .length > 0
+);
+```
+
+Eine deiner Checkboxen sollte das `value`-Attribut `energetic` besitzen.
+
+```js
+assert(
+ $('label:contains("Energetic") > input[type="checkbox"]').filter(
+ "[value='energetic']"
+ ).length > 0
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md
new file mode 100644
index 00000000000..9394b266b4a
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md
@@ -0,0 +1,258 @@
+---
+id: 587d78ab367417b2b2512af1
+title: Flex-Superkräfte zur Tweet-Einbettung hinzufügen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/c9W7MhM'
+forumTopicId: 301100
+dashedName: add-flex-superpowers-to-the-tweet-embed
+---
+
+# --description--
+
+Auf der rechten Seite ist der Tweet eingebettet, der als praktisches Beispiel verwendet werden soll. Einige der Elemente würden mit einem anderen Layout besser aussehen. Die letzte Aufgabe zeigte `display: flex`. Hier fügst du sie zu verschiedenen Komponenten im eingebetteten Tweet hinzu, um ihre Positionierung anzupassen.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `display: flex` zu allen folgenden Elementen hinzu - beachte, dass die Selektoren bereits im CSS definiert sind:
+
+Die Kopfzeile `header`, die Kopfzeile `.profile-name`, die Kopfzeile `.follow-btn`, die Kopfzeile `h3` und `h4`, der `footer` und die Fußzeile `.stats`.
+
+# --hints--
+
+Dein `.follow-btn` sollte auf der Seite gerendert werden. Achte darauf, dass du alle Erweiterungen wie Werbeblocker deaktivierst.
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+Dein `header` sollte eine Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('header').css('display') == 'flex');
+```
+
+Dein `footer` sollte die Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('footer').css('display') == 'flex');
+```
+
+Dein `h3` sollte eine Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('h3').css('display') == 'flex');
+```
+
+Dein `h4` sollte eine Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('h4').css('display') == 'flex');
+```
+
+Dein `.profile-name` sollte eine Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('.profile-name').css('display') == 'flex');
+```
+
+Dein `.follow-btn` sollte eine Eigenschaft `display` haben, die auf `flex` gesetzt ist.
+
+```js
+assert($('.follow-btn').css('display') == 'flex');
+```
+
+Dein `.stats` sollte eine Eigenschaft `display` besitzen, die auf `flex` gesetzt ist.
+
+```js
+assert($('.stats').css('display') == 'flex');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
flex-start: Richtet die Elemente am Anfang des Flex-Containers aus. Bei Reihen werden die Elemente am oberen Rand des Containers ausgerichtet. Bei Spalten werden die Elemente auf der linken Seite des Containers ausgerichtet.flex-end: Richtet Elemente am Ende des Flex-Containers aus. Bei Reihen werden die Elemente am unteren Rand des Containers ausgerichtet. Bei Spalten werden die Elemente auf der rechten Seite des Containers ausgerichtet.center: Richtet die Elemente in der Mitte aus. Bei Zeilen werden die Elemente vertikal ausgerichtet (gleicher Abstand über und unter den Elementen). Bei Spalten werden sie horizontal ausgerichtet (gleicher Abstand links und rechts von den Elementen).stretch: Streckt die Elemente, um den Flex-Container zu füllen. Zum Beispiel werden Zeilen so gestreckt, dass sie den Flex-Container von oben nach unten ausfüllen. Dies ist der Standardwert, wenn kein Wert für align-items angegeben wird.baseline: Richte die Gegenstände an ihren Grundlinien aus. Die Grundlinie ist ein Textkonzept. Stell sie dir als die Linie vor, auf der die Buchstaben stehen. Hier erfährst du mehr zu Flexbox-Eigenschaften
+
+Erinnere dich daran, dass beim Einsetzen eines Flex-Containers als Reihe, die Flex-Elemente von links nach rechts nebeneinander platziert werden. Ein Flex-Container, der als Spalte eingestellt ist, platziert die Flex-Elemente in einem vertikalen Stapel von oben nach unten. Bei jedem dieser Elemente wird die Richtung der Flex-Elemente als **Hauptachse** bezeichnet. Bei einer Reihe ist das eine horizontale Linie, die durch jedes Element verläuft. Und bei einer Spalte ist die Hauptachse eine vertikale Linie, die durch die Elemente verläuft.
+
+Es gibt verschiedene Möglichkeiten, wie du die Flex-Elemente entlang der Hauptachse anordnen kannst. Eine der am häufigsten verwendete Möglichkeit ist `justify-content: center;`, womit du alle Flex-Elemente in die Mitte des Flex-Containers ausrichtest. Weitere Möglichkeiten sind:
+
+
flex-start: Richtet die Elemente am Anfang des Flex-Containers aus. Bei einer Zeile werden die Elemente dadurch nach links in den Container verschoben. Bei einer Spalte werden die Elemente dadurch an den Anfang des Containers verschoben. Dies ist die Standardausrichtung, wenn kein justify-content angegeben ist.flex-end: Richtet Elemente am Ende des Flex-Containers aus. Bei einer Reihe werden die Elemente dadurch nach rechts in den Container verschoben. Bei einer Spalte werden die Elemente dadurch an den unteren Rand des Containers verschoben.space-between: Richtet die Elemente an der Mitte der Hauptachse aus, wobei zusätzlicher Platz zwischen den Elementen eingefügt wird. Das erste und das letzte Element werden an den äußersten Rand des Flex-Containers geschoben. In einer Reihe liegt zum Beispiel das erste Element an der linken Seite des Containers, das letzte Element liegt an der rechten Seite des Containers und der verbleibende Platz wird gleichmäßig auf die anderen Elemente verteilt.space-around: ähnelt space-between, aber das erste und das letzte Element werden nicht an den Rändern des Containers fixiert, sondern der Platz wird um alle Elemente herum verteilt, mit einem halben Abstand an beiden Enden des Flex-Containers.space-evenly: Verteilt den Platz zwischen den Flex-Items gleichmäßig mit einem vollen Abstand an beiden Enden des Flex-Containers.
+
+# --instructions--
+
+Ein Beispiel hilft, diese Eigenschaft in Aktion zu zeigen. Füge die CSS-Eigenschaft `justify-content` zum Element `#box-container` hinzu und gib ihm den Wert `center`.
+
+**Bonus**
+Probiere die anderen Optionen für die Eigenschaft `justify-content` im Code-Editor aus, um ihre Unterschiede zu sehen. Beachte aber, dass der Wert `center` der einzige ist, der diese Aufgabe bestehen kann.
+
+# --hints--
+
+Das Element `#box-container` sollte eine `justify-content`-Eigenschaft besitzen, die auf einen Wert von `center` gesetzt ist.
+
+```js
+assert($('#box-container').css('justify-content') == 'center');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-a-column-in-the-tweet-embed.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-a-column-in-the-tweet-embed.md
new file mode 100644
index 00000000000..68b357b0aa6
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-a-column-in-the-tweet-embed.md
@@ -0,0 +1,218 @@
+---
+id: 587d78ac367417b2b2512af5
+title: Verwende die flex-direction Eigenschaft, um eine Spalte in einer Tweet-Einbettung zu erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cnzdVC9'
+forumTopicId: 301103
+dashedName: apply-the-flex-direction-property-to-create-a-column-in-the-tweet-embed
+---
+
+# --description--
+
+Der `header` und der `footer` der Tweet-Einbettung verwendeten die `flex-direction` Eigenschaft früher mit einem row-Wert. In ähnlicher Weise würden die Elemente innerhalb von `.profile-name` gut übereinander funktionieren.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-direction` zum `.profile-name` Element des Headers hinzu und setze den Wert auf `column`.
+
+# --hints--
+
+Dein `.follow-btn` sollte auf der Seite gerendert werden. Stelle sicher, dass Add-ons wie Ad-Blocker deaktiviert sind.
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+Das `.profile-name` Element sollte eine `flex-direction` Eigenschaft mit Wert `column` haben.
+
+```js
+assert($('.profile-name').css('flex-direction') == 'column');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-rows-in-the-tweet-embed.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-rows-in-the-tweet-embed.md
new file mode 100644
index 00000000000..2c1e6c1ebdc
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/apply-the-flex-direction-property-to-create-rows-in-the-tweet-embed.md
@@ -0,0 +1,230 @@
+---
+id: 587d78ab367417b2b2512af3
+title: Wende die flex-direction Eigenschaft an, um Zeilen in einer Tweet-Einbettung zu erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cJb8yuq'
+forumTopicId: 301104
+dashedName: apply-the-flex-direction-property-to-create-rows-in-the-tweet-embed
+---
+
+# --description--
+
+Der `header` und der `footer` im Tweet-Einbettungsbeispiel haben je Unterelemente, die man mit der `flex-direction` Eigenschaft zeilenweise anordnen kann. Damit richtet CSS die Unterelemente horizontal aus.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-direction` sowohl zum `header` als auch zum `footer` und setze den Wert auf `row`.
+
+# --hints--
+
+Dein `.follow-btn` sollte auf der Seite gerendert werden. Stelle sicher, dass Add-ons wie Ad-Blocker deaktiviert sind.
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+Der `header` sollte eine `flex-direction` Eigenschaft mit Wert `row` haben.
+
+```js
+assert(code.match(/header\s*?{[^}]*?flex-direction:\s*?row;/g));
+```
+
+Der `footer` sollte eine `flex-direction` Eigenschaft mit Wert `row` haben.
+
+```js
+assert(code.match(/footer\s*?{[^}]*?flex-direction:\s*?row;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.md
new file mode 100644
index 00000000000..e5b4cc90baf
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.md
@@ -0,0 +1,82 @@
+---
+id: 587d78ab367417b2b2512af0
+title: 'Verwende display: flex um zwei Boxen anzuordnen'
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cgz3QS7'
+forumTopicId: 301105
+dashedName: use-display-flex-to-position-two-boxes
+---
+
+# --description--
+
+Dieser Abschnitt verwendet wechselnde Übungsarten, um zu zeigen, wie flexibel man mit CSS Elemente platzieren kann. Im ersten Teil einer Aufgabe wird je Theorie erklärt, dann folgt eine praktische Übung mit einer Tweet-Komponente, auf die wir das Flexbox-Konzept anwenden.
+
+Nachdem du einem Element die Eigenschaft `display: flex;` zuweist, hast du die Möglichkeit, mit weiteren Flex-Eigenschaften Seiten responsive zu gestalten.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `display` zu `#box-container` hinzu und setze seinen Wert auf `flex`.
+
+# --hints--
+
+`#box-container` sollte eine `display` Eigenschaft mit einem Wert von `flex` besitzen.
+
+```js
+assert($('#box-container').css('display') == 'flex');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+```
+
+# --solutions--
+
+```html
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-items-property-in-the-tweet-embed.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-items-property-in-the-tweet-embed.md
new file mode 100644
index 00000000000..acdb1b5bd69
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-items-property-in-the-tweet-embed.md
@@ -0,0 +1,222 @@
+---
+id: 587d78ad367417b2b2512af9
+title: Verwende die align-items Eigenschaft in dem eingebetteten Tweet
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cd3PNfq'
+forumTopicId: 301106
+dashedName: use-the-align-items-property-in-the-tweet-embed
+---
+
+# --description--
+
+In der letzten Aufgabe wurde die Eigenschaft `align-items` vorgestellt und ein Beispiel gezeigt. Man kann sie auf mehrere Elemente von Tweet-Einbettungen anwenden, um in ihnen enthaltene Flex-Elemente auszurichten.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `align-items` zum `.follow-btn` Element des Headers hinzu. Setze den Wert auf `center`.
+
+# --hints--
+
+Dein `.follow-btn` sollte auf der Seite gerendert werden. Stelle sicher, dass Add-ons wie Ad-Blocker deaktiviert sind.
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+Das `.follow-btn` Element sollte eine `align-items` Eigenschaft mit dem Wert `center` besitzen.
+
+```js
+assert($('.follow-btn').css('align-items') == 'center');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-self-property.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-self-property.md
new file mode 100644
index 00000000000..1c0736c17c0
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-align-self-property.md
@@ -0,0 +1,92 @@
+---
+id: 587d78af367417b2b2512b00
+title: Verwende die Eigenschaft align-self
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cMbvzfv'
+forumTopicId: 301107
+dashedName: use-the-align-self-property
+---
+
+# --description--
+
+Die letzte Eigenschaft für Flex-Elemente ist `align-self`. Diese Eigenschaft erlaubt dir, die Ausrichtung für jedes Element individuell festzulegen, anstatt sie alle auf einmal zu definieren. Dies ist nützlich, da andere übliche Anpassungstechniken mit den CSS-Eigenschaften `float`, `clear`, und `vertical-align` nicht auf Flex-Elemente funktionieren.
+
+`align-self` akzeptiert die gleichen Werte wie `align-items` und wird jegliche Werte überschreiben, die von der `align-items` Eigenschaft gesetzt wurden.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `align-self` sowohl zur `#box-1` als auch zur `#box-2` hinzu. Gib `#box-1` einen Wert von `center` und `#box-2` den Wert `flex-end`.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `align-self` Eigenschaft mit einem Wert von `center` haben.
+
+```js
+assert($('#box-1').css('align-self') == 'center');
+```
+
+Auf dem `#box-2` Element sollte die `align-self` Eigenschaft auf `flex-end` gesetzt sein.
+
+```js
+assert($('#box-2').css('align-self') == 'flex-end');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.md
new file mode 100644
index 00000000000..3cc2f19268b
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.md
@@ -0,0 +1,102 @@
+---
+id: 587d78ae367417b2b2512afd
+title: Verwende die Eigenschaft flex-basis, um die Anfangsgröße eines Elements festzulegen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/c3d9nCa'
+forumTopicId: 301108
+dashedName: use-the-flex-basis-property-to-set-the-initial-size-of-an-item
+---
+
+# --description--
+
+Die `flex-basis` Eigenschaft definiert die ursprüngliche Größe eines Elements, bevor CSS Anpassungen mittels `flex-shrink` oder `flex-grow` vornimmt.
+
+Die verwendeten Einheiten der `flex-basis` Eigenschaft sind dieselben wie bei anderen Größeneigenschaften (`px`, `em`, `%`, etc.). Der Wert `auto` skaliert Element auf Basis des Inhalts.
+
+# --instructions--
+
+Lege die Anfangsgröße der Boxen mit `flex-basis` fest. Füge die CSS-Eigenschaft `flex-basis` sowohl zu `#box-1` als auch zu `#box-2` hinzu. Gib `#box-1` einen Wert von `10em` und `#box-2` einen von `20em`.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `flex-basis` Eigenschaft besitzen.
+
+```js
+assert($('#box-1').css('flex-basis') != 'auto');
+```
+
+Das `#box-1` Element sollte einen `flex-basis` Wert von `10em` haben.
+
+```js
+assert(code.match(/#box-1\s*?{\s*?.*?\s*?.*?\s*?flex-basis:\s*?10em;/g));
+```
+
+Das `#box-2` Element sollte eine `flex-basis` Eigenschaft besitzen.
+
+```js
+assert($('#box-2').css('flex-basis') != 'auto');
+```
+
+Das `#box-2` Element sollte einen `flex-basis` Wert von `20em` haben.
+
+```js
+assert(code.match(/#box-2\s*?{\s*?.*?\s*?.*?\s*?flex-basis:\s*?20em;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.md
new file mode 100644
index 00000000000..bf26628dd70
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.md
@@ -0,0 +1,82 @@
+---
+id: 587d78ac367417b2b2512af4
+title: Verwende die flex-direction Eigenschaft, um eine Spalte zu erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cZmWeA4'
+forumTopicId: 301109
+dashedName: use-the-flex-direction-property-to-make-a-column
+---
+
+# --description--
+
+Die letzten beiden Aufgaben verwendeten die `flex-direction`-Eigenschaft mit dem Wert `row`. Diese Eigenschaft kann auch Spalten erstellen, indem sie die Unterelemente eines Flex-Containers vertikal stapelt.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-direction` zum `#box-container` Element hinzu und gib ihm einen Wert von `column`.
+
+# --hints--
+
+Das `#box-container` Element sollte eine `flex-direction` Eigenschaft mit Wert `column` besitzen.
+
+```js
+assert($('#box-container').css('flex-direction') == 'column');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.md
new file mode 100644
index 00000000000..16e60b2fb79
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.md
@@ -0,0 +1,86 @@
+---
+id: 587d78ab367417b2b2512af2
+title: Verwende die flex-direction Eigenschaft um eine Zeile zu bilden
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cBEkbfJ'
+forumTopicId: 301110
+dashedName: use-the-flex-direction-property-to-make-a-row
+---
+
+# --description--
+
+Durch Hinzufügen von `display: flex` wird ein Element zu einem Flex-Container. Dies ermöglicht es Unterelemente dieses Elements in Zeilen oder Spalten auszurichten. Du erreichst dies, indem du eine `flex-direction` Eigenschaft zum Elternelement hinzufügst und sie auf "row" (engl. Zeile) oder "column" (engl. Spalte) setzt. Durch Erstellen einer "row" werden die Unterelemente horizontal ausgerichtet und eine "column" ordnet sie vertikal an.
+
+Weitere Optionen für `flex-direction` sind `row-reverse` und `column-reverse`.
+
+**Hinweis:** Der Defaultwert der `flex-direction` Eigenschaft ist `row`.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-direction` zum Element `#box-container` hinzu und gib ihm einen Wert von `row-reverse`.
+
+# --hints--
+
+Das `#box-container` Element sollte eine `flex-direction` Eigenschaft mit Wert `row-reverse` haben.
+
+```js
+assert($('#box-container').css('flex-direction') == 'row-reverse');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.md
new file mode 100644
index 00000000000..55a7d331c82
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.md
@@ -0,0 +1,90 @@
+---
+id: 587d78ae367417b2b2512afc
+title: Verwende die flex-grow Eigenschaft, um Elemente auszudehnen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/c2p78cg'
+forumTopicId: 301111
+dashedName: use-the-flex-grow-property-to-expand-items
+---
+
+# --description--
+
+Das Gegenteil von `flex-shrink` ist die `flex-grow` Eigenschaft. Du erinnerst dich, dass `flex-shrink` die Größe von Elementen kontrolliert, wenn der Container schrumpft. Die `flex-grow` Eigenschaft kontrolliert die Größe von Elementen, wenn sich der Elterncontainer ausdehnt.
+
+Ein Beispiel ähnlich dem aus der letzten Aufgabe wäre, wenn ein Element einen `flex-grow`-Wert von `1` und das andere einen `flex-grow`-Wert von `3` hat, wächst das Element mit dem Wert `3` dreimal so stark wie das andere.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-grow` zur `#box-1` und zu `#box-2` hinzu. Gib `#box-1` einen Wert von `1` und `#box-2` einen Wert von `2`.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `flex-grow` Eigenschaft mit Wert `1` haben.
+
+```js
+assert($('#box-1').css('flex-grow') == '1');
+```
+
+Das `#box-2` Element sollte eine `flex-grow` Eigenschaft mit Wert `2` haben.
+
+```js
+assert($('#box-2').css('flex-grow') == '2');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.md
new file mode 100644
index 00000000000..4e9df2e6301
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.md
@@ -0,0 +1,106 @@
+---
+id: 587d78ae367417b2b2512afe
+title: Verwende die Kurzform der flex Eigenschaft
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cbpW2tE'
+forumTopicId: 301112
+dashedName: use-the-flex-shorthand-property
+---
+
+# --description--
+
+Es gibt eine Kurzform mit der man mehrere flex Eigenschaften auf einmal setzen kann. Die `flex-grow`, `flex-shrink`, und `flex-basis` Eigenschaften können alle gemeinsam mit der `flex` Sammeleigenschaft definiert werden.
+
+Zum Beispiel würde `flex: 1 0 10px;` ein Element auf `flex-grow: 1;`, `flex-shrink: 0;`, und `flex-basis: 10px;` setzen.
+
+Die Standardwerte sind `flex: 0 1 auto;`.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex` sowohl zu `#box-1` als auch zu `#box-2` hinzu. Setze die Werte von `#box-1` so, dass `flex-grow` einen Wert von `2` hat, `flex-shrink` `2` ist und seine `flex-basis` `150px` entspricht. Weise `#box-2` Werte zu, sodass `flex-grow` `1` ist, sein `flex-shrink` `1` entspricht und eine `flex-basis` von `150px` hat.
+
+Diese Werte werden auslösen, dass sich `#box-1` doppelt so viel ausdehnt, um Leerraum zu füllen, wie `#box-2` wenn der Container größer als 300px ist und doppelt so viel schrumpfen wie `#box-2`, wenn der Container kleiner als 300px ist. 300px ist die gemeinsame Größe der `flex-basis` Werte beider Boxen.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `flex` Eigenschaft mit einem Wert von `2 2 150px` besitzen.
+
+```js
+assert(
+ $('#box-1').css('flex-grow') == '2' &&
+ $('#box-1').css('flex-shrink') == '2' &&
+ $('#box-1').css('flex-basis') == '150px'
+);
+```
+
+Das `#box-2` Element sollte eine `flex` Eigenschaft mit einem Wert von `1 1 150px` haben.
+
+```js
+assert(
+ $('#box-2').css('flex-grow') == '1' &&
+ $('#box-2').css('flex-shrink') == '1' &&
+ $('#box-2').css('flex-basis') == '150px'
+);
+```
+
+Dein Code sollte die `flex` Eigenschaft für `#box-1` und `#box-2` verwenden.
+
+```js
+assert(code.match(/flex:\s*?\d\s+?\d\s+?150px;/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.md
new file mode 100644
index 00000000000..884eef8fdad
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.md
@@ -0,0 +1,94 @@
+---
+id: 587d78ad367417b2b2512afb
+title: Verwende die flex-shrink Eigenschaft um Elemente zu schrumpfen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cd3PBfr'
+forumTopicId: 301113
+dashedName: use-the-flex-shrink-property-to-shrink-items
+---
+
+# --description--
+
+Bisher gelten alle Eigenschaften in den Aufgaben für den Flex-Container (das übergeordnete Element der Flex-Elemente). Es gibt jedoch mehrere nützliche Eigenschaften für Flex-Elemente.
+
+Die erste ist die `flex-shrink` Eigenschaft. Wenn man sie verwendet, erlaubt es einem Element zu schrumpfen, falls der Flex-Container zu klein ist. Elemente schrumpfen, wenn die Breite des übergeordneten Containers kleiner ist als die kombinierte Breite aller Flex-Elemente in diesem Container.
+
+Die `flex-shrink` Eigenschaft akzeptiert Zahlen als Werte. Umso größer die Zahl, desto stärker wird das Element schrumpfen, verglichen mit anderen Elementen im selben Container. Hat zum Beispiel ein Element einen `flex-shrink` Wert von `1` und ein anderes einen `flex-shrink` Wert von `3`, dann wird das mit dem Wert von `3` dreimal so viel schrumpfen wie das andere.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `flex-shrink` zu `#box-1` und `#box-2` hinzu. Gib `#box-1` einen Wert von `1` und `#box-2` einen Wert von `2`.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `flex-shrink` Eigenschaft mit Wert `1` haben.
+
+```js
+assert($('#box-1').css('flex-shrink') == '1');
+```
+
+Das `#box-2` Element sollte eine `flex-shrink` Eigenschaft mit einem Wert von `2` haben.
+
+```js
+assert($('#box-2').css('flex-shrink') == '2');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md
new file mode 100644
index 00000000000..b3a51589981
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.md
@@ -0,0 +1,138 @@
+---
+id: 587d78ad367417b2b2512afa
+title: Verwende die flex-wrap Eigenschaft, um Zeilen oder Spalten umzubrechen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cQv9ZtG'
+forumTopicId: 301114
+dashedName: use-the-flex-wrap-property-to-wrap-a-row-or-column
+---
+
+# --description--
+
+CSS-Flexbox bietet die Möglichkeit einen Flex-Container in mehrere Zeilen (oder Spalten) aufzuteilen. Standardmäßig wird ein Flex-Container alle Elemente zusammensetzen. Zum Beispiel würde eine "row" eine einzige Zeile bilden.
+
+Die `flex-wrap` Eigenschaft hingegen sorgt dafür, dass Elemente umgebrochen werden. Das bedeutet, dass extra Element in eine neue Zeile oder Spalte wandern. Der Punkt an dem umgebrochen wird, hängt von der Größe der Elemente und der des Containers ab.
+
+In CSS gibt es auch Einstellungsmöglichkeiten für die Richtung des Umbruchs:
+
+
nowrap: ist der Standardwert und bricht die Elemente nicht um.wrap: bricht Elemente auf mehrere Zeilen von oben nach unten um, wenn sie in Zeilen stehen und von links nach rechts, wenn sie in Spalten stehen.wrap-reverse: bricht Elemente auf mehrere Zeilen von unten nach oben um, wenn sie in Zeilen stehen, und von rechts nach links, wenn sie in Spalten stehen.
+
+# --instructions--
+
+Das aktuelle Layout hat zu viele Boxen in einer Zeile. Füge die CSS-Eigenschaft `flex-wrap` zum `#box-container` Element hinzu und gib ihm einen Wert von `wrap`.
+
+# --hints--
+
+Das `#box-container` Element sollte eine `flex-wrap` Eigenschaft mit einem Wert von `wrap` haben.
+
+```js
+assert($('#box-container').css('flex-wrap') == 'wrap');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.md
new file mode 100644
index 00000000000..ab2942e2952
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.md
@@ -0,0 +1,224 @@
+---
+id: 587d78ac367417b2b2512af7
+title: Verwende die justify-content Eigenschaft in der Tweet-Einbettung
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/c43GgTa'
+forumTopicId: 301115
+dashedName: use-the-justify-content-property-in-the-tweet-embed
+---
+
+# --description--
+
+In der letzten Aufgabe wurde ein Beispiel für die Eigenschaft `justify-content` gezeigt. Bei der Tweet-Einbettung kann diese Eigenschaft angewendet werden, um die Elemente im Element `.profile-name` auszurichten.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `justify-content` zum `.profile-name`-Element der Kopfzeile hinzu und setze den Wert auf eine der Optionen der letzten Aufgabe.
+
+# --hints--
+
+Dein `.follow-btn` sollte auf der Seite dargestellt werden. Stelle sicher, dass Add-ons wie Ad-Blocker deaktiviert sind.
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+Das `.profile-name` Element sollte eine `justify-content` Eigenschaft mit einem der folgenden Werte haben: `center`, `flex-start`, `flex-end`, `space-between`, `space-around`, oder `space-evenly`.
+
+```js
+assert(
+ code.match(
+ /header\s.profile-name\s*{\s*?.*?\s*?.*?\s*?\s*?.*?\s*?justify-content\s*:\s*(center|flex-start|flex-end|space-between|space-around|space-evenly)\s*;/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.md b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.md
new file mode 100644
index 00000000000..981227dd935
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.md
@@ -0,0 +1,90 @@
+---
+id: 587d78ae367417b2b2512aff
+title: Bestellungseigenschaft verwenden, um Artikel neu zu ordnen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/cMbvNAG'
+forumTopicId: 301116
+dashedName: use-the-order-property-to-rearrange-items
+---
+
+# --description--
+
+Die Eigenschaft `order` wird verwendet, um CSS mitzuteilen, wie Flex-Elemente im Flex-Container dargestellt werden. Standardmäßig werden die Elemente in der gleichen Reihenfolge angezeigt, in der sie im HTML-Quelltext erscheinen. Die Eigenschaft nimmt Zahlen als Werte an, und es können auch negative Zahlen verwendet werden.
+
+# --instructions--
+
+Füge die CSS-Eigenschaft `order` sowohl zu `#box-1` als auch zu `#box-2` hinzu. Gib' `#box-1` den Wert `2` und `#box-2` den Wert `1`.
+
+# --hints--
+
+Das `#box-1` Element sollte eine `order` Eigenschaft mit einem Wert von `2` besitzen.
+
+```js
+assert($('#box-1').css('order') == '2');
+```
+
+Das `#box-2`-Element sollte eine `order` Eigenschaft mit einem Wert von `1` besitzen.
+
+```js
+assert($('#box-2').css('order') == '1');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/add-columns-with-grid-template-columns.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-columns-with-grid-template-columns.md
new file mode 100644
index 00000000000..9de8f8dd68b
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-columns-with-grid-template-columns.md
@@ -0,0 +1,72 @@
+---
+id: 5a9036d038fddaf9a66b5d32
+title: Spalten mit grid-template-columns hinzufügen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c7NzDHv'
+forumTopicId: 301117
+dashedName: add-columns-with-grid-template-columns
+---
+
+# --description--
+
+Einfach nur ein Rasterelement zu erstellen, bringt dich nicht sehr weit. Du musst auch die Struktur des Rasters festlegen. Um dem Raster einige Spalten hinzuzufügen, verwende die Eigenschaft `grid-template-columns` für einen Raster-Container, wie unten gezeigt:
+
+```css
+.container {
+ display: grid;
+ grid-template-columns: 50px 50px;
+}
+```
+
+So erhält dein Raster zwei Spalten, die jeweils 50px breit sind. Die Anzahl der Parameter, die der Eigenschaft `grid-template-columns` übergeben werden, gibt die Anzahl der Spalten im Raster an und der Wert der einzelnen Parameter gibt die Breite jeder Spalte an.
+
+# --instructions--
+
+Gib dem Raster-Container drei Spalten, die jeweils `100px` breit sind.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-template-columns` mit drei Einheiten von `100px` besitzen.
+
+```js
+assert(new __helpers.CSSHelp(document).getStyle('.container')?.gridTemplateColumns === '100px 100px 100px');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/add-gaps-faster-with-grid-gap.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-gaps-faster-with-grid-gap.md
new file mode 100644
index 00000000000..8ea5c0dbd0b
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-gaps-faster-with-grid-gap.md
@@ -0,0 +1,69 @@
+---
+id: 5a9036ee38fddaf9a66b5d37
+title: Füge Abstände mit grid-gap schneller hinzu
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/ca2qVtv'
+forumTopicId: 301118
+dashedName: add-gaps-faster-with-grid-gap
+---
+
+# --description--
+
+`grid-gap` ist eine Kurzform für `grid-row-gap` und `grid-column-gap` aus den beiden vorherigen Aufgaben, die einfacher zu verwenden ist. Wenn `grid-gap` einen Wert hat, wird ein Abstand zwischen allen Zeilen und Spalten erzeugt. Wenn es jedoch zwei Werte gibt, wird der erste Wert verwendet, um den Abstand zwischen den Zeilen festzulegen, und der zweite Wert für die Spalten.
+
+# --instructions--
+
+Verwende `grid-gap`, um einen `10px` Abstand zwischen den Zeilen und einen `20px` Abstand zwischen den Spalten einzufügen.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-gap` besitzen, die einen `10px` Abstand zwischen den Zeilen und einen `20px` Abstand zwischen den Spalten einfügt.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-gap\s*?:\s*?10px\s+?20px\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/add-rows-with-grid-template-rows.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-rows-with-grid-template-rows.md
new file mode 100644
index 00000000000..db2e7d9ed34
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/add-rows-with-grid-template-rows.md
@@ -0,0 +1,68 @@
+---
+id: 5a9036e138fddaf9a66b5d33
+title: Zeilen mit grid-template-rows hinzufügen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cbp9Pua'
+forumTopicId: 301119
+dashedName: add-rows-with-grid-template-rows
+---
+
+# --description--
+
+Das Raster, das du in der letzten Aufgabe erstellt hast, legt die Anzahl der Zeilen automatisch fest. Um die Zeilen manuell anzupassen, verwendest du die Eigenschaft `grid-template-rows` auf die gleiche Weise, wie du `grid-template-columns` in der vorherigen Aufgabe verwendet hast.
+
+# --instructions--
+
+Füge dem Raster zwei Zeilen hinzu, die jeweils `50px` hoch sind.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-template-rows` mit zwei Einheiten von `50px` besitzen.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-rows\s*?:\s*?50px\s*?50px\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-horizontally-using-justify-items.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-horizontally-using-justify-items.md
new file mode 100644
index 00000000000..ec4db631640
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-horizontally-using-justify-items.md
@@ -0,0 +1,71 @@
+---
+id: 5a90376038fddaf9a66b5d3c
+title: Alle Elemente horizontal ausrichten mit justify-items
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cJbpECn'
+forumTopicId: 301120
+dashedName: align-all-items-horizontally-using-justify-items
+---
+
+# --description--
+
+Manchmal möchtest du, dass alle Elemente in deinem CSS-Raster die gleiche Ausrichtung besitzen. Du kannst die zuvor gelernten Eigenschaften verwenden und sie einzeln ausrichten oder du kannst sie alle auf einmal horizontal ausrichten, indem du `justify-items` auf deinem Gittercontainer verwendest. Diese Eigenschaft kann die gleichen Werte annehmen, die du in den beiden vorherigen Aufgaben kennengelernt hast. Der Unterschied ist, dass sie **alle** Elemente in unserem Raster in die gewünschte Ausrichtung verschiebt.
+
+# --instructions--
+
+Verwende diese Eigenschaft, um alle unsere Elemente horizontal zu zentrieren.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `justify-items` besitzen, die den Wert `center` hat.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*justify-items\s*?:\s*?center\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-vertically-using-align-items.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-vertically-using-align-items.md
new file mode 100644
index 00000000000..b3e22789c58
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-all-items-vertically-using-align-items.md
@@ -0,0 +1,69 @@
+---
+id: 5a94fdf869fb03452672e45b
+title: Alle Elemente horizontal ausrichten mit align-items
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/ckzPeUv'
+forumTopicId: 301121
+dashedName: align-all-items-vertically-using-align-items
+---
+
+# --description--
+
+Wenn du die Eigenschaft `align-items` für einen Grid-Container verwendest, wird die vertikale Ausrichtung für alle Elemente in unserem Raster festgelegt.
+
+# --instructions--
+
+Verwende sie jetzt, um alle Gegenstände an das Ende jeder Zelle zu verschieben.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `align-items` besitzen, die den Wert `end` hat.
+
+```js
+assert(
+ code.match(/.container\s*?{[\s\S]*align-items\s*?:\s*?end\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-horizontally-using-justify-self.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-horizontally-using-justify-self.md
new file mode 100644
index 00000000000..12e565656ee
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-horizontally-using-justify-self.md
@@ -0,0 +1,79 @@
+---
+id: 5a90374338fddaf9a66b5d3a
+title: Ein Element mit justify-self horizontal ausrichten
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cJbpKHq'
+forumTopicId: 301122
+dashedName: align-an-item-horizontally-using-justify-self
+---
+
+# --description--
+
+Im CSS-Raster befindet sich der Inhalt jedes Elements in einer Box, die als
Zelle (cell) bezeichnet wird. Du kannst die Position des Inhalts innerhalb der Zelle horizontal ausrichten, indem du die Eigenschaft `justify-self` für ein Rasterelement verwendest. Standardmäßig hat diese Eigenschaft den Wert `stretch`, so dass der Inhalt die gesamte Breite der Zelle ausfüllt. Diese CSS-Raster-Eigenschaft kann auch andere Werte annehmen:
+
+`start`: Richtet den Inhalt am linken Rand der Zelle aus,
+
+`center`: Richtet den Inhalt in der Mitte der Zelle aus,
+
+`end`: Richtet den Inhalt am rechten Rand der Zelle aus.
+
+# --instructions--
+
+Verwende die Eigenschaft `justify-self`, um das Element mit der Klasse `item2` zu zentrieren.
+
+# --hints--
+
+Die Klasse `item2` sollte eine Eigenschaft `justify-self` besitzen, die den Wert `center` enthält.
+
+```js
+assert(
+ code.match(/.item2\s*?{[\s\S]*justify-self\s*?:\s*?center\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md
new file mode 100644
index 00000000000..30dcc67f4a9
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md
@@ -0,0 +1,71 @@
+---
+id: 5a90375238fddaf9a66b5d3b
+title: Richte ein Element mit align-self vertikal aus
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cmzd4fz'
+forumTopicId: 301123
+dashedName: align-an-item-vertically-using-align-self
+---
+
+# --description--
+
+Genauso wie man ein Element horizontal ausrichten kann, gibt es einen Weg, um ein Element vertikal auszurichten. Dafür benutzt man die `align-self` Eigenschaft auf einem Element. Diese Eigenschaft akzeptiert dieselben Werte wie `justify-self` aus der letzten Aufgabe.
+
+# --instructions--
+
+Richtige das Element mit der Klasse `item3` vertikal am Ende (`end`) aus.
+
+# --hints--
+
+Die `item3` Klasse sollte eine `align-self` Eigenschaft mit einem Wert von `end` haben.
+
+```js
+assert(code.match(/.item3\s*?{[\s\S]*align-self\s*?:\s*?end\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md
new file mode 100644
index 00000000000..09d2c6e238e
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md
@@ -0,0 +1,76 @@
+---
+id: 5a9036ee38fddaf9a66b5d35
+title: Erstelle einen Spaltenabstand mit grid-column-gap
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cVZ8vfD'
+forumTopicId: 301124
+dashedName: create-a-column-gap-using-grid-column-gap
+---
+
+# --description--
+
+In den Rastern, die du bisher erstellt hast, sind die Spalten alle eng aneinander gerückt. Manchmal möchtest du einen Abstand zwischen den Spalten haben. Um einen Abstand zwischen den Spalten einzufügen, verwende die Eigenschaft `grid-column-gap` wie folgt:
+
+```css
+grid-column-gap: 10px;
+```
+
+Dies schafft 10px Leerraum zwischen allen unseren Spalten.
+
+# --instructions--
+
+Gib den Spalten des Rasters einen Abstand von `20px`.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-column-gap` besitzen, die den Wert `20px` hat.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-column-gap\s*?:\s*?20px\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md
new file mode 100644
index 00000000000..61c98794080
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md
@@ -0,0 +1,68 @@
+---
+id: 5a9036ee38fddaf9a66b5d36
+title: Erstelle einen Zeilenabstands mit grid-row-gap
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cPbJ2Cv'
+forumTopicId: 301125
+dashedName: create-a-row-gap-using-grid-row-gap
+---
+
+# --description--
+
+Du kannst einen Abstand zwischen den Zeilen eines Rasters mit `grid-row-gap` auf die gleiche Weise einfügen, wie du in der vorherigen Aufgabe einen Abstand zwischen den Spalten eingefügt hast.
+
+# --instructions--
+
+Erstelle einen Abstand für die Zeilen, die `5px` hoch ist.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-row-gap` besitzen, die den Wert `5px` enthält.
+
+```js
+assert(
+ code.match(/.container\s*?{[\s\S]*grid-row-gap\s*?:\s*?5px\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md
new file mode 100644
index 00000000000..ac287e427ee
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md
@@ -0,0 +1,140 @@
+---
+id: 5a94fe5469fb03452672e461
+title: Flexible Layouts mit Auto-Fill erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cmzdycW'
+forumTopicId: 301126
+dashedName: create-flexible-layouts-using-auto-fill
+---
+
+# --description--
+
+Die repeat-Funktion verfügt über eine Option namens
auto-fill . Auf diese Weise kannst du je nach Größe des Containers automatisch so viele Zeilen oder Spalten deiner gewünschten Größe einfügen wie möglich. Du kannst flexible Layouts erstellen, wenn du `auto-fill` mit `minmax` kombinierst, so wie hier:
+
+```css
+repeat(auto-fill, minmax(60px, 1fr));
+```
+
+Wenn der Container seine Größe ändert, fügt dieses Setup immer wieder 60px-Spalten ein und streckt sie, bis es eine weitere einfügen kann. **Hinweis:** Wenn dein Container nicht alle Elemente in einer Reihe unterbringen kann, verschiebt er sie nach unten in eine neue Reihe.
+
+# --instructions--
+
+Im ersten Raster (Grid) verwendest du `auto-fill` mit `repeat`, um das Raster mit Spalten zu füllen, die eine Mindestbreite von `60px` und eine Maximalbreite von `1fr` haben. Ändere dann die Größe der Vorschau, um das automatische Ausfüllen in Aktion zu sehen.
+
+# --hints--
+
+Die Klasse `container` sollte eine `grid-template-columns`-Eigenschaft mit `repeat` und `auto-fill` besitzen, die das Raster mit Spalten füllt, die eine minimale Breite von `60px` und maximal `1fr` haben.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?auto-fill\s*?,\s*?minmax\s*?\(\s*?60px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md
new file mode 100644
index 00000000000..6537353d5a5
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md
@@ -0,0 +1,91 @@
+---
+id: 5a94fe6269fb03452672e462
+title: Flexible Layouts mit auto-fit erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c3dPph8'
+forumTopicId: 301127
+dashedName: create-flexible-layouts-using-auto-fit
+---
+
+# --description--
+
+`auto-fit` funktioniert fast identisch zu `auto-fill`. Der einzige Unterschied besteht darin, dass `auto-fill`, sobald die Größe des Containers die Größe aller Elemente zusammen übersteigt, weitere leere Zeilen oder Spalten einfügt und die Elemente zur Seite schiebt, während `auto-fit` diese leeren Zeilen oder Spalten entfernt und die Elemente streckt, damit sie in die Größe des Containers passen.
+
+**Hinweis:** Wenn dein Container nicht alle Elemente in einer Zeile unterbringen kann, verschiebt er sie in eine neue Zeile.
+
+# --instructions--
+
+Verwende im zweitem Raster (Grid) `auto-fit` mit `repeat`, um das Raster mit Spalten zu füllen, die eine minimale Breite von `60px` und eine maximale von `1fr` haben. Verändere dann die Größe der Vorschau, um den Unterschied zu sehen.
+
+# --hints--
+
+Die Klasse `container2` sollte eine `grid-template-columns`-Eigenschaft mit `repeat` und `auto-fit` besitzen, die das Raster mit Spalten füllt, die eine minimale Breite von `60px` und eine maximale von `1fr` aufweisen.
+
+```js
+assert(
+ code.match(
+ /.container2\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?auto-fit\s*?,\s*?minmax\s*?\(\s*?60px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-grids-within-grids.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-grids-within-grids.md
new file mode 100644
index 00000000000..48083fbb6e8
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-grids-within-grids.md
@@ -0,0 +1,106 @@
+---
+id: 5a94fe8569fb03452672e464
+title: Erstelle Raster innerhalb von Rastern
+challengeType: 0
+forumTopicId: 301128
+dashedName: create-grids-within-grids
+---
+
+# --description--
+
+Das Umwandeln eines Elements in ein Raster (Grid) wirkt sich nur auf das Verhalten seiner direkten Nachfahren aus. Wenn du also einen direkten Nachfahren (descendant) in ein Raster verwandelst, hast du ein Raster innerhalb eines Rasters.
+
+Indem du zum Beispiel die Eigenschaften `display` und `grid-template-columns` des Elements mit der Klasse `item3` setzt, erzeugst du ein Raster innerhalb deines Rasters.
+
+# --instructions--
+
+Wandele das Element mit der Klasse `item3` mithilfe von `display` und `grid-template-columns` in ein Raster mit zwei Spalten sowie einer Breite von `auto` und `1fr` um.
+
+# --hints--
+
+Die Klasse `item3` sollte eine `grid-template-columns`-Eigenschaft mit den Werten `auto` und `1fr` besitzen.
+
+```js
+assert(
+ code.match(
+ /.item3\s*?{[\s\S]*grid-template-columns\s*?:\s*?auto\s*?1fr\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+Die Klasse `item3` sollte eine Eigenschaft `display` mit dem Wert `grid` enthalten.
+
+```js
+assert(code.match(/.item3\s*?{[\s\S]*display\s*?:\s*?grid\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
header
+
advert
+
+
paragraph1
+
paragraph2
+
+
footer
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/create-your-first-css-grid.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-your-first-css-grid.md
new file mode 100644
index 00000000000..b8989886922
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/create-your-first-css-grid.md
@@ -0,0 +1,64 @@
+---
+id: 5a858944d96184f06fd60d61
+title: Erstelle dein erstes CSS-Raster (Grid)
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cqwREC4'
+forumTopicId: 301129
+dashedName: create-your-first-css-grid
+---
+
+# --description--
+
+Verwandle jedes HTML-Element in einen Grid-Container, indem du seine `display`-Eigenschaft auf `grid` setzt. Dies gibt dir die Möglichkeit, alle anderen Eigenschaften zu nutzen, die mit CSS Grid verbunden sind.
+
+**Hinweis:** Im CSS-Raster wird das übergeordnete Element als
Container bezeichnet und seine Kinder heißen
Elemente .
+
+# --instructions--
+
+Ändere die Anzeige des Div mit der Klasse `container` auf `grid`.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `display` mit dem Wert `grid` besitzen.
+
+```js
+assert(code.match(/.container\s*?{[\s\S]*display\s*?:\s*?grid\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md
new file mode 100644
index 00000000000..4735c062353
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md
@@ -0,0 +1,113 @@
+---
+id: 5a94fe0569fb03452672e45c
+title: Unterteile das Raster in eine Bereichsvorlage
+challengeType: 0
+forumTopicId: 301130
+dashedName: divide-the-grid-into-an-area-template
+---
+
+# --description--
+
+Du kannst Zellen deines Rasters zu einem
Bereich (Area) zusammenfassen und dem Bereich einen eigenen Namen geben. Dazu wendest du `grid-template-areas` auf den Container an, wie hier:
+
+```css
+grid-template-areas:
+ "header header header"
+ "advert content content"
+ "advert footer footer";
+```
+
+Der obige Code gruppiert die Zellen des Rasters in vier Bereiche: `header`, `advert`, `content` und `footer`. Jedes Wort steht für eine Zelle und jedes Paar Anführungszeichen für eine Zeile.
+
+# --instructions--
+
+Ändere die Vorlage (Template) so, dass sich der `footer`-Bereich über die gesamte untere Zeile erstreckt. Das Definieren der Bereiche hat jetzt noch keinen sichtbaren Effekt. Später wirst du ein Element erstellen, das einen Bereich verwendet, um zu sehen, wie es funktioniert.
+
+# --hints--
+
+Die `container`-Klasse sollte eine `grid-template-areas`-Eigenschaft besitzen, ähnlich wie im Beispiel, aber mit dem `footer`-Bereich, der sich über die gesamte untere Zeile erstreckt.
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(
+ /.container\s*?{[\s\S]*grid-template-areas\s*?:\s*?"\s*?header\s*?header\s*?header\s*?"\s*?"\s*?advert\s*?content\s*?content\s*?"\s*?"\s*?footer\s*?footer\s*?footer\s*?"\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md
new file mode 100644
index 00000000000..9d8e82027db
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md
@@ -0,0 +1,77 @@
+---
+id: 5a94fe4469fb03452672e460
+title: Elementgröße mit der Funktion minmax begrenzen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cD97RTv'
+forumTopicId: 301131
+dashedName: limit-item-size-using-the-minmax-function
+---
+
+# --description--
+
+Es gibt eine weitere integrierte Funktion zur Verwendung mit `grid-template-columns` und `grid-template-rows`, die `minmax` heißt. Sie wird verwendet, um die Größe der Elemente zu begrenzen, wenn sich die Größe des Raster(Grid)-Containers ändert. Dazu musst du den gewünschten Größenbereich für dein Element angeben. Hier ist ein Beispiel:
+
+```css
+grid-template-columns: 100px minmax(50px, 200px);
+```
+
+Im obigen Code ist `grid-template-columns` so gesetzt, dass zwei Spalten erzeugt werden; die erste ist 100px breit, die zweite hat die minimale Breite von 50px und die maximale Breite von 200px.
+
+# --instructions--
+
+Ersetze mit der Funktion `minmax` das `1fr` in der Funktion `repeat` durch eine Spaltengröße, die die minimale Breite von `90px` und die maximale Breite von `1fr` hat, und verändere die Größe des Vorschaufensters, um den Effekt zu sehen.
+
+# --hints--
+
+Die Klasse `container` sollte eine Eigenschaft `grid-template-columns` besitzen, die auf die Wiederholung von 3 Spalten mit der minimalen Breite von `90px` und der maximalen Breite von `1fr` eingestellt ist.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?3\s*?,\s*?minmax\s*?\(\s*?90px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
new file mode 100644
index 00000000000..f2f0f7b9c22
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
@@ -0,0 +1,86 @@
+---
+id: 5a94fe1369fb03452672e45d
+title: Platziere Elemente in Rasterbereichen mit der Eigenschaft grid-area
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cRrqmtV'
+forumTopicId: 301132
+dashedName: place-items-in-grid-areas-using-the-grid-area-property
+---
+
+# --description--
+
+Nachdem du eine Bereichsvorlage für deinen Grid-Container erstellt hast, wie in der vorherigen Aufgabe gezeigt, kannst du ein Element in deinem benutzerdefinierten Bereich platzieren, indem du auf den Namen verweist, den du ihm gegeben hast. Dazu verwendest du die Eigenschaft `grid-area` für ein Element wie dieses:
+
+```css
+.item1 {
+ grid-area: header;
+}
+```
+
+Dadurch weiß das Raster, dass die Klasse `item1` in den Bereich `header` gehört. In diesem Fall wird das Element die gesamte obere Zeile verwenden, da die gesamte Zeile als `header`-Bereich benannt ist.
+
+# --instructions--
+
+Platziere ein Element mit der Klasse `item5` im `footer` mit der Eigenschaft `grid-area`.
+
+# --hints--
+
+Die Klasse `item5` sollte eine Eigenschaft `grid-area` besitzen, die den Wert `footer` hat.
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(/.item5\s*?{[\s\S]*grid-area\s*?:\s*?footer\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md
new file mode 100644
index 00000000000..6f03ab3bb41
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md
@@ -0,0 +1,93 @@
+---
+id: 5a94fe3669fb03452672e45f
+title: Wiederholungen mit der repeat-Funktion reduzieren
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cQvqyHR'
+forumTopicId: 301133
+dashedName: reduce-repetition-using-the-repeat-function
+---
+
+# --description--
+
+Wenn du `grid-template-columns` und `grid-template-rows` verwendet hast, um die Struktur eines Rasters zu definieren, hast du einen Wert für jede Zeile oder Spalte eingegeben, die du erstellt hast.
+
+Nehmen wir an, du willst ein Raster mit 100 Zeilen derselben Höhe. Es ist nicht sehr praktisch, 100 Werte einzeln einzufügen. Glücklicherweise gibt es einen besseren Weg - indem du die Funktion `repeat` verwendest, um die Anzahl der Wiederholungen deiner Spalte oder Zeile anzugeben, gefolgt von einem Komma und dem Wert, den du wiederholen willst.
+
+Hier ist ein Beispiel, das ein 100-zeiliges Raster erzeugt, bei dem jede Zeile 50px hoch ist.
+
+```css
+grid-template-rows: repeat(100, 50px);
+```
+
+Du kannst auch mehrere Werte mit der Wiederholungsfunktion wiederholen und die Funktion zwischen anderen Werten einfügen, wenn du eine Rasterstruktur definierst. So sieht das aus:
+
+```css
+grid-template-columns: repeat(2, 1fr 50px) 20px;
+```
+
+Das heißt übersetzt so viel wie:
+
+```css
+grid-template-columns: 1fr 50px 1fr 50px 20px;
+```
+
+**Hinweis:** Das `1fr 50px` wird zweimal wiederholt, gefolgt von 20px.
+
+# --instructions--
+
+Verwende `repeat`, um Wiederholungen aus der Eigenschaft `grid-template-columns` zu entfernen.
+
+# --hints--
+
+Die Klasse `container` sollte eine `grid-template-columns`-Eigenschaft besitzen, die auf die Wiederholung von 3 Spalten mit der Breite von `1fr` eingestellt ist.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?3\s*?,\s*?1fr\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
new file mode 100644
index 00000000000..79cfacab756
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
@@ -0,0 +1,83 @@
+---
+id: 5a9036ee38fddaf9a66b5d34
+title: Verwende CSS-Rastereinheiten, um die Größe von Spalten und Zeilen zu ändern
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cvE8phd'
+forumTopicId: 301134
+dashedName: use-css-grid-units-to-change-the-size-of-columns-and-rows
+---
+
+# --description--
+
+Du kannst absolute und relative Einheiten wie `px` und `em` in CSS Grid verwenden, um die Größe von Zeilen und Spalten zu definieren. Du kannst auch diese verwenden:
+
+`fr`: setzt die Spalte oder Zeile auf einen Bruchteil des verfügbaren Platzes,
+
+`auto`: setzt die Spalte oder Zeile automatisch auf die Breite oder Höhe ihres Inhalts,
+
+`%`: Passt die Spalte oder Zeile an die prozentuale Breite ihres Containers an.
+
+Hier ist der Code, der die Ausgabe in der Vorschau generiert:
+
+```css
+grid-template-columns: auto 50px 10% 2fr 1fr;
+```
+
+Dieses Snippet erstellt fünf Spalten. Die erste Spalte ist so breit wie ihr Inhalt, die zweite Spalte ist 50px, die dritte Spalte ist 10% ihres Containers und für die letzten beiden Spalten wird der verbleibende Platz in drei Abschnitte aufgeteilt, zwei für die vierte Spalte und einer für die fünfte.
+
+# --instructions--
+
+Erstelle ein Raster mit drei Spalten, die wie folgt breit sind: 1fr, 100px, und 2fr.
+
+# --hints--
+
+Deine `container` Klasse sollte eine `grid-template-columns` Eigenschaft haben, die drei Spalten mit den folgenden Breiten besitzt: `1fr`, `100px`, und `2fr`.
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?1fr\s*?100px\s*?2fr\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md
new file mode 100644
index 00000000000..b8a8ce881d0
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md
@@ -0,0 +1,86 @@
+---
+id: 5a94fe2669fb03452672e45e
+title: Verwende grid-area ohne eine Bereichsvorlage zu erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c6N7VhK'
+forumTopicId: 301135
+dashedName: use-grid-area-without-creating-an-areas-template
+---
+
+# --description--
+
+Die Eigenschaft `grid-area`, die du in der letzten Aufgabe kennengelernt hast, kann auf eine andere Weise verwendet werden. Wenn dein Raster keine Bereichsvorlage hat, kannst du einen Bereich für ein Element erstellen, das wie folgt platziert werden soll:
+
+```css
+item1 { grid-area: 1/1/2/4; }
+```
+
+Hier werden die Zeilennummern verwendet, die du bereits kennengelernt hast, um zu bestimmen, wo der Bereich für dieses Element liegen soll. Die Zahlen im obigen Beispiel stellen diese Werte dar:
+
+```css
+grid-area: horizontal line to start at / vertical line to start at / horizontal line to end at / vertical line to end at;
+```
+
+Das Element im Beispiel wird also die Zeilen zwischen den Zeilen 1 und 2 und die Spalten zwischen den Zeilen 1 und 4 verbrauchen.
+
+# --instructions--
+
+Platziere das Element mit der Klasse `item5` mithilfe der Eigenschaft `grid-area` zwischen der dritten und vierten horizontalen Linie und zwischen der ersten und vierten vertikalen Linie.
+
+# --hints--
+
+Die Klasse `item5` sollte eine Eigenschaft von `grid-area` haben, um die gesamte Fläche zwischen der dritten und vierten horizontalen Linie zu füllen und erste und vierte vertikale Linien.
+
+```js
+assert(
+ code.match(
+ /.item5\s*?{[\s\S]*grid-area\s*?:\s*?3\s*?\/\s*?1\s*?\/\s*?4\s*?\/\s*?4\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md
new file mode 100644
index 00000000000..f364b631823
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md
@@ -0,0 +1,139 @@
+---
+id: 5a90372638fddaf9a66b5d38
+title: Verwende grid-column um die Abstände zu kontrollieren
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cnzkDSr'
+forumTopicId: 301136
+dashedName: use-grid-column-to-control-spacing
+---
+
+# --description--
+
+Bis zu diesem Punkt wurden alle Eigenschaften für Grid-Container besprochen. Die Eigenschaft `grid-column` ist die erste Eigenschaft, die für die Rasterelemente selbst verwendet wird.
+
+Die hypothetischen horizontalen und vertikalen Linien, die das Raster bilden, werden als
Linien (Lines) bezeichnet. Diese Zeilen sind nummeriert, beginnend mit 1 in der oberen linken Ecke des Rasters und bewegen sich nach rechts für Spalten und nach unten für Zeilen, wobei sie aufwärts zählen.
+
+So sehen die Linien für ein 3x3-Raster aus:
+
+
Spaltenlinien
1
2
3
4
Zeilenlinien
1
2
3
4
+
+Um die Anzahl der Spalten zu bestimmen, die ein Element verbraucht, kannst du die Eigenschaft `grid-column` in Verbindung mit den Zeilennummern verwenden, bei denen das Element beginnen und enden soll.
+
+Hier ist ein Beispiel:
+
+```css
+grid-column: 1 / 3;
+```
+
+Dadurch beginnt das Element an der ersten vertikalen Linie des Rasters auf der linken Seite und erstreckt sich bis zur dritten Linie des Rasters, wodurch zwei Spalten belegt werden.
+
+# --instructions--
+
+Lass das Element mit der Klasse `item5` die letzten beiden Spalten des Rasters einnehmen.
+
+# --hints--
+
+Die Klasse `item5` sollte eine Eigenschaft `grid-column` besitzen.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace($('style').text())
+ .match(/\.item5{.*grid-column:.*}/g)
+);
+```
+
+Die Klasse `item5` sollte eine Eigenschaft `grid-column` besitzen, die dazu führt, dass sie die letzten beiden Spalten des Rasters verwendet werden.
+
+```js
+const colStart = getComputedStyle($('.item5')[0]).gridColumnStart;
+const colEnd = getComputedStyle($('.item5')[0]).gridColumnEnd;
+const result = colStart.toString() + colEnd.toString();
+const correctResults = [
+ '24',
+ '2-1',
+ '2span 2',
+ '2span2',
+ 'span 2-1',
+ '-12',
+ 'span 2span 2',
+ 'span 2auto',
+ 'autospan 2'
+];
+assert(correctResults.includes(result));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md
new file mode 100644
index 00000000000..5aa4e53b771
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md
@@ -0,0 +1,122 @@
+---
+id: 5a90373638fddaf9a66b5d39
+title: Verwende grid-row um Abstände zu kontrollieren
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c9WBLU4'
+forumTopicId: 301137
+dashedName: use-grid-row-to-control-spacing
+---
+
+# --description--
+
+Natürlich kannst du auch mehrere Zeilen verwenden, genauso wie du es mit Spalten machen kannst. Du legst die horizontalen Linien fest, an denen ein Element beginnen und enden soll, indem du die Eigenschaft `grid-row` für ein Rasterelement verwendest.
+
+# --instructions--
+
+Lass das Element mit der Klasse `item5` die letzten beiden Zeilen verwenden.
+
+# --hints--
+
+Die Klasse `item5` sollte eine Eigenschaft `grid-row` besitzen.
+
+```js
+assert(
+ __helpers.removeWhiteSpace($('style').text()).match(/\.item5{.*grid-row:.*}/g)
+);
+```
+
+Die Klasse `item5` sollte eine Eigenschaft `grid-row` besitzen, die dazu führt, dass sie die letzten beiden Zeilen des Grids verwendet.
+
+```js
+const rowStart = getComputedStyle($('.item5')[0]).gridRowStart;
+const rowEnd = getComputedStyle($('.item5')[0]).gridRowEnd;
+const result = rowStart.toString() + rowEnd.toString();
+const correctResults = [
+ '24',
+ '2-1',
+ '2span 2',
+ '2span2',
+ 'span 2-1',
+ '-12',
+ 'span 2span 2',
+ 'span 2auto',
+ 'autospan 2'
+];
+assert(correctResults.includes(result));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md
new file mode 100644
index 00000000000..ba559ded909
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md
@@ -0,0 +1,174 @@
+---
+id: 5a94fe7769fb03452672e463
+title: Verwende Media Queries, um responsive Layouts zu erstellen
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cMbqeHk'
+forumTopicId: 301138
+dashedName: use-media-queries-to-create-responsive-layouts
+---
+
+# --description--
+
+Mit CSS-Raster kannst du deine Website auf einfache Weise responsiver machen, indem du Media-Queries verwendest, um Rasterbereiche neu anzuordnen, die Abmessungen eines Rasters zu ändern und die Platzierung von Elementen neu zu ordnen.
+
+Wenn die Breite des Ansichtsfensters 300px oder mehr beträgt, ändert sich die Anzahl der Spalten in der Vorschau von 1 auf 2. Die Werbefläche nimmt dann die linke Spalte komplett ein.
+
+# --instructions--
+
+Wenn die Breite des Ansichtsfensters (Viewport) `400px` oder mehr beträgt, musst du dafür sorgen, dass der Header-Bereich die obere Zeile vollständig einnimmt und der Footer-Bereich die untere Zeile vollständig einnimmt.
+
+# --hints--
+
+Wenn das Ansichtsfenster `400px` oder mehr beträgt, sollte die Klasse `container` eine Eigenschaft `grid-template-areas` besitzen, in der der Header- und Footer-Bereich die obere bzw. untere Zeile und die Werbung und der Inhalt die linke und rechte Spalte der mittleren Zeile einnehmen.
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(
+ /@media\s*?\(\s*?min-width\s*?:\s*?400px\s*?\)[\s\S]*.container\s*?{[\s\S]*grid-template-areas\s*?:\s*?"\s*?header\s*?header\s*?"\s*?"\s*?advert\s*?content\s*?"\s*?"\s*?footer\s*?footer\s*?"\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
header
+
advert
+
content
+
footer
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
header
+
advert
+
content
+
footer
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/create-a-media-query.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/create-a-media-query.md
new file mode 100644
index 00000000000..4b690a73675
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/create-a-media-query.md
@@ -0,0 +1,91 @@
+---
+id: 587d78b0367417b2b2512b08
+title: Erstellen einer Medienabfrage
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pzrPu4/cqwKrtm'
+forumTopicId: 301139
+dashedName: create-a-media-query
+---
+
+# --description--
+
+Medienabfragen (Media Queries) sind eine neue Technik, die in CSS3 eingeführt wurde und mit der die Darstellung von Inhalten je nach Größe des Ansichtsfensters (Viewport) geändert werden kann. Der Viewport ist der für den Nutzer sichtbare Bereich einer Webseite und unterscheidet sich je nach dem Gerät, mit dem die Seite aufgerufen wird.
+
+Medienabfragen bestehen aus einem Medientyp, und wenn dieser Medientyp mit dem Gerätetyp übereinstimmt, auf dem das Dokument angezeigt wird, werden die Stile angewendet. Du kannst so viele Selektoren und Stile in deiner Medienabfrage verwenden, wie du willst.
+
+Hier ist ein Beispiel für eine Medienabfrage, die den Inhalt zurückgibt, wenn die Breite des Geräts kleiner oder gleich `100px` ist:
+
+```css
+@media (max-width: 100px) { /* CSS Rules */ }
+```
+
+und die folgende Medienabfrage gibt den Inhalt zurück, wenn die Höhe des Geräts größer oder gleich `350px` ist:
+
+```css
+@media (min-height: 350px) { /* CSS Rules */ }
+```
+
+Denk daran, dass das CSS in der Medienabfrage nur angewendet wird, wenn der Medientyp mit dem des verwendeten Geräts übereinstimmt.
+
+# --instructions--
+
+Füge eine Medienabfrage hinzu, damit der `p`-Tag eine Schriftgröße (`font-size`) von `10px` hat, wenn die Höhe des Geräts kleiner oder gleich `800px` ist.
+
+# --hints--
+
+Du solltest eine `@media`-Abfrage für Geräte mit einer Höhe (`height`) kleiner oder gleich `800px` deklarieren.
+
+```js
+const media = new __helpers.CSSHelp(document).getCSSRules('media');
+assert(media.some(x => x.media?.mediaText?.includes('(max-height: 800px)')));
+```
+
+Dein `p`-Element sollte eine Schriftgröße (`font-size`) von `10px` haben, wenn die Höhe ( `height`) des Geräts kleiner als oder gleich `800px` ist.
+
+```js
+const rules = new __helpers.CSSHelp(document).getRuleListsWithinMedia('(max-height: 800px)');
+assert(rules?.find(x => x.selectorText === 'p')?.style?.fontSize === "10px");
+```
+
+Dein `p`-Element sollte eine anfängliche Schriftgröße (`font-size`) von `20px` haben, wenn die Höhe (`height`) des Geräts mehr als `800px` beträgt.
+
+```js
+const ifPFirst = new __helpers.CSSHelp(document).getCSSRules()?.find(x => x?.selectorText === 'p' || x?.media);
+assert(ifPFirst?.style?.fontSize === '20px');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
+
+# --solutions--
+
+```html
+
+
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md
new file mode 100644
index 00000000000..199dcec0c3e
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md
@@ -0,0 +1,76 @@
+---
+id: 587d78b1367417b2b2512b09
+title: Ein Bild responsiv gestalten
+challengeType: 0
+forumTopicId: 301140
+dashedName: make-an-image-responsive
+---
+
+# --description--
+
+Bilder mit CSS responsive zu machen, ist eigentlich ganz einfach. Du musst nur diese Eigenschaften zu einem Bild hinzufügen:
+
+```css
+img {
+ max-width: 100%;
+ height: auto;
+}
+```
+
+Die `max-width` von `100%` sorgt dafür, dass das Bild nie breiter ist als der Container, in dem es sich befindet, und die `height` von `auto` sorgt dafür, dass das Bild sein ursprüngliches Seitenverhältnis behält.
+
+# --instructions--
+
+Füge die Stilregeln zur Klasse `responsive-img` hinzu, um sie responsive zu gestalten. Es sollte nie größer als sein Container sein (in diesem Fall ist es das Vorschaufenster) und es sollte sein ursprüngliches Seitenverhältnis beibehalten. Nachdem du deinen Code hinzugefügt hast, kannst du die Größe der Vorschau ändern, um zu sehen, wie sich deine Bilder verhalten.
+
+# --hints--
+
+Deine Klasse `responsive-img` sollte eine `max-width` besitzen, die auf `100%` gesetzt ist.
+
+```js
+assert(getComputedStyle($('.responsive-img')[0]).maxWidth === '100%');
+```
+
+Deine Klasse `responsive-img` sollte eine `height` besitzen, die auf `auto` eingestellt ist.
+
+```js
+assert(code.match(/height:\s*?auto;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-typography-responsive.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-typography-responsive.md
new file mode 100644
index 00000000000..cb01234594c
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/make-typography-responsive.md
@@ -0,0 +1,77 @@
+---
+id: 587d78b1367417b2b2512b0c
+title: Typografie responsiv gestalten
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pzrPu4/crzN7T8'
+forumTopicId: 301141
+dashedName: make-typography-responsive
+---
+
+# --description--
+
+Anstatt `em` oder `px` für die Textgröße zu verwenden, kannst du Viewport-Einheiten für responsive Typografie nutzen. Viewport-Einheiten sind wie Prozentangaben relative Einheiten, aber sie basieren auf unterschiedlichen Elementen. Viewport-Einheiten sind relativ zu den Viewport-Dimensionen (Breite oder Höhe) eines Geräts, und Prozentsätze sind relativ zur Größe des übergeordneten Container-Elements.
+
+Die vier verschiedenen Viewport-Einheiten sind:
+
+
vw (Viewport-breite): 10vw wäre 10% der Breite des Viewports.vh (Viewport-Höhe): 3vh wäre 3% der Höhe des Viewports.vmin (Viewport minimum): 70vmin wäre 70% der kleineren Größe des Viewports (Höhe oder Breite).vmax (Viewport maximal): 100vmax wäre 100% der größeren Größe des Viewports (Höhe oder Breite).
+
+Hier ist ein Beispiel, das ein `body` Tag auf 30% der Breite des Viewports setzt.
+
+```css
+body { width: 30vw; }
+```
+
+# --instructions--
+
+Setze die `width` des `h2`-Tags auf 80% der Breite des Viewports und die `width` des Absatzes auf 75% der kleineren Dimension des Viewports.
+
+# --hints--
+
+Dein `h2`-Tag sollte eine `width` von 80vw besitzen.
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(/h2\s*?{\s*?width:\s*?80vw;\s*?}/g)
+);
+```
+
+Dein `p`-Tag sollte eine `width` von 75vmin besitzen.
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(/p\s*?{\s*?width:\s*?75vmin;\s*?}/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
Importantus Ipsum
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
+
+# --solutions--
+
+```html
+
+
+
Importantus Ipsum
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md
new file mode 100644
index 00000000000..f153940f397
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md
@@ -0,0 +1,64 @@
+---
+id: 587d78b1367417b2b2512b0a
+title: Verwende ein Retina-Bild für Displays mit höherer Auflösung
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pzrPu4/cVZ4Rfp'
+forumTopicId: 301142
+dashedName: use-a-retina-image-for-higher-resolution-displays
+---
+
+# --description--
+
+Mit der Zunahme der im Internet angeschlossenen Geräte variieren ihre Größen und Spezifikationen und die Displays, die sie verwenden, könnten extern und intern unterschiedlich sein. Die Pixeldichte ist ein Aspekt, der bei einem Gerät anders sein kann als bei anderen. Diese Dichte wird als Pixel pro Zoll (PPI) oder Dots per Inch (DPI) bezeichnet. Das bekannteste dieser Displays ist das sogenannte "Retina Display", das in den neuesten Apple MacBook Pro Notebooks und seit kurzem auch in den iMac Computern zu finden ist. Aufgrund des Unterschieds in der Pixeldichte zwischen einem "Retina"-Display und einem "Non-Retina"-Display können einige Bilder, die nicht mit Blick auf ein hochauflösendes Display erstellt wurden, "pixelig" aussehen, wenn sie auf einem hochauflösenden Display dargestellt werden.
+
+Der einfachste Weg, damit deine Bilder auf hochauflösenden Bildschirmen wie dem "Retina-Display" des MacBook Pros richtig angezeigt werden, besteht darin, die Werte für `width` und `height` auf die Hälfte der Originaldatei zu beschränken. Hier ist ein Beispiel für ein Bild, das nur die Hälfte der ursprünglichen Höhe und Breite verwendet:
+
+```html
+
+
+```
+
+# --instructions--
+
+Setze die `width` und `height` des `img`-Tags auf die Hälfte ihrer ursprünglichen Werte. In diesem Fall sind sowohl die ursprüngliche `height` als auch die ursprüngliche `width` gleich `200px`.
+
+# --hints--
+
+Dein `img`-Tag sollte eine `width` von 100 Pixeln besitzen.
+
+```js
+assert(document.querySelector('img').width === 100);
+```
+
+Dein `img`-Tag sollte eine `height` von 100 Pixeln besitzen.
+
+```js
+assert(document.querySelector('img').height === 100);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-personal-portfolio-webpage.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-personal-portfolio-webpage.md
new file mode 100644
index 00000000000..6f048812ff9
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-personal-portfolio-webpage.md
@@ -0,0 +1,281 @@
+---
+id: bd7158d8c242eddfaeb5bd13
+title: Erstelle eine persönliche Portfolio-Webseite
+challengeType: 14
+forumTopicId: 301143
+dashedName: build-a-personal-portfolio-webpage
+---
+
+# --description--
+
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie
https://personal-portfolio.freecodecamp.rocks aufweist
+
+**User Stories:**
+
+1. Dein Portfolio sollte einen Begrüßungsbereich mit einer `id` von `welcome-section` besitzen
+1. Der Begrüßungsbereich sollte ein `h1` Element besitzen, das einen Text enthält
+1. Dein Portfolio sollte einen Projektabschnitt mit einer `id` von `projects` besitzen
+1. Der Projektabschnitt sollte mindestens ein Element mit einer `class` von `project-tile` besitzen, um das Projekt zu halten
+1. Der Projektabschnitt sollte mindestens einen Link zu einem Projekt enthalten
+1. Dein Portfolio sollte eine Navigationsleiste mit einer Id der `navbar` besitzen
+1. Die Navigationsleiste sollte mindestens einen klickbaren Link beinhalten, der zu verschiedenen Sektionen auf der Seite navigiert
+1. Dein Portfolio sollte einen Link mit der Id von `profile-link` besitzen, der dein GitHub oder das freeCodeCamp Profil in einem neuen Tab öffnet
+1. Dein Portfolio sollte mindestens eine Media Query (Medienabfrage) enthalten
+1. Die Höhe des Begrüßungsabschnitts sollte der Höhe des Viewports entsprechen
+1. Die Navigationsleiste sollte immer oben am Viewport liegen
+
+Erfülle die folgenden User Stories und bestehe alle Tests, um dieses Projekt abzuschließen. Gib dem Ganzen deinen persönlichen Stil. Viel Spaß beim Programmieren!
+
+**Hinweis:** Achte darauf, `
` in deinen HTML-Code einzufügen, um dein Stylesheet zu verknüpfen und dein CSS-Code anwenden zu können
+
+# --hints--
+
+Dein Portfolio sollte einen Begrüßungsbereich mit einer `id` von `welcome-section` besitzen.
+
+```js
+const el = document.getElementById('welcome-section')
+assert(!!el);
+```
+
+Dein `#welcome-section` Element sollte ein `h1` Element beinhalten.
+
+```js
+assert.isAbove(
+ document.querySelectorAll('#welcome-section h1').length,
+ 0,
+ 'Welcome section should contain an h1 element '
+);
+```
+
+Du solltest keine leeren `h1` Elemente innerhalb des `#welcome-section` Elements haben.
+
+```js
+assert.isAbove(
+ document.querySelectorAll('#welcome-section h1')?.[0]?.innerText?.length,
+ 0,
+ 'h1 element in welcome section should contain your name or camper ' +
+ 'name '
+);
+```
+
+Du solltest einen Projektabschnitt mit einer `id` von `projects` haben.
+
+```js
+const el = document.getElementById('projects')
+assert(!!el);
+```
+
+Dein Portfolio sollte mindestens ein Element mit einer Klasse von `project-tile` haben.
+
+```js
+assert.isAbove(
+ document.querySelectorAll('#projects .project-tile').length,
+ 0
+);
+```
+
+Dein `#projects` Element sollte mindestens ein `a` Element beinhalten.
+
+```js
+assert.isAbove(document.querySelectorAll('#projects a').length, 0);
+```
+
+Dein Portfolio sollte eine Navigationsleiste mit der `id` von `navbar` besitzen.
+
+```js
+const el = document.getElementById('navbar');
+assert(!!el);
+```
+
+Dein `#navbar` Element sollte mindestens ein `a` Element, dessen `href` Attribut mit `#` beginnt, besitzen.
+
+```js
+const links = [...document.querySelectorAll('#navbar a')].filter(
+ (nav) => (nav?.getAttribute('href') || '').substr(0, 1) === '#'
+);
+
+assert.isAbove(
+ links.length,
+ 0,
+ 'Navbar should contain an anchor link '
+);
+```
+
+Dein Portfolio sollte ein `a` Element mit einer `id` von `profile-link` besitzen.
+
+```js
+const el = document.getElementById('profile-link');
+assert(!!el && el.tagName === 'A')
+```
+
+Dein `#profile-link` Element sollte ein `target` Attribut von `_blank` besitzen.
+
+```js
+const el = document.getElementById('profile-link');
+assert(!!el && el.target === '_blank')
+```
+
+Dein Portfolio sollte mindestens eine Medienabfrage (Media Query) benutzen.
+
+```js
+const htmlSourceAttr = Array.from(document.querySelectorAll('source')).map(el => el.getAttribute('media'))
+const cssCheck = new __helpers.CSSHelp(document).getCSSRules('media')
+assert(cssCheck.length > 0 || htmlSourceAttr.length > 0);
+```
+
+Dein `#navbar` Element sollte immer oben im Viewport liegen.
+
+```js
+(async () => {
+ const timeout = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+ const navbar = document.getElementById('navbar');
+ assert.approximately(
+ navbar?.getBoundingClientRect().top,
+ 0,
+ 15,
+ "Navbar's parent should be body and it should be at the top of " +
+ 'the viewport '
+ );
+
+ window.scroll(0, 500);
+
+ await timeout(1);
+
+ assert.approximately(
+ navbar?.getBoundingClientRect().top,
+ 0,
+ 15,
+ 'Navbar should be at the top of the viewport even after ' +
+ 'scrolling '
+ );
+ window.scroll(0, 0);
+})();
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+```css
+
+```
+
+## --solutions--
+
+```html
+
+
+
+
+
+
Personal Portfolio
+
+
+
+
+
+ Projects |
+ Contact me
+
+
+
+ It's me!
+ Naomi Carrigan
+ Welcome to my portfolio page!
+ https://product-landing-page.freecodecamp.rocks aufweist
+
+**User Stories:**
+
+1. Deine Produkt-Landingpage sollte ein `header` Element mit einem entsprechenden `id="header"` haben
+1. Du kannst ein Bild innerhalb des `header` Elements mit einem entsprechenden `id="header-img"` (Ein Logo würde hier ein gutes Bild abgeben) sehen
+1. Innerhalb des `#header` Elements, siehst du ein `nav` Element mit dazugehöriger `id="nav-bar"`
+1. Du kannst mindestens drei anklickbare Elemente innerhalb des `nav` Elements sehen, jedes mit der Klasse `nav-link`
+1. Wenn du den `.nav-link` Button im `nav` Element drückst, wirst du zu dem entsprechenden Bereich auf der Landingpage geführt
+1. Du kannst ein eingebettetes Produktvideo mit `id="video"` ansehen
+1. Deine Landingpage sollte ein `form` Element mit einer einer entsprechenden `id="form"` haben
+1. Innerhalb des Formulars gibt es ein `input` Feld mit `id="email"`, in das du deine E-Mail Adresse eingeben kannst
+1. Das `#email` Eingabefeld sollte einen Platzhaltertext haben, um die Benutzer über das Feld zu informieren
+1. Das `#email` Eingabefeld benutzt HTML-5 Validierung, um zu bestätigen, dass der eingegebene Text auch wirklich eine E-Mail Adresse ist
+1. Innerhalb des Formulars gibt es auch ein Bestätigungsbutton -`input` mit einer entsprechenden `id="submit"`
+1. Wenn du das `#submit` Element klickst, wird die E-Mail zu einer statischen Seite weitergeleitet (Verwende diese Schein-URL: `https://www.freecodecamp.com/email-submit`)
+1. Die Navigationsleiste sollte immer oben am Viewport liegen
+1. Deine Produkt-Landingpage sollte mindestens eine Medienabfrage (Media Query) haben
+1. Deine Produkt-Landingpage sollte die CSS-Flexbox mindestens einmal verwenden
+
+Erfülle die folgenden User Stories und bestehe alle Tests, um dieses Projekt abzuschließen. Gib dem Ganzen deinen persönlichen Stil. Viel Spaß beim Programmieren!
+
+**Hinweis:** Achte darauf, `Product Landing Page
+
+
+
+
+
+ Pokemon Daycare Service
+
+
+ What we offer
+
+
+
+
+
Guaranteed friendly and loving staff!
+
+
+
+
+
+ Comfortable environment for Pokemon to explore and play!
+
+
+
+
+
+
+ Multiple membership plans to fit your lifestyle!
+
+
+
+ Check us out!
+ A sneak peek into our facility:
+ VIDEO
+
+
+ Membership Plans
+
+
+
Basic Membership
+
+ One Pokemon
+ Food and berries provided
+
+
$9.99/month
+
+
+
Silver Membership
+
+ Up to Three Pokemon
+ Food and berries provided
+ Grooming and accessories included
+
+
$19.99/month
+
+
+
Gold Membership
+
+ Up to six Pokemon!
+ Food and berries provided
+ Grooming and accessories included
+ Personal training for each Pokemon
+ Breeding and egg hatching
+
+
$29.99/month
+
+
+
+
+
+
+
+```
+
+```css
+body {
+ background-color: #3a3240;
+ color: white;
+}
+main {
+ max-width: 750px;
+ margin: 50px auto;
+}
+input {
+ background-color: #92869c;
+}
+a:not(.nav-link) {
+ color: white;
+}
+#header-img {
+ max-height: 25px;
+}
+#nav-bar {
+ position: fixed;
+ width: 100%;
+ text-align: center;
+ top: 0%;
+ background-color: #92869c;
+}
+h1 {
+ text-align: center;
+}
+body {
+ text-align: center;
+}
+footer {
+ text-align: center;
+}
+#bullet {
+ max-height: 25px;
+}
+.flex-here {
+ display: flex;
+ justify-content: center;
+}
+.flex-left {
+ height: 25px;
+}
+.flex-mem {
+ display: flex;
+ justify-content: center;
+}
+.flex-mem-box {
+ background-color: #92869c;
+ border-color: black;
+ border-width: 5px;
+ border-style: solid;
+ margin: 10px;
+ padding: 10px;
+ color: black;
+}
+@media (max-width: 350px) {
+ #video {
+ width: 300;
+ height: 200;
+ }
+}
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md
new file mode 100644
index 00000000000..5fcdb8f5f1b
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md
@@ -0,0 +1,518 @@
+---
+id: 587d78af367417b2b2512b03
+title: Erstelle ein Umfrageformular
+challengeType: 14
+forumTopicId: 301145
+dashedName: build-a-survey-form
+---
+
+# --description--
+
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie https://survey-form.freecodecamp.rocks aufweist
+
+**User Stories:**
+
+1. Du solltest einen Seitentitel in einem `h1`-Element mit einer `id` von `title` haben
+1. Du solltest eine kurze Erklärung in einem `p`-Element mit einer `id` von `description` haben
+1. Du solltest ein `form`-Element mit einer `id` von `survey-form` haben
+1. Innerhalb des Formular-Elements **musst** du deinen Namen in ein `input`-Feld mit einer `id` von `name` und einem `type` von `text` eingeben
+1. Innerhalb des Formular-Elements **musst** du deine E-Mail in ein `input`-Feld mit einer `id` von `email` eingeben
+1. Wenn du eine falsch formatierte E-Mail angibst, wird dir ein HTML5-Validierungsfehler ausgegeben
+1. Innerhalb des Formulars kannst du eine Zahl in das `input`-Feld, das die `id` von `number` hat, eingeben
+1. Wenn du eine nicht-numerische Eingabe in das Nummern-Feld eingibst, wird dir ein HTML5-Validierungsfehler ausgegeben
+1. Wenn du eine Nummer eingibst, die außerhalb des Bereichs der Zahleneingabe liegt, wird dir ein HTML5-Validierungsfehler ausgegeben. Der genannte Bereich wird durch die `min`- und `max`-Attribute festgelegt
+1. Für die Namen-, E-Mail- und Nummern-Eingabefelder findest du zugehörige `label`-Elemente im Formular, welches den Nutzen jedes Felds der folgenden IDs beschreibt: `id="name-label"`, `id="email-label"`, und `id="number-label"`
+1. Für die Namen-, E-Mail- und Nummern-Eingabefelder findest du einen Platzhalter-Text, der eine Beschreibung oder Anweisung für jedes Feld enthält
+1. Innerhalb des Formular-Elements solltest du ein `select`-Dropdown-Element auffinden, welches sowohl über eine `id` von `dropdown` als auch über mindestens zwei Optionen zum Auswählen verfügt
+1. Innerhalb des Fomular-Elements kannst du aus einer Gruppe von mindestens zwei Radio-Buttons, die mit dem `name`-Attribut unterteilt wurden, auswählen
+1. Innerhalb des Formular-Elements kannst du mehrere Felder aus einer Reihe von Checkboxen auswählen, die alle über ein `value`-Attribut verfügen müssen
+1. Innerhalb des Formular-Elements findest du eine `textarea` mit zusätzlichen Kommentaren
+1. Innerhalb des Formular-Elementes wird dir ein Button mit der `id` von `submit` angezeigt, um alle Eingaben abzuschicken
+
+Erfülle die folgenden User Stories und bestehe alle Tests, um dieses Projekt abzuschließen. Gib dem Ganzen deinen persönlichen Stil. Viel Spaß beim Programmieren!
+
+**Hinweis:** Achte darauf, `Survey Form
+
+
+ Survey Form
+ The card below was built as a sample survey form for freeCodeCamp.
+
+ Join the Togepi Fan Club!
+
+ Enter your information here to receive updates about club activities,
+ our monthly newsletter, and other email communications.
+
+
+
+
+
+
+```
+
+```css
+main {
+ text-align: center;
+ background-color: #92869c;
+ background-blend-mode: lighten;
+ max-width: 500px;
+ margin: 20px auto;
+ border-radius: 50px;
+ box-shadow: 10px 10px rgba(0, 0, 0, 0.5);
+ color: black;
+}
+body {
+ text-align: center;
+ background: #3a3240;
+ color: white;
+}
+input, textarea, select, button {
+ background: #3a3240;
+ color: white;
+}
+a {
+ color: white;
+}
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md
new file mode 100644
index 00000000000..cc3249184a9
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md
@@ -0,0 +1,529 @@
+---
+id: 587d78b0367417b2b2512b05
+title: Erstelle eine Seite für technische Dokumentationen
+challengeType: 14
+forumTopicId: 301146
+dashedName: build-a-technical-documentation-page
+---
+
+# --description--
+
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie https://technical-documentation-page.freecodecamp.rocks aufweist
+
+**User Stories:**
+
+1. Du kannst ein `main`-Element mit einer entsprechenden `id="main-doc"` sehen, das den Hauptinhalt der Seite enthält (technische Dokumentation)
+1. Innerhalb des `#main-doc`-Elements kannst du mehrere `section`-Elemente sehen, jedes mit einer `main-section`-Klasse. Es sollten mindestens 5 sein
+1. Das erste Element innerhalb jeder `.main-section` sollte ein `header`-Element sein, das einen Text enthält, der das Thema dieses Abschnitts beschreibt.
+1. Jedes `section`-Element der Klasse `main-section` sollte auch eine `id` haben, die mit dem Text von jedem `header` übereinstimmt. Alle Leerzeichen sollten durch Unterstriche ersetzt werden (z. B. sollte die Sektion, welche die Überschrift "JavaScript and Java" enthält, eine entsprechende `id="JavaScript_and_Java"` haben)
+1. Die `.main-section`-Elemente sollten mindestens zehn `p`-Elemente enthalten (insgesamt)
+1. Die `.main-section`-Elemente sollten mindestens fünf `code`-Elemente enthalten (insgesamt)
+1. Die `.main-section`-Elemente sollten mindestens fünf `li`-Elemente enthalten (nicht jedes)
+1. Du kannst ein `nav`-Element mit entsprechender `id="navbar"` sehen
+1. Das Navbar-Element sollte ein `header`-Element enthalten, das einen Text enthält, der das Thema der technischen Dokumentation beschreibt
+1. Außerdem sollte die Navigationsleiste auch Link-Elemente (`a`) der Klasse `nav-link` enthalten. Es sollte eines für jedes Element mit der Klasse `main-section` geben
+1. Das `header`-Element in der `#navbar` muss vor jedem Link-Element (`a`) in der Navigationsleiste stehen
+1. Jedes Element der Klasse `nav-link` sollte einen Text enthalten, der zu dem entsprechenden `header`-Text jeder `section` passt (wenn du z.B. einen Header bzw. eine Sektion mit „Hello world" hast, sollte deine Navigationsleiste ein Element mit eben jenem Text enthalten)
+1. Wenn du auf ein Element der Navigationsleiste klickst, sollte die Seite zu der entsprechenden Sektion des `#main-doc`-Elements navigieren (klickst du z.B. auf ein `.nav-link`-Element, das den Text „Hello World" enthält, sollte die Seite zu einem `section`-Element mit dieser Id navigieren und nun den entsprechenden Header enthalten)
+1. Auf Geräten mit regulärer Größe (Laptops, Desktop-PCs) sollte das Element mit der `id="navbar"` auf der linken Seite des Bildschirms angezeigt werden und für den Nutzer immer sichtbar sein
+1. Deine technische Dokumentation sollte mindestens eine Media Query verwenden
+
+Erfülle die folgenden User Stories und bestehe alle Tests, um dieses Projekt abzuschließen. Gib dem Ganzen deinen persönlichen Stil. Viel Spaß beim Programmieren!
+
+**Hinweis:** Achte darauf, `Technical Documentation Page
+
+
+
+
+ Introduction Definitions Examples Solving Equations Solving Equations II Solving Equations III System of Equations Try it Yourself! More Information
+
+
+
+
+ Welcome to a basic introduction of algebra. In this tutorial, we will
+ review some of the more common algebraic concepts.
+
+
+
+
+
+ To start with, let's define some of the more common terms used in
+ algebra:
+
+
+
+ Variable: A variable is an unknown value, usually represented
+ by a letter.
+
+
+ Expression: Essentially a mathematical object. For the
+ purpose of this tutorial, an expression is one part of an equation.
+
+
+ Equation: An equation is a mathematical argument in which two
+ expressions result in the same value.
+
+
+
+
+
+
+ Sometimes it is easier to understand the definitions when you have a
+ physical example to look at. Here is an example of the above terms.x + 5 = 12
+
+ Variable: The variable in the example is "x".
+ Expression: There are two expressions in this example. They
+ are "x+5" and "12".
+
+
+ Equation: The entire example, "x+5=12", is an equation.
+
+
+
+
+
+
+ The primary use for algebra is to determine an unknown value, the
+ "variable", with the information provided. Continuing to use our
+ example from above, we can find the value of the variable "x".x + 5 = 12 get the variable into its own expression, or by itself on one side
+ of the = sign. subtract 5 , because subtraction is
+ the opposite operation to addition. But remember, we have to perform
+ the same operation to both sides of the equation. Now our equation
+ looks like this.x + 5 - 5 = 12 - 5simplify this equation to make it easier
+ to read by performing the operations "5-5" and "12-5". The result
+ is:x = 7
+
+
+
+
+ Let us look at a slightly more challenging equation.3x + 4 = 133x = 9divide each expression by 3 .x = 3
+
+
+
+
+ Now we are getting in to more complex operations. Here is another
+ equation for us to look at:x^2 - 8 = 8add 8 to each side. This is
+ different from our previous examples, where we had to subtract. But
+ remember, our goal is to get the variable alone by performing opposite
+ operations.x^2 = 16is available, you would see it as x2 .
+ For the sake of this project, however, we will use the "^" symbol.divide both sides by "x" . We do not want to do this, as that
+ would put an "x" on the other side of the equation. So instead, we
+ need to use the root operation! For an exponent of "2", we call this
+ the "square root" and denote it with "√". Our equation is now:
+ x = √9perfect square , so we do not need to calculate anything. Instead, we find our
+ answer to be:x = 3
+
+
+
+
+
+ As you explore your algebra studies further, you may start to run
+ across equations with more than one variable. The first such equations
+ will likely look like:y = 3xnot have one single solution .
+ Rather, there are a series of values for which the equation is true.
+ For example, if "x=3" and "y=9", the equation is true. These equations
+ are usually used to plot a graph. pair of
+ equations. This is called a "system of equations", and CAN be solved.
+ Let's look at how we do this! Consider the following system of
+ equations:y = 3x | y - 6 = x
+ A system of equations IS solvable, but it is a multi-step process. To
+ get started, we need to chose a variable we are solving for. Let's
+ solve for "x" first. From the second equation, we know that "x" equals
+ "y - 6", but we cannot simplify that further because we do not have a
+ value for "y". Except, thanks to the system of equations, we DO have a
+ value for "y". We know that "y" equals "3x". So, looking at our second
+ equation, we can replace "y" with "3x" because they have the same
+ value. We then get:3x - 6 = x3x = x + 62x = 6x = 3y = 3xy = 3*3x = 3 and y = 9
+
+
+
+ Coming Soon!
+ Keep an eye out for new additions!
+
+
+
+ Check out the following links for more information!
+
+
+
+
+
+
+```
+
+```css
+* {
+ background-color: #3a3240;
+}
+a {
+ color: #92869c;
+}
+a:hover {
+ background-color: #92869c;
+ color: #3a3240;
+}
+#navbar {
+ border-style: solid;
+ border-width: 5px;
+ border-color: #92869c;
+ height: 100%;
+ top: -5px;
+ left: -5px;
+ padding: 5px;
+ text-align: center;
+ color: #92869c
+}
+@media (min-width: 480px) {
+ #navbar {
+ position: fixed;
+ }
+}
+main {
+ margin-left: 220px;
+ color: #92869c
+}
+header {
+ font-size: 20pt;
+}
+code {
+ background-color: #92869c;
+ border-style: dashed;
+ border-width: 2px;
+ border-color: #92869c;
+ padding: 5px;
+ color: black;
+}
+footer {
+ text-align: center;
+}
+```
diff --git a/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md
new file mode 100644
index 00000000000..e5baa3220c1
--- /dev/null
+++ b/curriculum/challenges/german/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md
@@ -0,0 +1,325 @@
+---
+id: bd7158d8c442eddfaeb5bd18
+title: Erstelle eine Tribute-Seite
+challengeType: 14
+forumTopicId: 301147
+dashedName: build-a-tribute-page
+---
+
+# --description--
+
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie https://tribute-page.freecodecamp.rocks aufweist
+
+**User Stories:**
+
+1. Deine Tribute-Seite sollte über ein `main`-Element mit einer zugehörigen `id` von `main` verfügen, die alle anderen Elemente enthält
+1. Du solltest ein Element mit einer `id` von `title` sehen, das einen String (d.h. Text) enthält, der das Thema der Tribute-Seite beschreibt (z.B. „Dr. Norman Borlaug“)
+1. Du solltest entweder ein `figure`- oder ein `div`-Element mit einer `id` von `img-div` sehen
+1. Du solltest innerhalb des `#img-div`-Elements ein `img`-Element mit zugehöriger `id="image"` sehen
+1. Du solltest innerhalb des `#img-div`-Elements ein Element mit zugehöriger `id="img-caption"` sehen, der einen Text enthält, der das in `#img-div` angezeigte Bild beschreibt.
+1. Du solltest ein Element mit zugehöriger `id="tribute-info"` sehen, das einen Text enthält und das Thema der Tribute-Seite beschreibt
+1. Du solltest ein `a`-Element mit zugehöriger `id="tribute-link"` sehen, welches auf eine externe Seite verweist, die zusätzliche Informationen über das Thema der Tribute-Seite enthält. TIPP: Du musst deinem Element ein Attribut von `target` zuweisen und es auf `_blank` setzen, damit der Link in einem neuen Tab geöffnet werden kann
+1. Dein `#image` sollte die `max-width` und `height` Eigenschaften verwenden, um die Größenänderung responsiv zu gestalten, daher relativ zur Breite des übergeordneten Elements, ohne dessen Originalgröße zu überschreiten
+1. Dein `img`-Element sollte innerhalb des Elternelements zentriert werden
+
+Erfülle die folgenden User Stories und bestehe alle Tests, um dieses Projekt abzuschließen. Gib dem Ganzen deinen persönlichen Stil. Viel Spaß beim Programmieren!
+
+**Hinweis:** Achte darauf, `Tribute Page
+
+
+ Tribute Page
+ The below card was designed as a tribute page for freeCodeCamp.
+
+
+
+
Togepi, happy as always.
+
Togepi
+
+
+ Togepi was first discovered in the Johto region, when Ash Ketchum
+ discovered a mysterious egg. However, when the egg hatched, Togepi saw
+ Ash's friend Misty first and imprinted on her. Like many other
+ creatures, this imprinting process created a bond and Togepi views
+ Misty as his mother.
+
+
+ Togepi is a very childlike Pokemon, and is very emotionally
+ expressive. He demonstrates extreme levels of joy and sadness.
+
+
+
Battle Information
+
+ Type: Fairy
+ Evolutions: Togepi -> Togetic -> Togekiss
+ Moves: Growl, Pound, Sweet Kiss, Charm
+ Weaknesses: Poison, Steel
+ Resistances: Dragon
+
+
+ Check out this
+ Bulbapedia article on Togepi
+ for more information on this great Pokemon.
+
+
+
+
+
+```
+
+```css
+body {
+ background-color: #3a3240;
+ color: white;
+}
+main {
+ background-color: #92869c;
+ font-family: Lobster;
+ max-width: 500px;
+ margin: 20px auto;
+ color: black;
+ border-radius: 50px;
+ box-shadow: 10px 10px rgba(0, 0, 0, 0.5);
+}
+h2 {
+ text-align: center;
+ font-size: 20pt;
+ font-family: Pacifico;
+}
+body {
+ text-align: center;
+ font-size: 12pt;
+}
+footer {
+ text-align: center;
+ font-size: 10pt;
+}
+.border {
+ border-color: black;
+ border-width: 5px;
+ border-style: solid;
+}
+#image {
+ height: auto;
+ display: block;
+ margin: auto;
+ max-width: 100%;
+ border-radius: 50%;
+}
+#img-caption {
+ font-size: 10pt;
+}
+a:not(#tribute-link) {
+ color: white;
+}
+hr {
+ border-color: black;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
new file mode 100644
index 00000000000..4c884759572
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
@@ -0,0 +1,97 @@
+---
+id: a77dbc43c33f39daa4429b4f
+title: Boo wer?
+challengeType: 1
+forumTopicId: 16000
+dashedName: boo-who
+---
+
+# --description--
+
+Überprüfe, ob ein Wert als primitiver Boolean deklariert ist. Gib `true` (wahr) oder `false` (falsch) zurück.
+
+Primitive boolesche Werte umfassen `true` und `false`.
+
+# --hints--
+
+`booWho(true)` soll `true` zurückgeben.
+
+```js
+assert.strictEqual(booWho(true), true);
+```
+
+`booWho(false)` soll `true` zurückgeben.
+
+```js
+assert.strictEqual(booWho(false), true);
+```
+
+`booWho([1, 2, 3])` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho([1, 2, 3]), false);
+```
+
+`booWho([].slice)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho([].slice), false);
+```
+
+`booWho({ "a": 1 })` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho({ a: 1 }), false);
+```
+
+`booWho(1)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho(1), false);
+```
+
+`booWho(NaN)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho(NaN), false);
+```
+
+`booWho("a")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('a'), false);
+```
+
+`booWho("true")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('true'), false);
+```
+
+`booWho("false")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('false'), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function booWho(bool) {
+ return bool;
+}
+
+booWho(null);
+```
+
+# --solutions--
+
+```js
+function booWho(bool) {
+ return typeof bool === "boolean";
+}
+
+booWho(null);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
new file mode 100644
index 00000000000..39c969b1066
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
@@ -0,0 +1,110 @@
+---
+id: a9bd25c716030ec90084d8a1
+title: Chunky Monkey
+challengeType: 1
+forumTopicId: 16005
+dashedName: chunky-monkey
+---
+
+# --description--
+
+Schreibe eine Funktion, die ein Array (erstes Argument) in Gruppen mit der Länge `size` (zweites Argument) aufteilt und sie als zweidimensionales Array zurückgibt.
+
+# --hints--
+
+`chunkArrayInGroups(["a", "b", "c", "d"], 2)` sollte `[["a", "b"], ["c", "d"]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [
+ ['a', 'b'],
+ ['c', 'd']
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` sollte `[[0, 1, 2], [3, 4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [
+ [0, 1, 2],
+ [3, 4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` sollte `[[0, 1], [2, 3], [4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [
+ [0, 1],
+ [2, 3],
+ [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` sollte `[[0, 1, 2, 3], [4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [
+ [0, 1, 2, 3],
+ [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` sollte`[[0, 1, 2], [3, 4, 5], [6]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [
+ [0, 1, 2],
+ [3, 4, 5],
+ [6]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` sollte `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [
+ [0, 1, 2, 3],
+ [4, 5, 6, 7],
+ [8]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` sollte `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [
+ [0, 1],
+ [2, 3],
+ [4, 5],
+ [6, 7],
+ [8]
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chunkArrayInGroups(arr, size) {
+ return arr;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
+
+# --solutions--
+
+```js
+function chunkArrayInGroups(arr, size) {
+ let out = [];
+
+ for (let i = 0; i < arr.length; i += size) {
+ out.push(arr.slice(i, i + size));
+ }
+
+ return out;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
new file mode 100644
index 00000000000..143a21293d3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
@@ -0,0 +1,113 @@
+---
+id: acda2fb1324d9b0fa741e6b5
+title: Bestätige das Ende
+challengeType: 1
+forumTopicId: 16006
+dashedName: confirm-the-ending
+---
+
+# --description--
+
+Überprüfe, ob ein String (erstes Argument, `str`) mit einem gegebenen Target-String (zweites Argument, `target`) endet.
+
+Diese Aufgabe *kann* mit der Methode `.endsWith()` gelöst werden, die in ES2015 eingeführt wurde. Jedoch hätten wir für den Zweck dieser Aufgabe gerne, dass du stattdessen die JavaScript Substring-Methode verwendest.
+
+# --hints--
+
+`confirmEnding("Bastian", "n")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Bastian', 'n') === true);
+```
+
+`confirmEnding("Congratulation", "on")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Congratulation', 'on') === true);
+```
+
+`confirmEnding("Connor", "n")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Connor', 'n') === false);
+```
+
+`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` soll `false` zurückgeben.
+
+```js
+assert(
+ confirmEnding(
+ 'Walking on water and developing software from a specification are easy if both are frozen',
+ 'specification'
+ ) === false
+);
+```
+
+`confirmEnding("He has to give me a new name", "name")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('He has to give me a new name', 'name') === true);
+```
+
+`confirmEnding("Open sesame", "same")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'same') === true);
+```
+
+`confirmEnding("Open sesame", "sage")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'sage') === false);
+```
+
+`confirmEnding("Open sesame", "game")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'game') === false);
+```
+
+`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` soll `false` zurückgeben.
+
+```js
+assert(
+ confirmEnding(
+ 'If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing',
+ 'mountain'
+ ) === false
+);
+```
+
+`confirmEnding("Abstraction", "action")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Abstraction', 'action') === true);
+```
+
+Dein Code sollte diese Aufgabe ohne die integrierte Methode `.endsWith()` lösen.
+
+```js
+assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function confirmEnding(str, target) {
+ return str;
+}
+
+confirmEnding("Bastian", "n");
+```
+
+# --solutions--
+
+```js
+function confirmEnding(str, target) {
+ return str.substring(str.length - target.length) === target;
+}
+
+confirmEnding("Bastian", "n");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
new file mode 100644
index 00000000000..b62e1a088f4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b3
+title: Umrechnung von Celsius in Fahrenheit
+challengeType: 1
+forumTopicId: 16806
+dashedName: convert-celsius-to-fahrenheit
+---
+
+# --description--
+
+Die Formel zur Umrechnung von Celsius in Fahrenheit lautet: Celsius mal `9/5`, plus `32`.
+
+Du erhältst eine vorgegebene Variable namens `celsius`, die für den Temperaturwert in Celsius steht. Verwende die vordefinierte Variable `fahrenheit` und weise ihr die Temperatur in Fahrenheit äquivalent zum gegebenen Temperaturwert in Celsius zu. Verwende die oben angegebene Formel um die Temperatur von Celsius in Fahrenheit umzurechnen.
+
+# --hints--
+
+`convertCtoF(0)` sollte eine Zahl zurückgeben
+
+```js
+assert(typeof convertCtoF(0) === 'number');
+```
+
+`convertCtoF(-30)` sollte den Wert `-22` zurückgeben
+
+```js
+assert(convertCtoF(-30) === -22);
+```
+
+`convertCtoF(-10)` sollte den Wert `14` zurückgeben
+
+```js
+assert(convertCtoF(-10) === 14);
+```
+
+`convertCtoF(0)` sollte den Wert `32` zurückgeben
+
+```js
+assert(convertCtoF(0) === 32);
+```
+
+`convertCtoF(20)` sollte den Wert `68` zurückgeben
+
+```js
+assert(convertCtoF(20) === 68);
+```
+
+`convertCtoF(30)` sollte den Wert `86` zurückgeben
+
+```js
+assert(convertCtoF(30) === 86);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertCtoF(celsius) {
+ let fahrenheit;
+ return fahrenheit;
+}
+
+convertCtoF(30);
+```
+
+# --solutions--
+
+```js
+function convertCtoF(celsius) {
+ let fahrenheit = celsius * 9/5 + 32;
+ return fahrenheit;
+}
+
+convertCtoF(30);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
new file mode 100644
index 00000000000..a44922d98a5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
@@ -0,0 +1,73 @@
+---
+id: a302f7aae1aa3152a5b413bc
+title: Faktorisierung einer Zahl
+challengeType: 1
+forumTopicId: 16013
+dashedName: factorialize-a-number
+---
+
+# --description--
+
+Gib die Fakultät der übergebenen ganzen Zahl zurück.
+
+Wenn die ganze Zahl mit dem Buchstaben `n` dargestellt wird, ist eine Fakultät das Produkt aller positiven ganzen Zahlen kleiner oder gleich `n`.
+
+Fakultäten werden häufig mit der Kurzschreibweise `n!` dargestellt.
+
+Zum Beispiel: `5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+Nur ganze Zahlen größer oder gleich null werden der Funktion übergeben.
+
+# --hints--
+
+`factorialize(5)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof factorialize(5) === 'number');
+```
+
+`factorialize(5)` sollte `120` zurückgeben.
+
+```js
+assert(factorialize(5) === 120);
+```
+
+`factorialize(10)` sollte `3628800` zurückgeben.
+
+```js
+assert(factorialize(10) === 3628800);
+```
+
+`factorialize(20)` sollte `2432902008176640000` zurückgeben.
+
+```js
+assert(factorialize(20) === 2432902008176640000);
+```
+
+`factorialize(0)` sollte `1` zurückgeben.
+
+```js
+assert(factorialize(0) === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function factorialize(num) {
+ return num;
+}
+
+factorialize(5);
+```
+
+# --solutions--
+
+```js
+function factorialize(num) {
+ return num < 1 ? 1 : num * factorialize(num - 1);
+}
+
+factorialize(5);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
new file mode 100644
index 00000000000..8b38f9146b7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
@@ -0,0 +1,63 @@
+---
+id: adf08ec01beb4f99fc7a68f2
+title: Falsy Bouncer
+challengeType: 1
+forumTopicId: 16014
+dashedName: falsy-bouncer
+---
+
+# --description--
+
+Entferne alle fehlerhaften Werte aus einem Array.
+
+Folgendes sind fehlerhafte Werte in JavaScript: `false`, `null`, `0`, `""`, `undefined`, und `NaN`.
+
+Tipp: Versuche, jeden Wert in einen booleschen Wert zu konvertieren.
+
+# --hints--
+
+`bouncer([7, "ate", "", false, 9])` sollte `[7, "ate", 9]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]);
+```
+
+`bouncer(["a", "b", "c"])` sollte `["a", "b", "c"]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']);
+```
+
+`bouncer([false, null, 0, NaN, undefined, ""])` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []);
+```
+
+`bouncer([null, NaN, 1, 2, undefined])` sollte `[1, 2]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function bouncer(arr) {
+ return arr;
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
+
+# --solutions--
+
+```js
+function bouncer(arr) {
+ return arr.filter(e => e);
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
new file mode 100644
index 00000000000..ffb3b64015a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
@@ -0,0 +1,87 @@
+---
+id: a26cbbe9ad8655a977e1ceb5
+title: Finde das längste Wort in einem String
+challengeType: 1
+forumTopicId: 16015
+dashedName: find-the-longest-word-in-a-string
+---
+
+# --description--
+
+Gib die Länge des längsten Wortes im angegebenen Satz zurück.
+
+Deine Antwort sollte eine Zahl sein.
+
+# --hints--
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` sollte eine Zahl zurückgeben.
+
+```js
+assert(
+ typeof findLongestWordLength(
+ 'The quick brown fox jumped over the lazy dog'
+ ) === 'number'
+);
+```
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` sollte `6` zurückgeben.
+
+```js
+assert(
+ findLongestWordLength('The quick brown fox jumped over the lazy dog') === 6
+);
+```
+
+`findLongestWordLength("May the force be with you")` sollte `5` zurückgeben.
+
+```js
+assert(findLongestWordLength('May the force be with you') === 5);
+```
+
+`findLongestWordLength("Google do a barrel roll")` sollte `6` zurückgeben.
+
+```js
+assert(findLongestWordLength('Google do a barrel roll') === 6);
+```
+
+`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` sollte `8` zurückgeben.
+
+```js
+assert(
+ findLongestWordLength(
+ 'What is the average airspeed velocity of an unladen swallow'
+ ) === 8
+);
+```
+
+`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` sollte `19` zurückgeben.
+
+```js
+assert(
+ findLongestWordLength(
+ 'What if we try a super-long word such as otorhinolaryngology'
+ ) === 19
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findLongestWordLength(str) {
+ return str.length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
+
+# --solutions--
+
+```js
+function findLongestWordLength(str) {
+ return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
new file mode 100644
index 00000000000..53bbe30b92f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
@@ -0,0 +1,58 @@
+---
+id: a6e40f1041b06c996f7b2406
+title: Finders Keepers
+challengeType: 1
+forumTopicId: 16016
+dashedName: finders-keepers
+---
+
+# --description--
+
+Erstelle eine Funktion, die einen Array namens `arr` durchsucht und das erste Element zurückgibt, das einen "Wahrheitstest" besteht. Das bedeutet, dass ein Element `x` den "Wahrheitstest" bestanden hat, wenn `func(x)` gleich `true` (engl. wahr) ist. Wenn kein Element den Test besteht, gib `undefined` (engl. undefiniert) zurück.
+
+# --hints--
+
+`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` sollte `8` zurückgeben.
+
+```js
+assert.strictEqual(
+ findElement([1, 3, 5, 8, 9, 10], function (num) {
+ return num % 2 === 0;
+ }),
+ 8
+);
+```
+
+`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` sollte `undefined` zurückgeben.
+
+```js
+assert.strictEqual(
+ findElement([1, 3, 5, 9], function (num) {
+ return num % 2 === 0;
+ }),
+ undefined
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findElement(arr, func) {
+ let num = 0;
+ return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
+
+# --solutions--
+
+```js
+function findElement(arr, func) {
+ return arr.filter(func)[0];
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
new file mode 100644
index 00000000000..eec8501464a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
@@ -0,0 +1,117 @@
+---
+id: af2170cad53daa0770fabdea
+title: Mutations
+challengeType: 1
+forumTopicId: 16025
+dashedName: mutations
+---
+
+# --description--
+
+Gib `true` zurück, wenn der String im ersten Element des Arrays alle Buchstaben des Strings im zweiten Element des Arrays enthält.
+
+Zum Beispiel sollte `["hello", "Hello"]` den Wert `true` zurückgeben, weil unabhängig von der Groß- und Kleinschreibung, alle Buchstaben des zweiten Strings im ersten enthalten sind.
+
+Die Argumente `["hello", "hey"]` sollten `false` zurückgeben, weil der String `hello` kein `y` beinhaltet.
+
+Schließlich sollte `["Alien", "line"]` den Wert `true` zurückgeben, weil alle Buchstaben von `line` in `Alien` vorhanden sind.
+
+# --hints--
+
+`mutation(["hello", "hey"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['hello', 'hey']) === false);
+```
+
+`mutation(["hello", "Hello"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['hello', 'Hello']) === true);
+```
+
+`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true);
+```
+
+`mutation(["Mary", "Army"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Mary', 'Army']) === true);
+```
+
+`mutation(["Mary", "Aarmy"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Mary', 'Aarmy']) === true);
+```
+
+`mutation(["Alien", "line"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Alien', 'line']) === true);
+```
+
+`mutation(["floor", "for"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['floor', 'for']) === true);
+```
+
+`mutation(["hello", "neo"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['hello', 'neo']) === false);
+```
+
+`mutation(["voodoo", "no"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['voodoo', 'no']) === false);
+```
+
+`mutation(["ate", "date"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['ate', 'date']) === false);
+```
+
+`mutation(["Tiger", "Zebra"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['Tiger', 'Zebra']) === false);
+```
+
+`mutation(["Noel", "Ole"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Noel', 'Ole']) === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mutation(arr) {
+ return arr;
+}
+
+mutation(["hello", "hey"]);
+```
+
+# --solutions--
+
+```js
+function mutation(arr) {
+ let hash = Object.create(null);
+
+ arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
+
+ return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
+}
+
+mutation(["hello", "hey"]);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
new file mode 100644
index 00000000000..7cb2d6059fb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
@@ -0,0 +1,84 @@
+---
+id: afcc8d540bea9ea2669306b6
+title: Repeat a String Repeat a String
+challengeType: 1
+forumTopicId: 16041
+dashedName: repeat-a-string-repeat-a-string
+---
+
+# --description--
+
+Wiederhole den vorgegeben String `str` (erstes Argument) für `num` male (zweites Argument). Gib einen leeren String zurück, falls `num` keine positive Zahl ist. Für den Zweck dieser Aufgabe sollte *nicht* die built-in Methode `.repeat()` verwendet werden.
+
+# --hints--
+
+`repeatStringNumTimes("*", 3)` sollte den String `***` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('*', 3) === '***');
+```
+
+`repeatStringNumTimes("abc", 3)` sollte den String `abcabcabc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
+```
+
+`repeatStringNumTimes("abc", 4)` sollte den String `abcabcabcabc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
+```
+
+`repeatStringNumTimes("abc", 1)` sollte den String `abc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 1) === 'abc');
+```
+
+`repeatStringNumTimes("*", 8)` sollte den String `********` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('*', 8) === '********');
+```
+
+`repeatStringNumTimes("abc", -2)` sollte einen leeren String (`""`) zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', -2) === '');
+```
+
+Die built-in Methode `repeat()` sollte hier nicht verwendet werden.
+
+```js
+assert(!/\.repeat/g.test(code));
+```
+
+`repeatStringNumTimes("abc", 0)` sollte `""` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 0) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function repeatStringNumTimes(str, num) {
+ return str;
+}
+
+repeatStringNumTimes("abc", 3);
+```
+
+# --solutions--
+
+```js
+function repeatStringNumTimes(str, num) {
+ if (num < 1) return '';
+ return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
+}
+
+repeatStringNumTimes("abc", 3);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
new file mode 100644
index 00000000000..6d953714d7c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
@@ -0,0 +1,92 @@
+---
+id: a789b3483989747d63b0e427
+title: Return Largest Numbers in Arrays
+challengeType: 1
+forumTopicId: 16042
+dashedName: return-largest-numbers-in-arrays
+---
+
+# --description--
+
+Gib ein Array zurück, das aus den größten Zahlen der Sub-Arrays besteht. Zur Vereinfachung wird das übergebene Array genau vier Sub-Arrays enthalten.
+
+Denk daran, dass du ein Array mit einem einfachen for-Loop durchlaufen kannst und auf jedes Element mit der Array-Syntax `arr[i]` zugreifen kannst.
+
+# --hints--
+
+`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` sollte ein Array zurückgeben.
+
+```js
+assert(
+ largestOfFour([
+ [4, 5, 1, 3],
+ [13, 27, 18, 26],
+ [32, 35, 37, 39],
+ [1000, 1001, 857, 1]
+ ]).constructor === Array
+);
+```
+
+`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` sollte `[27, 5, 39, 1001]` zurückgeben.
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [13, 27, 18, 26],
+ [4, 5, 1, 3],
+ [32, 35, 37, 39],
+ [1000, 1001, 857, 1]
+ ]),
+ [27, 5, 39, 1001]
+);
+```
+
+`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` sollte `[9, 35, 97, 1000000]` zurückgeben.
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [4, 9, 1, 3],
+ [13, 35, 18, 26],
+ [32, 35, 97, 39],
+ [1000000, 1001, 857, 1]
+ ]),
+ [9, 35, 97, 1000000]
+);
+```
+
+`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` sollte `[25, 48, 21, -3]` zurückgeben.
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [17, 23, 25, 12],
+ [25, 7, 34, 48],
+ [4, -10, 18, 21],
+ [-72, -3, -17, -10]
+ ]),
+ [25, 48, 21, -3]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function largestOfFour(arr) {
+ return arr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
+
+# --solutions--
+
+```js
+function largestOfFour(arr) {
+ return arr.map(subArr => Math.max.apply(null, subArr));
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
new file mode 100644
index 00000000000..1abf73f9861
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
@@ -0,0 +1,63 @@
+---
+id: a202eed8fc186c8434cb6d61
+title: Reverse a String
+challengeType: 1
+forumTopicId: 16043
+dashedName: reverse-a-string
+---
+
+# --description--
+
+Kehre den angegebenen String um.
+
+Möglicherweise musst du die Strings in ein Array umwandeln, bevor du sie umkehren kannst.
+
+Dein Ergebnis muss ein String sein.
+
+# --hints--
+
+`reverseString("hello")` sollte einen String zurückgeben.
+
+```js
+assert(typeof reverseString('hello') === 'string');
+```
+
+`reverseString("hello")` sollte den String `olleh` zurückgeben.
+
+```js
+assert(reverseString('hello') === 'olleh');
+```
+
+`reverseString("Howdy")` sollte den String `ydwoH` zurückgeben.
+
+```js
+assert(reverseString('Howdy') === 'ydwoH');
+```
+
+`reverseString("Greetings from Earth")` sollten den String `htraE morf sgniteerG` zurückgeben.
+
+```js
+assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function reverseString(str) {
+ return str;
+}
+
+reverseString("hello");
+```
+
+# --solutions--
+
+```js
+function reverseString(str) {
+ return str.split('').reverse().join('');
+}
+
+reverseString("hello");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
new file mode 100644
index 00000000000..05755dd39c8
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
@@ -0,0 +1,98 @@
+---
+id: 579e2a2c335b9d72dd32e05c
+title: Slice und Splice
+challengeType: 1
+forumTopicId: 301148
+dashedName: slice-and-splice
+---
+
+# --description--
+
+Du erhältst zwei Arrays und einen Index.
+
+Kopiere jedes Element des ersten Arrays in derselben Reihenfolge in das zweite Array.
+
+Füge die Elemente beginnend mit dem Index `n` des zweiten Arrays ein.
+
+Gib das resultierende Array zurück. Beide Input-Arrays sollten nach dem Ausführen der Funktion unverändert sein.
+
+# --hints--
+
+`frankenSplice([1, 2, 3], [4, 5], 1)` sollte `[4, 1, 2, 3, 5]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
+```
+
+`frankenSplice([1, 2], ["a", "b"], 1)` sollte `["a", 1, 2, "b"]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
+```
+
+`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` sollte `["head", "shoulders", "claw", "tentacle", "knees", "toes"]` zurückgeben.
+
+```js
+assert.deepEqual(
+ frankenSplice(
+ ['claw', 'tentacle'],
+ ['head', 'shoulders', 'knees', 'toes'],
+ 2
+ ),
+ ['head', 'shoulders', 'claw', 'tentacle', 'knees', 'toes']
+);
+```
+
+Alle Elemente des ersten Arrays sollten in ihrer ursprünglichen Reihenfolgen zum zweiten Array hinzugefügt werden. `frankenSplice([1, 2, 3, 4], [], 0)` sollte `[1, 2, 3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
+```
+
+Das erste Array sollte nach dem Ausführen der Funktion unverändert bleiben.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr1, [1, 2]);
+```
+
+Das zweite Array sollte nach dem Ausführen der Funktion unverändert bleiben.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr2, ['a', 'b']);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+let testArr1 = [1, 2];
+let testArr2 = ["a", "b"];
+```
+
+## --seed-contents--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+ return arr2;
+}
+
+frankenSplice([1, 2, 3], [4, 5, 6], 1);
+```
+
+# --solutions--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+ // It's alive. It's alive!
+ let result = arr2.slice();
+ for (let i = 0; i < arr1.length; i++) {
+ result.splice(n+i, 0, arr1[i]);
+ }
+ return result;
+}
+
+frankenSplice([1, 2, 3], [4, 5], 1);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
new file mode 100644
index 00000000000..c3d27beed37
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
@@ -0,0 +1,64 @@
+---
+id: ab6137d4e35944e21037b769
+title: Title Case a Sentence
+challengeType: 1
+forumTopicId: 16088
+dashedName: title-case-a-sentence
+---
+
+# --description--
+
+Gib den angegebenen String zurück, wobei der erste Buchstabe jeden Wortes groß geschrieben wird. Stelle sicher, dass der Rest der Wörter kleingeschrieben ist.
+
+Für den Zweck dieser Übung schreibe bitte auch Verbindungswörter wie `the` und `of` groß.
+
+# --hints--
+
+`titleCase("I'm a little tea pot")` soll einen String zurückgeben.
+
+```js
+assert(typeof titleCase("I'm a little tea pot") === 'string');
+```
+
+`titleCase("I'm a little tea pot")` soll den String `I'm A Little Tea Pot` zurückgeben.
+
+```js
+assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
+```
+
+`titleCase("sHoRt AnD sToUt")` soll den String `Short And Stout` zurückgeben.
+
+```js
+assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
+```
+
+`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` soll den String `Here Is My Handle Here Is My Spout` zurückgeben.
+
+```js
+assert(
+ titleCase('HERE IS MY HANDLE HERE IS MY SPOUT') ===
+ 'Here Is My Handle Here Is My Spout'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function titleCase(str) {
+ return str;
+}
+
+titleCase("I'm a little tea pot");
+```
+
+# --solutions--
+
+```js
+function titleCase(str) {
+ return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
+}
+
+titleCase("I'm a little tea pot");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
new file mode 100644
index 00000000000..f5075620b11
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
@@ -0,0 +1,91 @@
+---
+id: ac6993d51946422351508a41
+title: Truncate a String
+challengeType: 1
+forumTopicId: 16089
+dashedName: truncate-a-string
+---
+
+# --description--
+
+Kürze einen String (erstes Argument), wenn er länger als die angegebene maximale Stringlänge (zweites Argument) ist. Gib den gekürzten String mit `...` am Ende zurück.
+
+# --hints--
+
+`truncateString("A-tisket a-tasket A green and yellow basket", 8)` soll den String `A-tisket...` zurückgeben.
+
+```js
+assert(
+ truncateString('A-tisket a-tasket A green and yellow basket', 8) ===
+ 'A-tisket...'
+);
+```
+
+`truncateString("Peter Piper picked a peck of pickled peppers", 11)` soll den String `Peter Piper...` zurückgeben.
+
+```js
+assert(
+ truncateString('Peter Piper picked a peck of pickled peppers', 11) ===
+ 'Peter Piper...'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` soll den String `A-tisket a-tasket A green and yellow basket` zurückgeben.
+
+```js
+assert(
+ truncateString(
+ 'A-tisket a-tasket A green and yellow basket',
+ 'A-tisket a-tasket A green and yellow basket'.length
+ ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` soll den String `A-tisket a-tasket A green and yellow basket` zurückgeben.
+
+```js
+assert(
+ truncateString(
+ 'A-tisket a-tasket A green and yellow basket',
+ 'A-tisket a-tasket A green and yellow basket'.length + 2
+ ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-", 1)` soll den String `A...` zurückgeben.
+
+```js
+assert(truncateString('A-', 1) === 'A...');
+```
+
+`truncateString("Absolutely Longer", 2)` soll den String `Ab...` zurückgeben.
+
+```js
+assert(truncateString('Absolutely Longer', 2) === 'Ab...');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truncateString(str, num) {
+ return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
+
+# --solutions--
+
+```js
+function truncateString(str, num) {
+ if (num >= str.length) {
+ return str;
+ }
+
+ return str.slice(0, num) + '...';
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
new file mode 100644
index 00000000000..b1e02f2c56d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
@@ -0,0 +1,143 @@
+---
+id: a24c1a4622e3c05097f71d67
+title: Where do I Belong
+challengeType: 1
+forumTopicId: 16094
+dashedName: where-do-i-belong
+---
+
+# --description--
+
+Gib den niedrigsten Index zurück, bei dem ein Wert (zweites Argument) in ein Array (erstes Argument) eingefügt werden sollte, nachdem es sortiert wurde. Der zurückgegebene Wert sollte eine Zahl sein.
+
+Zum Beispiel sollte `getIndexToIns([1,2,3,4], 1.5)` den Wert `1` zurückgeben, weil es größer als `1` (Index 0) ist, aber kleiner als `2` (Index 1).
+
+Ebenso sollte `getIndexToIns([20,3,5], 19)` den Wert `2` zurückgeben, denn wenn der Array geordnet ist, sieht er wie `[3,5,20]` aus und `19` ist weniger als `20` (Index 2) und größer als `5` (Index 1).
+
+# --hints--
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` sollte `3` zurückgeben.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number');
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` sollte `2` zurückgeben.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number');
+```
+
+`getIndexToIns([40, 60], 50)` sollte `1` zurückgeben.
+
+```js
+assert(getIndexToIns([40, 60], 50) === 1);
+```
+
+`getIndexToIns([40, 60], 50)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([40, 60], 50) === 'number');
+```
+
+`getIndexToIns([3, 10, 5], 3)` sollte `0` zurückgeben.
+
+```js
+assert(getIndexToIns([3, 10, 5], 3) === 0);
+```
+
+`getIndexToIns([3, 10, 5], 3)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([3, 10, 5], 3) === 'number');
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` soll `2` zurückgeben.
+
+```js
+assert(getIndexToIns([5, 3, 20, 3], 5) === 2);
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number');
+```
+
+`getIndexToIns([2, 20, 10], 19)` soll `2` zurückgeben.
+
+```js
+assert(getIndexToIns([2, 20, 10], 19) === 2);
+```
+
+`getIndexToIns([2, 20, 10], 19)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([2, 20, 10], 19) === 'number');
+```
+
+`getIndexToIns([2, 5, 10], 15)` soll `3` zurückgeben.
+
+```js
+assert(getIndexToIns([2, 5, 10], 15) === 3);
+```
+
+`getIndexToIns([2, 5, 10], 15)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([2, 5, 10], 15) === 'number');
+```
+
+`getIndexToIns([], 1)` soll `0` zurückgeben.
+
+```js
+assert(getIndexToIns([], 1) === 0);
+```
+
+`getIndexToIns([], 1)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([], 1) === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getIndexToIns(arr, num) {
+ return num;
+}
+
+getIndexToIns([40, 60], 50);
+```
+
+# --solutions--
+
+```js
+function getIndexToIns(arr, num) {
+ arr = arr.sort((a, b) => a - b);
+
+ for (let i = 0; i < arr.length; i++) {
+ if (arr[i] >= num) {
+ return i;
+ }
+ }
+
+ return arr.length;
+}
+
+getIndexToIns([40, 60], 50);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
new file mode 100644
index 00000000000..f23fdf384c4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
@@ -0,0 +1,82 @@
+---
+id: 5a661e0f1068aca922b3ef17
+title: Auf den Inhalt eines Arrays mit der Klammernotation zugreifen
+challengeType: 1
+forumTopicId: 301149
+dashedName: access-an-arrays-contents-using-bracket-notation
+---
+
+# --description--
+
+Die grundlegende Eigenschaft jeder Datenstruktur ist natürlich die Fähigkeit, nicht nur Daten zu speichern, sondern diese Daten auch auf Befehl abrufen zu können. Nachdem wir nun gelernt haben, wie man ein Array erstellt, wollen wir uns überlegen, wie wir auf die Informationen in diesem Array zugreifen können.
+
+Wenn wir ein einfaches Array wie unten definieren, sind darin 3 Elemente enthalten:
+
+```js
+let ourArray = ["a", "b", "c"];
+```
+
+In einem Array hat jedes Array-Element einen Index . Dieser Index verweist zum einen auf die Position des jeweiligen Elements innerhalb des Arrays, zum anderen kann es über ihn referenziert werden. Dabei ist zu beachten, dass JavaScript-Arrays nullbasiert indiziert sind, d. h. das erste Element eines Arrays befindet sich eigentlich an der ***nullten*** Position, nicht der ersten. Um ein Element aus einem Array abzurufen, können wir einen Index in eckige Klammern schreiben und ihn an das Ende eines Arrays hängen, oder noch häufiger, an eine Variable, die ein Array-Objekt referenziert. Diese Schreibweise nennt man Klammernotation . Wenn wir beispielsweise das `a` aus `ourArray` abrufen möchten, um es einer Variablen zuzuweisen, können wir das mit folgendem Code tun:
+
+```js
+let ourVariable = ourArray[0];
+```
+
+Nun enthält `ourVariable` den Wert `a`.
+
+Neben dem Zugreifen auf einen Wert, der mit einem Index assoziiert ist, ermöglicht dir diese Notation auch das *Setzen* eines Wertes über einen Index:
+
+```js
+ourArray[1] = "not b anymore";
+```
+
+Mit der Klammernotation haben wir nun das Element am Index 1 mit dem String `b` durch `not b anymore` ersetzt. `ourArray` enthält nun `["a", "not b anymore", "c"]`.
+
+# --instructions--
+
+Um diese Aufgabe abzuschließen, setze die zweite Position (Index `1`) von `myArray` auf einen Wert deiner Wahl, ausgenommen dem Buchstaben `b`.
+
+# --hints--
+
+`myArray[0]` sollte gleich dem Buchstaben `a` sein
+
+```js
+assert.strictEqual(myArray[0], 'a');
+```
+
+`myArray[1]` sollte nicht gleich dem Buchstaben `b` sein
+
+```js
+assert.notStrictEqual(myArray[1], 'b');
+```
+
+`myArray[2]` sollte gleich dem Buchstaben `c` sein
+
+```js
+assert.strictEqual(myArray[2], 'c');
+```
+
+`myArray[3]` sollte gleich dem Buchstaben `d` sein
+
+```js
+assert.strictEqual(myArray[3], 'd');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+// Only change code below this line
+
+// Only change code above this line
+console.log(myArray);
+```
+
+# --solutions--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+myArray[1] = "e";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
new file mode 100644
index 00000000000..655b6657d9f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b1a
+title: Zugriff auf Eigenschaftsnamen mit der Klammernotation
+challengeType: 1
+forumTopicId: 301150
+dashedName: access-property-names-with-bracket-notation
+---
+
+# --description--
+
+In der ersten Aufgabe zu Objekten haben wir erwähnt, dass die Klammernotation eine Möglichkeit bietet, auf Eigenschaftswerte zuzugreifen, indem eine Variable ausgewertet wird. Stell dir zum Beispiel vor, unser `foods` Objekt wird in einem Programm für eine Supermarktkasse verwendet. Wir haben eine Funktion, die `selectedFood` festlegt und wir möchten überprüfen, ob es im Objekt `foods` vorhanden ist. Dies könnte so aussehen:
+
+```js
+let selectedFood = getCurrentFood(scannedItem);
+let inventory = foods[selectedFood];
+```
+
+Dieser Code wird den in der Variable `selectedFood` gespeicherten Schlüsselwert auswerten und dann den entsprechenden Wert zu diesem Schlüssel aus dem Objekt `foods` ausgeben oder `undefined` falls er nicht vorhanden ist. Die Klammernotation ist sehr nützlich, weil Objekteigenschaften vor der Laufzeit manchmal unbekannt sind oder dynamischer auf sie zugegriffen werden muss.
+
+# --instructions--
+
+Wir haben eine Funktion namens `checkInventory` definiert, die ein gescanntes Produkt als ein Argument erhält. Gib den aktuellen Wert zum `scannedItem` Schlüssel des `foods` Objekts zurück. Du kannst davon ausgehen, dass nur gültige Schlüssel als ein Argument an `checkInventory` übergeben werden.
+
+# --hints--
+
+`checkInventory` sollte eine Funktion sein.
+
+```js
+assert.strictEqual(typeof checkInventory, 'function');
+```
+
+Das `foods` Objekt sollte nur die folgenden Schlüssel-Wert-Paare enthalten: `apples: 25`, `oranges: 32`, `plums: 28`, `bananas: 13`, `grapes: 35`, `strawberries: 27`.
+
+```js
+assert.deepEqual(foods, {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+});
+```
+
+`checkInventory("apples")` sollte `25` zurückgeben.
+
+```js
+assert.strictEqual(checkInventory('apples'), 25);
+```
+
+`checkInventory("bananas")` sollte `13` zurückgeben.
+
+```js
+assert.strictEqual(checkInventory('bananas'), 13);
+```
+
+`checkInventory("strawberries")` sollte `27` zurückgeben.
+
+```js
+assert.strictEqual(checkInventory('strawberries'), 27);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(checkInventory("apples"));
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+ return foods[scannedItem];
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
new file mode 100644
index 00000000000..d42adcdca49
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b0e
+title: Füge Elemente mit push() und unshift() einem Array hinzu
+challengeType: 1
+forumTopicId: 301151
+dashedName: add-items-to-an-array-with-push-and-unshift
+---
+
+# --description--
+
+Die Länge eines Arrays ist, wie die Datentypen, die es enthalten kann, nicht festgelegt. Arrays können mit einer beliebigen Anzahl von Elementen definiert werden, und Elemente können im Laufe der Zeit hinzugefügt oder entfernt werden; mit anderen Worten, Arrays sind veränderlich (mutable) . In dieser Aufgabe werden wir uns zwei Methoden ansehen, mit denen wir ein Array programmatisch verändern können: `Array.push()` und `Array.unshift()`.
+
+Beide Methoden nehmen ein oder mehrere Elemente als Parameter entgegen und fügen diese Elemente dem Array hinzu, auf dem die Methode aufgerufen wird; die Methode `push()` fügt Elemente am Ende eines Arrays hinzu und `unshift()` fügt Elemente am Anfang hinzu. Beachte Folgendes:
+
+```js
+let twentyThree = 'XXIII';
+let romanNumerals = ['XXI', 'XXII'];
+
+romanNumerals.unshift('XIX', 'XX');
+```
+
+`romanNumerals` würde den Wert `['XIX', 'XX', 'XXI', 'XXII']` haben.
+
+```js
+romanNumerals.push(twentyThree);
+```
+
+`romanNumerals` würde den Wert `['XIX', 'XX', 'XXI', 'XXII', 'XXIII']` haben. Beachte, dass wir auch Variablen übergeben können, was uns noch mehr Flexibilität bei der dynamischen Änderung unserer Array-Daten ermöglicht.
+
+# --instructions--
+
+Wir haben eine Funktion definiert, `mixedNumbers`, der wir ein Array als Argument übergeben. Ändere die Funktion, indem du `push()` und `unshift()` verwendest, um `'I', 2, 'three'` am Anfang des Arrays und `7, 'VIII', 9` am Ende hinzuzufügen, sodass das zurückgegebene Array Darstellungen der Zahlen 1-9 in der Reihenfolge enthält.
+
+# --hints--
+
+`mixedNumbers(["IV", 5, "six"])` sollte jetzt `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]` zurückgeben.
+
+```js
+assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [
+ 'I',
+ 2,
+ 'three',
+ 'IV',
+ 5,
+ 'six',
+ 7,
+ 'VIII',
+ 9
+]);
+```
+
+Die Funktion `mixedNumbers` sollte die Methode `push()` verwenden.
+
+```js
+assert(mixedNumbers.toString().match(/\.push/));
+```
+
+Die Funktion `mixedNumbers` sollte die Methode `unshift()` verwenden.
+
+```js
+assert(mixedNumbers.toString().match(/\.unshift/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mixedNumbers(arr) {
+ // Only change code below this line
+
+ // Only change code above this line
+ return arr;
+}
+
+console.log(mixedNumbers(['IV', 5, 'six']));
+```
+
+# --solutions--
+
+```js
+function mixedNumbers(arr) {
+ arr.push(7,'VIII',9);
+ arr.unshift('I',2,'three');
+ return arr;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
new file mode 100644
index 00000000000..634fcbdb5cb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
@@ -0,0 +1,93 @@
+---
+id: 587d78b3367417b2b2512b11
+title: Füge Elemente mit der splice() Methode hinzu
+challengeType: 1
+forumTopicId: 301152
+dashedName: add-items-using-splice
+---
+
+# --description--
+
+Kannst du dich an die letzte Herausforderung erinnern, in der wir erwähnten, dass `splice()` bis zu drei Parameter aufnehmen kann? Nun, du kannst den dritten Parameter, welcher aus einem oder mehreren Element(en) besteht, dem Array hinzufügen. Das kann unglaublich nützlich sein, um schnell ein Element oder ein Satz an Elementen für ein anderes auszutauschen.
+
+```js
+const numbers = [10, 11, 12, 12, 15];
+const startIndex = 3;
+const amountToDelete = 1;
+
+numbers.splice(startIndex, amountToDelete, 13, 14);
+console.log(numbers);
+```
+
+Das zweite Auftreten von `12` wird entfernt und wir fügen `13` und `14` an den gleichen Index hinzu. Der `numbers` Array würde jetzt `[ 10, 11, 12, 13, 14, 15 ]` sein.
+
+Hier starten wir mit einem Zahlen-Array. Anschließend übergeben wir Folgendes an `splice()`: Der Index, mit dem Elemente gelöscht werden sollen (3), die Anzahl der zu löschenden Elemente (1), und die verbleibenden Argumente (13, 14) werden am selben Index beginnend eingefügt. Beachte, dass es beliebig viele Elemente geben kann (durch Kommata getrennt), welche dem `amountToDelete` folgen, von denen jedes eingefügt wird.
+
+# --instructions--
+
+Wir haben eine Funktion `htmlColorNames` definiert, die ein Array aus HTML-Farben als Argument verwendet. Ändere die Funktion, indem du `splice()` benutzt, um die ersten zwei Elemente des Arrays zu entfernen und um `'DarkSalmon'` und `'BlanchedAlmond'` an ihre jeweiligen Stellen hinzuzufügen.
+
+# --hints--
+
+`htmlColorNames` sollte `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurquoise", "FireBrick"]` zurückgeben.
+
+```js
+assert.deepEqual(
+ htmlColorNames([
+ 'DarkGoldenRod',
+ 'WhiteSmoke',
+ 'LavenderBlush',
+ 'PaleTurquoise',
+ 'FireBrick'
+ ]),
+ [
+ 'DarkSalmon',
+ 'BlanchedAlmond',
+ 'LavenderBlush',
+ 'PaleTurquoise',
+ 'FireBrick'
+ ]
+);
+```
+
+Die Funktion `htmlColorNames` sollte die Methode `splice()` verwenden.
+
+```js
+assert(/.splice/.test(code));
+```
+
+Du solltest nicht`shift()` oder `unshift()` verwenden.
+
+```js
+assert(!/shift|unshift/.test(code));
+```
+
+Du solltest keine Array-Klammernotation verwenden.
+
+```js
+assert(!/\[\d\]\s*=/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function htmlColorNames(arr) {
+ // Only change code below this line
+
+ // Only change code above this line
+ return arr;
+}
+
+console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));
+```
+
+# --solutions--
+
+```js
+function htmlColorNames(arr) {
+ arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond');
+ return arr;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
new file mode 100644
index 00000000000..06ce6cdaf4f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
@@ -0,0 +1,124 @@
+---
+id: 587d7b7c367417b2b2512b18
+title: Hinzufügen von Schlüssel-Wert-Paaren zu JavaScript-Objekten
+challengeType: 1
+forumTopicId: 301153
+dashedName: add-key-value-pairs-to-javascript-objects
+---
+
+# --description--
+
+Im Grunde genommen sind Objekte nur Sammlungen von key-value- Paaren. Mit anderen Worten sind sie Teile von Daten (values ), die zu eindeutigen Identifikatoren namens properties zugeordnet sind (keys ). Schau dir ein Beispiel an:
+
+```js
+const tekkenCharacter = {
+ player: 'Hwoarang',
+ fightingStyle: 'Tae Kwon Doe',
+ human: true
+};
+```
+
+Der obere Code definiert ein Charakter-Objekt eines Tekken-Videospiels, das `tekkenCharacter` genannt wird. Es hat drei Eigenschaften, von denen jede einem bestimmten Wert zugeordnet wird. Wenn du eine zusätzliche Eigenschaft, wie z. B. "Herkunft", hinzufügen möchtest, kannst du dies tun, indem du dem Objekt `origin` zuweist:
+
+```js
+tekkenCharacter.origin = 'South Korea';
+```
+
+Dies verwendet Punktnotation. Wenn du das Objekt `tekkenCharacter` beobachten wolltest, so wird es jetzt die Eigenschaft `origin` enthalten. Hwoarang hatte auch deutlich orangefarbenes Haar. Du kannst diese Eigenschaft mit Klammernotation hinzufügen, indem du das Folgende tust:
+
+```js
+tekkenCharacter['hair color'] = 'dyed orange';
+```
+
+Klammernotation ist erforderlich, wenn deine Eigenschaft ein Leerzeichen hat oder wenn du eine Variable verwenden möchtest, um eine Eigenschaft zu benennen. Im obigen Fall ist die Eigenschaft in Anführungszeichen eingeschlossen, um sie als Zeichenfolge zu kennzeichnen, und wird genau wie gezeigt hinzugefügt. Ohne Anführungszeichen wird sie als Variable ausgewertet, und der Name der Eigenschaft ist der Wert, den die Variable hat. Hier ist ein Beispiel mit einer Variablen:
+
+```js
+const eyes = 'eye color';
+
+tekkenCharacter[eyes] = 'brown';
+```
+
+Nachdem man all die Beispiele hinzugefügt hat, wird das Objekt wie folgt aussehen:
+
+```js
+{
+ player: 'Hwoarang',
+ fightingStyle: 'Tae Kwon Doe',
+ human: true,
+ origin: 'South Korea',
+ 'hair color': 'dyed orange',
+ 'eye color': 'brown'
+};
+```
+
+# --instructions--
+
+Ein Objekt `foods` wurde mit drei Einträgen erstellt. Verwende die Syntax deiner Wahl und füge drei weitere Einträge hinzu: `bananas` mit einem Wert von `13`, `grapes` mit einem Wert von `35`, und `strawberries` mit einem Wert von `27`.
+
+# --hints--
+
+`foods` sollte ein Objekt sein.
+
+```js
+assert(typeof foods === 'object');
+```
+
+Das Objekt `foods` sollte einen Schlüssel `bananas` mit einem Wert von `13` haben.
+
+```js
+assert(foods.bananas === 13);
+```
+
+Das Objekt `foods` sollte einen Schlüssel `grapes` mit einem Wert von `35` haben.
+
+```js
+assert(foods.grapes === 35);
+```
+
+Das Objekt `foods` sollte einen Schlüssel `strawberries` mit einem Wert von `27` haben.
+
+```js
+assert(foods.strawberries === 27);
+```
+
+Die Schlüssel-Wert-Paare sollten mit Punkt- oder Klammernotation angegeben werden.
+
+```js
+assert(
+ code.search(/bananas:/) === -1 &&
+ code.search(/grapes:/) === -1 &&
+ code.search(/strawberries:/) === -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28
+};
+
+foods['bananas'] = 13;
+foods['grapes'] = 35;
+foods['strawberries'] = 27;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
new file mode 100644
index 00000000000..9934db6cfbd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b7b367417b2b2512b14
+title: Prüfe das Vorhandensein eines Elements mit indexOf()
+challengeType: 1
+forumTopicId: 301154
+dashedName: check-for-the-presence-of-an-element-with-indexof
+---
+
+# --description--
+
+Da Arrays jederzeit geändert oder *mutiert* werden können, gibt es keine Garantie dafür, wo sich ein bestimmtes Datenelement in einem bestimmten Array befindet, oder ob es überhaupt noch existiert. Zum Glück bietet uns JavaScript eine andere eingebaute Methode, `indexOf()`, welche es uns erlaubt, schnell und einfach das Vorhandensein eines Elements in einem Array zu überprüfen. `indexOf()` benötigt ein Element als Parameter und gibt beim Aufrufen die Position oder den Index des Elements wieder, oder `-1`, wenn das Element nicht im Array existiert.
+
+Zum Beispiel:
+
+```js
+let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
+
+fruits.indexOf('dates');
+fruits.indexOf('oranges');
+fruits.indexOf('pears');
+```
+
+`indexOf('dates')` gibt `-1` wieder, `indexOf('oranges')` gibt `2` wieder, und `indexOf('pears')` gibt `1` wieder (der erste Index, bei dem jedes Element existiert).
+
+# --instructions--
+
+`indexOf()` kann unglaublich nützlich für das schnelle Überprüfen zum Vorhandensein eines Elements in einem Array sein. Wir haben eine Funktion `quickCheck` definiert, welche einen Array und ein Element als Argumente benötigt. Ändere die Funktion, indem du `indexOf()` so benutzt, dass es `true` zurückgibt, wenn das übergebene Element im Array existiert, und `false`, wenn es nicht der Fall ist.
+
+# --hints--
+
+Die Funktion `quickCheck` sollte einen Boolean (`true` oder `false`) zurückgeben, keinen String (`"true"` oder `"false"`)
+
+```js
+assert.isBoolean(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+`quickCheck(["squash", "onions", "shallots"], "mushrooms")` sollte `false` zurückgeben
+
+```js
+assert.strictEqual(
+ quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'),
+ false
+);
+```
+
+`quickCheck(["onions", "squash", "shallots"], "onions")` sollte `true` zurückgeben
+
+```js
+assert.strictEqual(
+ quickCheck(['onions', 'squash', 'shallots'], 'onions'),
+ true
+);
+```
+
+`quickCheck([3, 5, 9, 125, 45, 2], 125)` sollte `true` zurückgeben
+
+```js
+assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true);
+```
+
+`quickCheck([true, false, false], undefined)` sollte `false` zurückgeben
+
+```js
+assert.strictEqual(quickCheck([true, false, false], undefined), false);
+```
+
+Die Funktion `quickCheck` sollte die Methode `indexOf()` verwenden
+
+```js
+assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function quickCheck(arr, elem) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+# --solutions--
+
+```js
+function quickCheck(arr, elem) {
+ return arr.indexOf(elem) >= 0;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
new file mode 100644
index 00000000000..071ded997bd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
@@ -0,0 +1,161 @@
+---
+id: 587d7b7d367417b2b2512b1c
+title: Prüfe ob ein Objekt eine Eigenschaft besitzt
+challengeType: 1
+forumTopicId: 301155
+dashedName: check-if-an-object-has-a-property
+---
+
+# --description--
+
+Jetzt können wir Schlüssel aus Objekten hinzufügen, verändern und entfernen. Aber was wäre, wenn wir nur wissen wollten, ob ein Objekt eine bestimmte Eigenschaft besitzt? JavaScript bietet uns zwei unterschiedliche Möglichkeiten an, dies zu tun. Eine benutzt die Methode `hasOwnProperty()` und die andere benutzt das Schlüsselwort `in`. Wenn wir ein Objekt `users` mit einer Eigenschaft von `Alan` haben, könnten wir sein Vorhandensein mit einem der folgenden Möglichkeiten überprüfen:
+
+```js
+users.hasOwnProperty('Alan');
+'Alan' in users;
+```
+
+Beide würden `true` zurückgeben.
+
+# --instructions--
+
+Schreibe die Funktion so zu Ende, dass sie `true` zurückgibt, wenn das übergebende Objekte alle vier Namen, `Alan`, `Jeff`, `Sarah` und `Ryan` enthält und ansonsten gibt sie `false` aus.
+
+# --hints--
+
+Das Objekt `users` sollte nicht direkt aufgerufen werden
+
+```js
+
+assert(code.match(/users/gm).length <= 2)
+
+```
+
+Das Objekt `users` sollte nur die Schlüssel `Alan`, `Jeff`, `Sarah`, und `Ryan` enthalten
+
+```js
+assert(
+ 'Alan' in users &&
+ 'Jeff' in users &&
+ 'Sarah' in users &&
+ 'Ryan' in users &&
+ Object.keys(users).length === 4
+);
+```
+
+Die Funktion `isEveryoneHere` sollte `true` zurückgeben, wenn `Alan`, `Jeff`, `Sarah`, und `Ryan` Eigenschaften sind, die an das Objekt übergeben wurden.
+
+```js
+assert(isEveryoneHere(users) === true);
+```
+
+Die Funktion `isEveryoneHere` sollte `false` zurückgeben, wenn `Alan` keine Eigenschaft ist, die an das Objekt weitergegeben wurde.
+
+```js
+assert(
+ (function () {
+ delete users.Alan;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+Die Funktion `isEveryoneHere` sollte `false` zurückgeben, wenn `Jeff` keine Eigenschaft davon ist, die an das Objekt übergeben wurde.
+
+```js
+assert(
+ (function () {
+ delete users.Jeff;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+Die Funktion `isEveryoneHere` sollte `false` zurückgeben, wenn `Sarah` keine Eigenschaft davon ist, die an das Objekt übergeben wurde.
+
+```js
+assert(
+ (function () {
+ delete users.Sarah;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+Die Funktion `isEveryoneHere` sollte `false` zurückgeben, wenn `Ryan` keine Eigenschaft ist, die an das Objekt übergeben wurde.
+
+```js
+assert(
+ (function () {
+ delete users.Ryan;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: true
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: true
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function isEveryoneHere(userObj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(isEveryoneHere(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: true
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: true
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function isEveryoneHere(userObj) {
+ return [
+ 'Alan',
+ 'Jeff',
+ 'Sarah',
+ 'Ryan'
+ ].every(user => userObj.hasOwnProperty(user));
+}
+
+console.log(isEveryoneHere(users));
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
new file mode 100644
index 00000000000..62e87906ba6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b7b367417b2b2512b17
+title: Kombiniere Arrays mit dem Spread-Operator
+challengeType: 1
+forumTopicId: 301156
+dashedName: combine-arrays-with-the-spread-operator
+---
+
+# --description--
+
+Ein anderer großer Vorteil des spread -Operators ist die Fähigkeit, Arrays zu kombinieren, oder um alle Elemente eines Arrays in ein anderes einzufügen, und zwar bei jedem Index. Mit traditionelleren Syntaxen können wir Arrays verketten, aber das erlaubt uns nur, Arrays am Ende eines Arrays und am Anfang eines anderen zu kombinieren. Die Spread-Syntax erleichtert den folgenden Vorgang erheblich:
+
+```js
+let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];
+
+let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
+```
+
+`thatArray` würde den Wert `['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']` besitzen.
+
+Mit der Spreadsyntax haben wir gerade eine Operation durchgeführt, die bei Verwendung herkömmlicher Methoden komplexer und ausführlicher gewesen wäre.
+
+# --instructions--
+
+Wir haben eine Funktion `spreadOut` definiert, welche die Variable `sentence` zurückgibt. Verändere die Funktion mit dem spread -Operator so, dass es den Array `['learning', 'to', 'code', 'is', 'fun']` zurückgibt.
+
+# --hints--
+
+`spreadOut` sollte `["learning", "to", "code", "is", "fun"]` zurückgeben
+
+```js
+assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']);
+```
+
+Die Funktion `spreadOut` sollte die Spread-Syntax verwenden
+
+```js
+assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spreadOut() {
+ let fragment = ['to', 'code'];
+ let sentence; // Change this line
+ return sentence;
+}
+
+console.log(spreadOut());
+```
+
+# --solutions--
+
+```js
+function spreadOut() {
+ let fragment = ['to', 'code'];
+ let sentence = ['learning', ...fragment, 'is', 'fun'];
+ return sentence;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
new file mode 100644
index 00000000000..04024a1e8bc
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
@@ -0,0 +1,102 @@
+---
+id: 587d7b7b367417b2b2512b13
+title: Kopiere ein Array mit dem Spread-Operator
+challengeType: 1
+forumTopicId: 301157
+dashedName: copy-an-array-with-the-spread-operator
+---
+
+# --description--
+
+Während `slice()` es uns erlaubt, selektiv zu entscheiden, welche Elemente eines Arrays kopiert werden sollen, ermöglicht der neue spread operator von ES6 das einfache Kopieren *aller* Elemente eines Arrays, und zwar der Reihe nach, mit einer einfachen und gut lesbaren Syntax. Die Spread-Syntax sieht einfach so aus: `...`
+
+In der Praxis können wir den Spread-Operator nutzen, um einen Array wie folgt zu kopieren:
+
+```js
+let thisArray = [true, true, undefined, false, null];
+let thatArray = [...thisArray];
+```
+
+`thatArray` entspricht `[true, true, undefined, false, null]`. `thisArray` bleibt unverändert und `thatArray` enthält die gleichen Elemente wie `thisArray`.
+
+# --instructions--
+
+Wir haben eine Funktion `copyMachine` definiert, welche `arr` (ein Array) und `num` (eine Nummer) als Argumente benötigt. Die Funktion sollte einen neuen Array zurückgeben, der aus `num` Kopien von `arr` besteht. Wir haben die meiste Arbeit für dich getan, jedoch funktioniert es noch nicht ganz richtig. Verändere die Funktion, indem du Spread-Syntax verwendest, sodass es richtig funktioniert (Tipp: eine andere Methode, die wir bereits behandelt haben, könnte hier nützlich sein!).
+
+# --hints--
+
+`copyMachine([true, false, true], 2)` sollte `[[true, false, true], [true, false, true]]` zurückgeben
+
+```js
+assert.deepEqual(copyMachine([true, false, true], 2), [
+ [true, false, true],
+ [true, false, true]
+]);
+```
+
+`copyMachine([1, 2, 3], 5)` sollte `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]` zurückgeben
+
+```js
+assert.deepEqual(copyMachine([1, 2, 3], 5), [
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3]
+]);
+```
+
+`copyMachine([true, true, null], 1)` sollte `[[true, true, null]]` zurückgeben
+
+```js
+assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]);
+```
+
+`copyMachine(["it works"], 3)` sollte `[["it works"], ["it works"], ["it works"]]` zurückgeben
+
+```js
+assert.deepEqual(copyMachine(['it works'], 3), [
+ ['it works'],
+ ['it works'],
+ ['it works']
+]);
+```
+
+Die Funktion `copyMachine` sollte den `spread operator` mit einem Array `arr` verwenden
+
+```js
+assert(code.match(/\.\.\.arr/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function copyMachine(arr, num) {
+ let newArr = [];
+ while (num >= 1) {
+ // Only change code below this line
+
+ // Only change code above this line
+ num--;
+ }
+ return newArr;
+}
+
+console.log(copyMachine([true, false, true], 2));
+```
+
+# --solutions--
+
+```js
+function copyMachine(arr,num){
+ let newArr=[];
+ while(num >=1){
+ newArr.push([...arr]);
+ num--;
+ }
+ return newArr;
+}
+console.log(copyMachine([true, false, true], 2));
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
new file mode 100644
index 00000000000..aad146b3638
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
@@ -0,0 +1,65 @@
+---
+id: 587d7b7a367417b2b2512b12
+title: Kopiere Array-Elemente mit der slice() - Methode
+challengeType: 1
+forumTopicId: 301158
+dashedName: copy-array-items-using-slice
+---
+
+# --description--
+
+Die nächste Methode, mit der wir uns beschäftigen ist `slice()`. Anstatt einen Array zu verändern, kopiert oder *extrahiert* `slice()` eine bestimmte Anzahl an Elementen in einen neuen Array, sodass der aufgerufene Array unverändert bleibt. `slice()` benötigt nur 2 Parameter -- der erste ist der Index, an welchem die Extraktion beginnen soll, und der zweite ist der Index, an welchem die Extraktion gestoppt werden soll (die Extraktion wird bis zum Ende auftreten, jedoch ohne das Element an diesem Index). Beachte Folgendes:
+
+```js
+let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
+
+let todaysWeather = weatherConditions.slice(1, 3);
+```
+
+`todaysWeather` würde den Wert `['snow', 'sleet']` haben, während `weatherConditions` immer noch `['rain', 'snow', 'sleet', 'hail', 'clear']` hat.
+
+Wir haben in der Tat einen neuen Array erstellt, indem wir Elemente aus einem bestehenden Array extrahiert haben.
+
+# --instructions--
+
+Wir haben eine Funktion `forecast` definiert, die einen Array als ein Argument verwendet. Verändere die Funktion mit `slice()`, um Informationen aus dem Argument-Array zu extrahieren und einen neuen Array mit den String-Elementen `warm` und `sunny` zurückzugeben.
+
+# --hints--
+
+`forecast` sollte `["warm", "sunny"]` zurückgeben
+
+```js
+assert.deepEqual(
+ forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']),
+ ['warm', 'sunny']
+);
+```
+
+Die Funktion `forecast` sollte die `slice()` Methode verwenden
+
+```js
+assert(/\.slice\(/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function forecast(arr) {
+ // Only change code below this line
+
+ return arr;
+}
+
+// Only change code above this line
+console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
+```
+
+# --solutions--
+
+```js
+function forecast(arr) {
+ return arr.slice(2,4);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
new file mode 100644
index 00000000000..c7a7315f806
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
@@ -0,0 +1,218 @@
+---
+id: 587d7b7b367417b2b2512b16
+title: Erstelle komplexe mehrdimensionale Arrays
+challengeType: 1
+forumTopicId: 301159
+dashedName: create-complex-multi-dimensional-arrays
+---
+
+# --description--
+
+Großartig! Du hast gerade eine Menge über Arrays gelernt! Das war ein relativ großer Überblick, und es gibt viel mehr über die Arbeit mit Arrays zu lernen, vieles, was wir uns in späteren Abschnitten ansehen werden. Bevor wir uns aber mit Objects beschäftigen, schauen wir uns noch einmal an, wie Arrays etwas komplexer als in den bisherigen Aufgaben werden können.
+
+Eines der mächtigsten Merkmale bei der Betrachtung von Arrays als Datastrukturen, ist, dass Arrays andere Arrays enthalten oder sogar komplett aus anderen bestehen können. Wir haben bereits in bisherigen Aufgaben Arrays gesehen, die selbst Arrays enthalten – aber nur recht einfache. Arrays können jedoch eine unendliche Tiefe von Arrays enthalten, die wiederum andere Arrays enthalten können, jeweils mit einer bestimmten Tiefe, und so weiter. Auf diese Weise kann ein Array sehr schnell zu einer sehr komplexen Datenstruktur werden, die als multi-dimensional oder verschachteltes Array bekannt ist. Beachte das folgende Beispiel:
+
+```js
+let nestedArray = [
+ ['deep'],
+ [
+ ['deeper'], ['deeper']
+ ],
+ [
+ [
+ ['deepest'], ['deepest']
+ ],
+ [
+ [
+ ['deepest-est?']
+ ]
+ ]
+ ]
+];
+```
+
+Der `deep` Array ist in 2 Ebenen verschachtelt. Die Arrays `deeper` sind 3 Ebenen tief. Die Arrays `deepest` sind 4 Ebenen und `deepest-est?` beträgt 5.
+
+Während dieses Beispiel sehr verworren erscheint, ist diese Ebene an Komplexität nicht unbekannt oder gar unüblich, wenn man mit großen Mengen an Daten arbeitet. Jedoch können wir immer noch sehr leicht auf die tiefsten Ebenen eines Arrays, der so komplex ist, mit Klammernotation zugreifen:
+
+```js
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+Dies protokolliert der String `deepest-est?`. Und jetzt, da wir wissen, wo die Daten sind, können wir sie zurücksetzen, wenn wir es brauchen:
+
+```js
+nestedArray[2][1][0][0][0] = 'deeper still';
+
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+Jetzt protokolliert es `deeper still`.
+
+# --instructions--
+
+Wir haben eine Variable `myNestedArray` definiert, die einem Array entspricht. Verändere `myNestedArray`, indem du irgendeine Kombination von strings , numbers , und booleans für Datenelemente verwendest, sodass es genau fünf Tiefenebenen hat (denk daran, der äußerste Array ist Ebene 1). Füge den String `deep` irgendwo auf der 3. Ebene ein, den String `deeper` auf der vierten Ebene und auf der fünften Ebene, füge den String `deepest` ein.
+
+# --hints--
+
+`myNestedArray` sollte nur Nummern, Booleans und Strings als Datenelemente enthalten
+
+```js
+assert.strictEqual(
+ (function (arr) {
+ let flattened = (function flatten(arr) {
+ const flat = [].concat(...arr);
+ return flat.some(Array.isArray) ? flatten(flat) : flat;
+ })(arr);
+ for (let i = 0; i < flattened.length; i++) {
+ if (
+ typeof flattened[i] !== 'number' &&
+ typeof flattened[i] !== 'string' &&
+ typeof flattened[i] !== 'boolean'
+ ) {
+ return false;
+ }
+ }
+ return true;
+ })(myNestedArray),
+ true
+);
+```
+
+`myNestedArray` sollte genau 5 Ebenen in die Tiefe haben
+
+```js
+assert.strictEqual(
+ (function (arr) {
+ let depth = 0;
+ function arrayDepth(array, i, d) {
+ if (Array.isArray(array[i])) {
+ arrayDepth(array[i], 0, d + 1);
+ } else {
+ depth = d > depth ? d : depth;
+ }
+ if (i < array.length) {
+ arrayDepth(array, i + 1, d);
+ }
+ }
+ arrayDepth(arr, 0, 0);
+ return depth;
+ })(myNestedArray),
+ 4
+);
+```
+
+`myNestedArray` sollte genau ein Auftreten der Strings `deep` in einen Array enthalten, der 3 Ebenen tief verschachtelt ist
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deep').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deep')[0] === 2
+);
+```
+
+`myNestedArray` sollte genau ein Auftreten der Strings `deeper` in einem Array enthalten, der 4 Ebenen tief verschachtelt ist
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deeper').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deeper')[0] === 3
+);
+```
+
+`myNestedArray` sollte genau ein Auftreten der Strings `deepest` in einem Array enthalten, der 5 Ebenen tief verschachtelt ist
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deepest').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deepest')[0] === 4
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myNestedArray = [
+ // Only change code below this line
+ ['unshift', false, 1, 2, 3, 'complex', 'nested'],
+ ['loop', 'shift', 6, 7, 1000, 'method'],
+ ['concat', false, true, 'spread', 'array'],
+ ['mutate', 1327.98, 'splice', 'slice', 'push'],
+ ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+ // Only change code above this line
+];
+```
+
+# --solutions--
+
+```js
+let myNestedArray = [
+ ['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'],
+ ['loop', 'shift', 6, 7, 1000, 'method'],
+ ['concat', false, true, 'spread', 'array'],
+ ['mutate', 1327.98, 'splice', 'slice', 'push'],
+ ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
new file mode 100644
index 00000000000..c57764f91de
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
@@ -0,0 +1,111 @@
+---
+id: 587d7b7d367417b2b2512b1e
+title: Erstelle einen Array aller Objekt-Schlüssel mit Object.keys()
+challengeType: 1
+forumTopicId: 301160
+dashedName: generate-an-array-of-all-object-keys-with-object-keys
+---
+
+# --description--
+
+Wir können auch mit der `Object.keys()` Methode einen Array erzeugen, der alle Schlüssel in einem Objekt enthält. Diese Methode nimmt ein Objekt als Argument und gibt ein Array von Strings zurück, die jede Eigenschaft des Objekts darstellen. Auch hier gibt es keine bestimmte Reihenfolge der Einträge im Array.
+
+# --instructions--
+
+Schreibe die Funktion `getArrayOfUsers` fertig, so dass sie ein Array mit allen Eigenschaften des Objekts zurückgibt, das sie als Argument erhält.
+
+# --hints--
+
+Das Objekt `users` sollte nur die Schlüssel `Alan`, `Jeff`, `Sarah`, und `Ryan` enthalten
+
+```js
+assert(
+ 'Alan' in users &&
+ 'Jeff' in users &&
+ 'Sarah' in users &&
+ 'Ryan' in users &&
+ Object.keys(users).length === 4
+);
+```
+
+Die Funktion `getArrayOfUsers` sollte einen Array, welcher alle Schlüssel des Objekts `users` enthält, zurückgeben
+
+```js
+assert(
+ (function () {
+ users.Sam = {};
+ users.Lewis = {};
+ let R = getArrayOfUsers(users);
+ return (
+ R.indexOf('Alan') !== -1 &&
+ R.indexOf('Jeff') !== -1 &&
+ R.indexOf('Sarah') !== -1 &&
+ R.indexOf('Ryan') !== -1 &&
+ R.indexOf('Sam') !== -1 &&
+ R.indexOf('Lewis') !== -1
+ );
+ })() === true
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: false
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: false
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function getArrayOfUsers(obj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(getArrayOfUsers(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: false
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: false
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function getArrayOfUsers(obj) {
+ return Object.keys(obj);
+}
+
+console.log(getArrayOfUsers(users));
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
new file mode 100644
index 00000000000..40062758157
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
@@ -0,0 +1,138 @@
+---
+id: 587d7b7b367417b2b2512b15
+title: Wiederholung durch alle Elemente eines Arrays mit For-Schleifen
+challengeType: 1
+forumTopicId: 301161
+dashedName: iterate-through-all-an-arrays-items-using-for-loops
+---
+
+# --description--
+
+Bei der Arbeit mit Arrays ist es manchmal sehr praktisch, wenn man durch jedes Element iterieren kann, um ein oder mehrere Elemente zu finden, die man braucht, oder um ein Array auf der Grundlage der Datenelemente, die bestimmte Kriterien erfüllen, zu bearbeiten. JavaScript bietet mehrere eingebaute Methoden, die jeweils auf leicht unterschiedliche Weise über Arrays iterieren, um unterschiedliche Ergebnisse zu erzielen (sowie `every()`, `forEach()`, `map()`, etc.), die Technik jedoch, die am flexibelsten ist und uns die größte Kontrolle bietet, ist eine einfache `for`-Schleife.
+
+Beachte Folgendes:
+
+```js
+function greaterThanTen(arr) {
+ let newArr = [];
+ for (let i = 0; i < arr.length; i++) {
+ if (arr[i] > 10) {
+ newArr.push(arr[i]);
+ }
+ }
+ return newArr;
+}
+
+greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
+```
+
+Wenn man eine `for` -Schleife verwendet, durchläuft und greift diese Funktion auf jedes Element des Arrays zu, und unterzieht es einem einfachen Test, den wir erstellt haben. Auf diese Weise haben wir einfach und programmatisch ermittelt, welche Datenelemente größer als `10` sind, und einen neuen Array, `[12, 14, 80]`, zurückgegeben, der diese Elemente enthält.
+
+# --instructions--
+
+Wir haben eine Funktion `filteredArray` definiert, welche einen verschachtelten Array `arr` und `elem` als Argumente benötigt und einen neuen Array zurückgibt. `elem` stellt ein Element dar, das auf einem oder mehreren Arrays, die in `arr` verschachtelt sind, vorhanden sein könnte. Verändere die Funktion, indem du eine `for`-Schleife verwendest, um eine gefilterte Version des übergebenden Arrays zurückzuerhalten, sodass jeder Array, der in `arr` verschachtelt ist und `elem` enthält, entfernt wurde.
+
+# --hints--
+
+`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` sollte `[[10, 8, 3], [14, 6, 23]]` zurückgeben
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ [10, 8, 3],
+ [14, 6, 23],
+ [3, 18, 6]
+ ],
+ 18
+ ),
+ [
+ [10, 8, 3],
+ [14, 6, 23]
+ ]
+);
+```
+
+`filteredArray([["trumpets", 2], ["flutes", 4], ["saxophones", 2]], 2)` sollte `[["flutes", 4]]` zurückgeben
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ ['trumpets', 2],
+ ['flutes', 4],
+ ['saxophones', 2]
+ ],
+ 2
+ ),
+ [['flutes', 4]]
+);
+```
+
+`filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter")` sollte `[["amy", "beth", "sam"]]` zurückgeben
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ ['amy', 'beth', 'sam'],
+ ['dave', 'sean', 'peter']
+ ],
+ 'peter'
+ ),
+ [['amy', 'beth', 'sam']]
+);
+```
+
+`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` sollte `[]` zurückgeben
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ [3, 2, 3],
+ [1, 6, 3],
+ [3, 13, 26],
+ [19, 3, 9]
+ ],
+ 3
+ ),
+ []
+);
+```
+
+Die Funktion `filteredArray` sollte eine `for`-Schleife verwenden
+
+```js
+assert.notStrictEqual(filteredArray.toString().search(/for/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function filteredArray(arr, elem) {
+ let newArr = [];
+ // Only change code below this line
+
+ // Only change code above this line
+ return newArr;
+}
+
+console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
+```
+
+# --solutions--
+
+```js
+function filteredArray(arr, elem) {
+ let newArr = [];
+ for (let i = 0; ifor...in-Anweisung genannt wird. Für unser `users` Objekt könnte es so aussehen:
+
+```js
+for (let user in users) {
+ console.log(user);
+}
+```
+
+Das würde `Alan`, `Jeff` und `Sarah` protokollieren - jeder Wert in einer eigenen Zeile.
+
+In dieser Anweisung haben wir eine Variable `user` definiert, und wie du sehen kannst, wurde diese Variable bei jeder Iteration auf jeden der Schlüssel des Objekts zurückgesetzt, während die Anweisung das Objekt in einer Schleife durchlief, was dazu führte, dass der Name jedes Benutzers auf der Konsole ausgegeben wurde.
+
+**HINWEIS:** Objekte behalten keine Reihenfolge der gespeicherten Schlüssel bei, wie es bei Arrays der Fall ist; daher ist die Position eines Schlüssels auf einem Objekt oder die relative Reihenfolge, in der er erscheint, irrelevant, wenn auf diesen Schlüssel verwiesen oder zugegriffen wird.
+
+# --instructions--
+
+Wir haben eine Funktion `countOnline` definiert, die ein Argument (ein Nutzer-Objekt) akzeptiert. Nutze eine for...in Anweisung innerhalb dieser Funktion, um eine Schleife durch das an die Funktion übergebene Benutzerobjekt zu durchlaufen und die Anzahl der Nutzer zurückzugeben, deren `online` Eigenschaft auf `true` festgesetzt ist. Ein Beispiel für ein Benutzerobjekt, das an `countOnline` übergeben werden könnte, wird unten gezeigt. Jeder Nutzer wird eine `online` Eigenschaft mit entweder einem `true` oder `false` Wert besitzen.
+
+```js
+{
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: true
+ },
+ Sarah: {
+ online: false
+ }
+}
+```
+
+# --hints--
+
+Die Funktion `countOnline` sollte eine `for in` Anweisung verwenden, um die Objektschlüssel des übergebenen Objekts zu durchlaufen.
+
+```js
+assert(
+ code.match(
+ /for\s*\(\s*(var|let|const)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)/
+ )
+);
+```
+
+Die Funktion `countOnline` sollte `1` zurückgeben, wenn das Objekt `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` an ihn übergeben wurde
+
+```js
+assert(countOnline(usersObj1) === 1);
+```
+
+Die Funktion `countOnline` sollte `2` zurückgeben, wenn das Objekt `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` an ihn übergeben wurde
+
+```js
+assert(countOnline(usersObj2) === 2);
+```
+
+Die Funktion `countOnline` sollte `0` zurückgeben, wenn das Objekt `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` an ihn übergeben wurde
+
+```js
+assert(countOnline(usersObj3) === 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const usersObj1 = {
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: true
+ },
+ Sarah: {
+ online: false
+ }
+}
+
+const usersObj2 = {
+ Alan: {
+ online: true
+ },
+ Jeff: {
+ online: false
+ },
+ Sarah: {
+ online: true
+ }
+}
+
+
+const usersObj3 = {
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: false
+ },
+ Sarah: {
+ online: false
+ }
+}
+```
+
+## --seed-contents--
+
+```js
+const users = {
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: true
+ },
+ Sarah: {
+ online: false
+ }
+}
+
+function countOnline(usersObj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(countOnline(users));
+```
+
+# --solutions--
+
+```js
+function countOnline(usersObj) {
+ let online = 0;
+ for(let user in usersObj){
+ if(usersObj[user].online) {
+ online++;
+ }
+ }
+ return online;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
new file mode 100644
index 00000000000..1f15bf7ad71
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
@@ -0,0 +1,112 @@
+---
+id: 587d7b7d367417b2b2512b1f
+title: Ändere ein Array, das in einem Objekt gespeichert ist
+challengeType: 1
+forumTopicId: 301163
+dashedName: modify-an-array-stored-in-an-object
+---
+
+# --description--
+
+Jetzt hast du alle grundlegenden Operationen für JavaScript-Objekte kennengelernt. Du kannst Schlüssel-Wert-Paare hinzufügen, ändern und entfernen, prüfen, ob Schlüssel vorhanden sind, und über alle Schlüssel eines Objekts iterieren. Beim weiteren Erlernen von JavaScript, wirst du noch vielseitigere Anwendungen von Objekten kennenlernen. Zusätzlich werden in den Lektionen zu Datenstrukturen im Abschnitt Vorbereitung auf das Coding-Interview des Lehrplans auch die ES6-Objekte Map und Set behandelt, die normalen Objekten ähneln, jedoch einige zusätzliche Funktionen bieten. Da du nun die Grundlagen von Arrays und Objekten kennengelernt hast, bist du bestens vorbereitet, um komplexere Probleme mit JavaScript anzugehen!
+
+# --instructions--
+
+Schau dir das Objekt an, das wir im Code-Editor bereigestellt haben. Das `user` Objekt enthält drei Schlüssel. Der `data` Schlüssel enthält fünf Schlüssel, von denen einer ein Array von `friends` enthält. Daran kannst du erkennen, wie flexibel Objekte als Datenstrukturen sind. Wir haben begonnen, eine Funktion `addFriend` zu schreiben. Schließe sie so ab, dass sie ein `user` Objekt nimmt und den Namen des `friend` Arguments zu dem in `user.data.friends` gespeicherten Array hinzufügt und dieses Array zurückgibt.
+
+# --hints--
+
+Das `user` Objekt sollte `name`, `age` und `data` Schlüssel haben.
+
+```js
+assert('name' in user && 'age' in user && 'data' in user);
+```
+
+Die Funktion `addFriend` sollte ein `user`-Objekt und einen `friend` String als Argumente akzeptieren und den Freund zum Array der `friends` zum `user` Objekt hinzufügen.
+
+```js
+assert(
+ (function () {
+ let L1 = user.data.friends.length;
+ addFriend(user, 'Sean');
+ let L2 = user.data.friends.length;
+ return L2 === L1 + 1;
+ })()
+);
+```
+
+`addFriend(user, "Pete")` sollte `["Sam", "Kira", "Tomo", "Pete"]` zurückgeben.
+
+```js
+assert.deepEqual(
+ (function () {
+ delete user.data.friends;
+ user.data.friends = ['Sam', 'Kira', 'Tomo'];
+ return addFriend(user, 'Pete');
+ })(),
+ ['Sam', 'Kira', 'Tomo', 'Pete']
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let user = {
+ name: 'Kenneth',
+ age: 28,
+ data: {
+ username: 'kennethCodesAllDay',
+ joinDate: 'March 26, 2016',
+ organization: 'freeCodeCamp',
+ friends: [
+ 'Sam',
+ 'Kira',
+ 'Tomo'
+ ],
+ location: {
+ city: 'San Francisco',
+ state: 'CA',
+ country: 'USA'
+ }
+ }
+};
+
+function addFriend(userObj, friend) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(addFriend(user, 'Pete'));
+```
+
+# --solutions--
+
+```js
+let user = {
+ name: 'Kenneth',
+ age: 28,
+ data: {
+ username: 'kennethCodesAllDay',
+ joinDate: 'March 26, 2016',
+ organization: 'freeCodeCamp',
+ friends: [
+ 'Sam',
+ 'Kira',
+ 'Tomo'
+ ],
+ location: {
+ city: 'San Francisco',
+ state: 'CA',
+ country: 'USA'
+ }
+ }
+};
+
+function addFriend(userObj, friend) {
+ userObj.data.friends.push(friend);
+ return userObj.data.friends;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
new file mode 100644
index 00000000000..df804075520
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b19
+title: Ein in einem Objekt verschachteltes Objekt ändern
+challengeType: 1
+forumTopicId: 301164
+dashedName: modify-an-object-nested-within-an-object
+---
+
+# --description--
+
+Werfen wir nun einen Blick auf ein etwas komplexeres Objekt. Objekteigenschaften können beliebig tief verschachtelt werden und ihre Werte können jede Art von Daten sein, die von JavaScript unterstützt werden, einschließlich Arrays und sogar andere Objekte. Beachte Folgendes:
+
+```js
+let nestedObject = {
+ id: 28802695164,
+ date: 'December 31, 2016',
+ data: {
+ totalUsers: 99,
+ online: 80,
+ onlineStatus: {
+ active: 67,
+ away: 13,
+ busy: 8
+ }
+ }
+};
+```
+
+`nestedObject` hat drei Eigenschaften: `id` (Wert ist eine Zahl), `date` (Wert ist ein String) und `data` (Wert ist ein Objekt mit verschachtelter Struktur). Obwohl Strukturen schnell komplex werden können, können wir immer noch die gleichen Notationen verwenden, um auf die benötigten Informationen zuzugreifen. Um den Wert `10` der Eigenschaft `busy` des verschachtelten Objekts `onlineStatus` zuzuweisen, verwenden wir die Punktnotation, um auf die Eigenschaft zu verweisen:
+
+```js
+nestedObject.data.onlineStatus.busy = 10;
+```
+
+# --instructions--
+
+Hier haben wir ein Objekt `userActivity` definiert, das ein weiteres, darin verschachteltes Objekt enthält. Setze den Wert des `online`-Schlüssels auf `45`.
+
+# --hints--
+
+`userActivity` sollte die Eigenschaften `id`, `date` und `data` haben.
+
+```js
+assert(
+ 'id' in userActivity && 'date' in userActivity && 'data' in userActivity
+);
+```
+
+`userActivity` sollte einen `data`-Schlüssel haben, der auf ein Objekt mit den Schlüsseln `totalUsers` und `online` gesetzt ist.
+
+```js
+assert('totalUsers' in userActivity.data && 'online' in userActivity.data);
+```
+
+Die `online`-Eigenschaft, die in den `data`-Schlüssel von `userActivity` verschachtelt ist, sollte auf `45` gesetzt werden
+
+```js
+assert(userActivity.data.online === 45);
+```
+
+Die `online` Eigenschaft sollte mit Punkt- oder Klammernotation gesetzt werden.
+
+```js
+assert.strictEqual(code.search(/online: 45/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let userActivity = {
+ id: 23894201352,
+ date: 'January 1, 2017',
+ data: {
+ totalUsers: 51,
+ online: 42
+ }
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(userActivity);
+```
+
+# --solutions--
+
+```js
+let userActivity = {
+ id: 23894201352,
+ date: 'January 1, 2017',
+ data: {
+ totalUsers: 51,
+ online: 42
+ }
+};
+
+userActivity.data.online = 45;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
new file mode 100644
index 00000000000..3947220b0f6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
@@ -0,0 +1,86 @@
+---
+id: 587d78b2367417b2b2512b0f
+title: Entfernen von Elementen aus einem Array mit pop() und shift()
+challengeType: 1
+forumTopicId: 301165
+dashedName: remove-items-from-an-array-with-pop-and-shift
+---
+
+# --description--
+
+Sowohl `push()` und `unshift()` verfügen über entsprechende Methoden, welche nahezu funktionale Gegensätze sind: `pop()` und `shift()`. Wie du vielleicht schon erraten hast, *entfernt* `pop()` ein Element vom Ende des Arrays anstatt es hinzuzufügen, während `shift()` ein Element vom Anfang entfernt. Der Hauptunterschied zwischen `pop()` und `shift()` und ihre Cousinen `push()` und `unshift()` ist, dass keine Methode Parameter benötigt und jede nur einen Array erlaubt, dass dieser von einem einzelnen Element gleichzeitig verändert werden kann.
+
+Schauen wir uns das mal an:
+
+```js
+let greetings = ['whats up?', 'hello', 'see ya!'];
+
+greetings.pop();
+```
+
+`greetings` hätte den Wert `['whats up?', 'hello']`.
+
+```js
+greetings.shift();
+```
+
+`greetings` hätte den Wert `['hello']`.
+
+Wir können den Wert eines entfernten Elements auch mit einer der folgenden Methoden ausgeben:
+
+```js
+let popped = greetings.pop();
+```
+
+`greetings` hätte den Wert `[]` und `popped` hätte den Wert `hello`.
+
+# --instructions--
+
+Wir haben die Funktion `popShift` definiert, die ein Array als Argument nimmt und ein neues Array ausgibt. Verändere die Funktion, indem du `pop()` und `shift()` verwendest, um das erste und das letzte Element des Argumentationsarrays zu entfernen, und weise die entfernten Elemente zu deren passenden Variablen, sodass das ausgegebene Array deren Werte enthält.
+
+# --hints--
+
+`popShift(["challenge", "is", "not", "complete"])` soll `["challenge", "complete"]` ausgeben
+
+```js
+assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [
+ 'challenge',
+ 'complete'
+]);
+```
+
+Die Funktion `popShift` soll die Methode `pop()` verwenden
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1);
+```
+
+Die Funktion`popShift` soll die Methode `shift()` verwenden
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function popShift(arr) {
+ let popped; // Change this line
+ let shifted; // Change this line
+ return [shifted, popped];
+}
+
+console.log(popShift(['challenge', 'is', 'not', 'complete']));
+```
+
+# --solutions--
+
+```js
+function popShift(arr) {
+ let popped = arr.pop(); // Change this line
+ let shifted = arr.shift(); // Change this line
+ return [shifted, popped];
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
new file mode 100644
index 00000000000..851850a4c32
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b10
+title: Entferne Elemente mit Hilfe der splice() - Methode
+challengeType: 1
+forumTopicId: 301166
+dashedName: remove-items-using-splice
+---
+
+# --description--
+
+Ok, wir haben nun gelernt, wie man Elemente vom Beginn und vom Ende eines Arrays mittels `shift()` und `pop()` entfernt, aber was passiert, wenn wir ein Element von irgendwo in der Mitte entfernen möchten? Oder mehr als ein Element auf einmal entfernen wollen? Nun, hier kommt `splice()` ins Spiel. Mit `splice()` können wir genau das tun: eine **beliebige Anzahl aufeinander folgender Elemente** von einer beliebigen Stelle in einem Array entfernen.
+
+`splice()` kann bis zu drei Parameter aufgreifen, aber vorerst fokussieren wir uns nur auf die ersten beiden. Die ersten beiden Parameter von `splice()` sind ganze Zahlen, die Indizes oder Positionen der Elemente im Array darstellen, die von `splice()` aufgerufen werden. Und denke daran, Arrays sind *null-indiziert*. Um das erste Element eines Arrays auszugeben, müssen wir `0` verwenden. Der erste Parameter von `splice()` stellt den Index des Arrays dar, aus dem Elemente entfernt werden sollen, während der zweite Parameter die Anzahl der zu löschenden Elemente angibt. Zum Beispiel:
+
+```js
+let array = ['today', 'was', 'not', 'so', 'great'];
+
+array.splice(2, 2);
+```
+
+Hier entfernen wir 2 Elemente, beginnend mit dem dritten Element (bei Index 2). `array` hätte den Wert `['today', 'was', 'great']`.
+
+`splice()` verändert nicht nur das Array, auf das es sich bezieht, sondern gibt auch ein neues Array aus, das den Wert des entfernten Elements enthält:
+
+```js
+let array = ['I', 'am', 'feeling', 'really', 'happy'];
+
+let newArray = array.splice(3, 2);
+```
+
+`newArray` hat den Wert `['really', 'happy']`.
+
+# --instructions--
+
+Wir haben das neue Array `arr` erstellt. Verwende `splice()`, um Elemente aus `arr` zu entfernen, sodass es nur Elemente enthält, deren Summe den Wert `10` ergibt.
+
+# --hints--
+
+Du sollst nicht die ursprüngliche Codezeile `const arr = [2, 4, 5, 1, 7, 5, 2, 1];` ändern.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/constarr=\[2,4,5,1,7,5,2,1\];?/)
+);
+```
+
+`arr` soll nur Elemente enthalten, deren Summe `10` ergibt.
+
+```js
+assert.strictEqual(
+ arr.reduce((a, b) => a + b),
+ 10
+);
+```
+
+Ihr Code sollte die Methode `splice()` auf `arr` anwenden.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/arr\.splice\(/));
+```
+
+Splice soll nur Elemente aus `arr` entfernen, aber keine zusätzlichen Elemente zu `arr` hinzufügen.
+
+```js
+assert(
+ !__helpers.removeWhiteSpace(code).match(/arr\.splice\(\d+,\d+,\d+.*\)/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+// Only change code below this line
+
+// Only change code above this line
+console.log(arr);
+```
+
+# --solutions--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+arr.splice(1, 4);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
new file mode 100644
index 00000000000..e95132f6eb7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
@@ -0,0 +1,95 @@
+---
+id: 587d7b7e367417b2b2512b20
+title: Verwende ein Array, um eine Sammlung von Daten zu speichern
+challengeType: 1
+forumTopicId: 301167
+dashedName: use-an-array-to-store-a-collection-of-data
+---
+
+# --description--
+
+Unten ist ein Beispiel für die einfachste Implementierung einer Array-Datenstruktur. Dies ist als eindimensionales Array bekannt und bedeutet, dass es nur eine Ebene hat oder dass keine anderen Arrays in ihm verschachtelt sind. Beachte, dass sie Booleans , Strings und Zahlen enthält, neben anderen gültigen JavaScript-Datentypen:
+
+```js
+let simpleArray = ['one', 2, 'three', true, false, undefined, null];
+console.log(simpleArray.length);
+```
+
+Der `console.log`-Aufruf zeigt `7` an.
+
+Alle Arrays haben eine Längeneigenschaft, die, wie oben gezeigt, sehr einfach mit der Syntax `Array.length` abgerufen werden kann. Eine komplexere Implementierung eines Arrays ist im Folgenden zu sehen. Dies wird als mehrdimensionales Array bezeichnet, oder ein Array, das andere Arrays enthält. Beachte, dass dieses Array auch JavaScript-Objekte enthält, die wir im nächsten Abschnitt genauer unter die Lupe nehmen werden, aber für den Moment musst du nur wissen, dass Arrays auch komplexe Objekte speichern können.
+
+```js
+let complexArray = [
+ [
+ {
+ one: 1,
+ two: 2
+ },
+ {
+ three: 3,
+ four: 4
+ }
+ ],
+ [
+ {
+ a: "a",
+ b: "b"
+ },
+ {
+ c: "c",
+ d: "d"
+ }
+ ]
+];
+```
+
+# --instructions--
+
+Wir haben eine Variable namens `yourArray` definiert. Vervollständige die Anweisung, indem du der Variable `yourArray` ein Array mit einer Länge von mindestens 5 Elementen zuweist. Dein Array sollte mindestens einen String , eine Zahl und ein Boolean enthalten.
+
+# --hints--
+
+`yourArray` soll ein Array sein.
+
+```js
+assert.strictEqual(Array.isArray(yourArray), true);
+```
+
+`yourArray` soll mindestens 5 Elemente lang sein.
+
+```js
+assert.isAtLeast(yourArray.length, 5);
+```
+
+`yourArray` soll mindestens einen Boolean (`boolean`) enthalten.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1);
+```
+
+`yourArray` soll mindestens eine Zahl (`number`) enthalten.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'number').length >= 1);
+```
+
+`yourArray` soll mindestens einen String (`string`) enthalten.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'string').length >= 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let yourArray; // Change this line
+```
+
+# --solutions--
+
+```js
+let yourArray = ['a string', 100, true, ['one', 2], 'another string'];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
new file mode 100644
index 00000000000..325ba37203d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b7c367417b2b2512b1b
+title: Verwende das Schlüsselwort delete, um Objekteigenschaften zu löschen
+challengeType: 1
+forumTopicId: 301168
+dashedName: use-the-delete-keyword-to-remove-object-properties
+---
+
+# --description--
+
+Jetzt weißt du, was Objekte sind und kennst deren Basisfunktionen und Vorteile. Kurz gefasst handelt es sich um Key-Value-Stores, die eine flexible, intuitive Möglichkeit bieten, Daten zu strukturieren, ***und*** sie bieten eine sehr schnelle Zugriffszeit. Im weiteren Verlauf dieser Aufgaben, werden wir verschiedene gängige Operationen erklären, die du mit Objekten durchführen kannst, damit du dich damit vertraut machen kannst diese nützlichen Datenstrukturen in deinen Programmen anzuwenden.
+
+In vorherigen Aufgaben haben wir die Schlüssel-Wert-Paare eines Objekts sowohl ergänzt, wie auch modifiziert. Hier werden wir sehen, wie wir ein Schlüssel-Wert-Paar von einem Objekt *entfernen*.
+
+Lass uns noch einmal unser Objektbeispiel `foods` ein letztes Mal anschauen. Wenn wir den Wert `apples` entfernen wollen, können wir es entfernen indem wir das Schlüsselwort `delete` wie hier verwenden:
+
+```js
+delete foods.apples;
+```
+
+# --instructions--
+
+Benutze das Schlüsselwort delete um die Werte `oranges`, `plums` und `strawberries` vom Objekt `foods` zu entfernen.
+
+# --hints--
+
+Das Objekt `foods` soll nur drei Schlüsselwörter haben: `apples`, `grapes`und `bananas`.
+
+```js
+assert(
+ !foods.hasOwnProperty('oranges') &&
+ !foods.hasOwnProperty('plums') &&
+ !foods.hasOwnProperty('strawberries') &&
+ Object.keys(foods).length === 3
+);
+```
+
+Die Werte `oranges`, `plums` und `strawberries` sollen mittels `delete` entfernt werden.
+
+```js
+assert(
+ code.search(/oranges:/) !== -1 &&
+ code.search(/plums:/) !== -1 &&
+ code.search(/strawberries:/) !== -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+delete foods.oranges;
+delete foods.plums;
+delete foods.strawberries;
+
+console.log(foods);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
new file mode 100644
index 00000000000..d70fa72440d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
@@ -0,0 +1,87 @@
+---
+id: 56bbb991ad1ed5201cd392ca
+title: Auf Array-Daten mit Indizes zugreifen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQbTz'
+forumTopicId: 16158
+dashedName: access-array-data-with-indexes
+---
+
+# --description--
+
+Wir können auf die Daten innerhalb von Arrays mit Indizes zugreifen.
+
+Array-Indizes werden in der gleichen Klammernotation wie Strings geschrieben, außer dass sie anstelle eines Zeichens einen Eintrag im Array spezifizieren. Wie bei Strings verwenden Arrays eine nullbasierte Indizierung, so dass das erste Element in einem Array den Index `0` hat.
+
+mehrdimensionales Array als ein *Array von Arrays* vorstellen. Wenn du Klammern verwendest, um auf dein Array zuzugreifen, bezieht sich der erste Klammersatz auf die Einträge im äußersten (die erste Ebene) Array, und jedes weitere Klammerpaar bezieht sich auf die nächste Ebene von Einträgen darin.
+
+**Beispiel**
+
+```js
+const arr = [
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 9],
+ [[10, 11, 12], 13, 14]
+];
+
+const subarray = arr[3];
+const nestedSubarray = arr[3][0];
+const element = arr[3][0][1];
+```
+
+In diesem Beispiel, hat `subarray` den Wert `[[10, 11, 12], 13, 14]`, `nestedSubarray` hat den Wert `[10, 11, 12]`, und `element` hat den Wert `11` .
+
+**Hinweis:** Zwischen dem Array-Namen und den eckigen Klammern sollten keine Leerzeichen stehen, zum Beispiel `array [0][0]` oder selbst dies `array [0] [0]` ist nicht erlaubt. Obwohl JavaScript dies problemlos verarbeiten kann, könnte es andere Programmierer, die deinen Code lesen, verwirren.
+
+# --instructions--
+
+Wähle mithilfe der Klammernotation ein Element aus `myArray` so aus, dass `myData` gleich `8` ist.
+
+# --hints--
+
+`myData` sollte gleich `8` sein.
+
+```js
+assert(myData === 8);
+```
+
+Du solltest die Klammernotation verwenden, um den richtigen Wert aus `myArray` zu lesen.
+
+```js
+assert(/myData=myArray\[2\]\[1\]/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 9],
+ [[10, 11, 12], 13, 14],
+];
+
+const myData = myArray[0][0];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [[10, 11, 12], 13, 14]];
+const myData = myArray[2][1];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
new file mode 100644
index 00000000000..5b95f30dec3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
@@ -0,0 +1,121 @@
+---
+id: 56533eb9ac21ba0edf2244cd
+title: Zugriff auf verschachtelte Arrays
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cLeGDtZ'
+forumTopicId: 16160
+dashedName: accessing-nested-arrays
+---
+
+# --description--
+
+Wie wir in früheren Beispielen gesehen haben, können Objekte sowohl verschachtelte Objekte als auch verschachtelte Arrays enthalten. Ähnlich wie beim Zugriff auf verschachtelte Objekte kann auch die Array-Klammerschreibweise verkettet werden, um auf verschachtelte Arrays zuzugreifen.
+
+Hier ist ein Beispiel, wie du auf ein verschachteltes Array zugreifen kannst:
+
+```js
+const ourPets = [
+ {
+ animalType: "cat",
+ names: [
+ "Meowzer",
+ "Fluffy",
+ "Kit-Cat"
+ ]
+ },
+ {
+ animalType: "dog",
+ names: [
+ "Spot",
+ "Bowser",
+ "Frankie"
+ ]
+ }
+];
+
+ourPets[0].names[1];
+ourPets[1].names[0];
+```
+
+`ourPets[0].names[1]` wäre der String `Fluffy`, und `ourPets[1].names[0]` wäre der String `Spot`.
+
+# --instructions--
+
+Verwende die Punkt- und Klammerschreibweise und setze die Variable `secondTree` auf den zweiten Eintrag in der `trees`-Liste des `myPlants` Objekts.
+
+# --hints--
+
+`secondTree` sollte gleich dem String `pine` sein.
+
+```js
+assert(secondTree === 'pine');
+```
+
+Dein Code sollte die Punkt- und Klammerschreibweise verwenden, um auf `myPlants` zuzugreifen.
+
+```js
+assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+ if(typeof x != 'undefined') {
+ return "secondTree = " + x;
+ }
+ return "secondTree is undefined";
+})(secondTree);
+```
+
+## --seed-contents--
+
+```js
+const myPlants = [
+ {
+ type: "flowers",
+ list: [
+ "rose",
+ "tulip",
+ "dandelion"
+ ]
+ },
+ {
+ type: "trees",
+ list: [
+ "fir",
+ "pine",
+ "birch"
+ ]
+ }
+];
+
+const secondTree = "";
+```
+
+# --solutions--
+
+```js
+const myPlants = [
+ {
+ type: "flowers",
+ list: [
+ "rose",
+ "tulip",
+ "dandelion"
+ ]
+ },
+ {
+ type: "trees",
+ list: [
+ "fir",
+ "pine",
+ "birch"
+ ]
+ }
+];
+
+const secondTree = myPlants[1].list[1];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
new file mode 100644
index 00000000000..13031461f56
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244cc
+title: Zugriff auf verschachtelte Objekte
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRnRnfa'
+forumTopicId: 16161
+dashedName: accessing-nested-objects
+---
+
+# --description--
+
+Auf die Untereigenschaften von Objekten kann durch Aneinanderreihen der Punkt- oder Klammerschreibweise zugegriffen werden.
+
+Hier ist ein verschachteltes Objekt:
+
+```js
+const ourStorage = {
+ "desk": {
+ "drawer": "stapler"
+ },
+ "cabinet": {
+ "top drawer": {
+ "folder1": "a file",
+ "folder2": "secrets"
+ },
+ "bottom drawer": "soda"
+ }
+};
+
+ourStorage.cabinet["top drawer"].folder2;
+ourStorage.desk.drawer;
+```
+
+`ourStorage.cabinet["top drawer"].folder2` wäre der String `secrets` und `ourStorage.desk.drawer` wäre der String `stapler`.
+
+# --instructions--
+
+Greife auf das Objekt `myStorage` zu und weise den Inhalt der Eigenschaft `glove box` der Variablen `gloveBoxContents` zu. Verwende nach Möglichkeit die Punktschreibweise für alle Eigenschaften, ansonsten die Klammerschreibweise.
+
+# --hints--
+
+`gloveBoxContents` sollte gleich dem String `maps` sein.
+
+```js
+assert(gloveBoxContents === 'maps');
+```
+
+Dein Code sollte die Punkt- und Klammerschreibweise verwenden, um auf `myStorage` zuzugreifen.
+
+```js
+assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+ if(typeof x != 'undefined') {
+ return "gloveBoxContents = " + x;
+ }
+ return "gloveBoxContents is undefined";
+})(gloveBoxContents);
+```
+
+## --seed-contents--
+
+```js
+const myStorage = {
+ "car": {
+ "inside": {
+ "glove box": "maps",
+ "passenger seat": "crumbs"
+ },
+ "outside": {
+ "trunk": "jack"
+ }
+ }
+};
+
+const gloveBoxContents = undefined;
+```
+
+# --solutions--
+
+```js
+const myStorage = {
+ "car":{
+ "inside":{
+ "glove box":"maps",
+ "passenger seat":"crumbs"
+ },
+ "outside":{
+ "trunk":"jack"
+ }
+ }
+};
+const gloveBoxContents = myStorage.car.inside["glove box"];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
new file mode 100644
index 00000000000..d0c8e5e8666
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
@@ -0,0 +1,103 @@
+---
+id: 56533eb9ac21ba0edf2244c8
+title: Zugriff auf Objekteigenschaften mit der Klammerschreibweise
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBvmEHP'
+forumTopicId: 16163
+dashedName: accessing-object-properties-with-bracket-notation
+---
+
+# --description--
+
+Die zweite Möglichkeit, auf die Eigenschaften eines Objekts zuzugreifen, ist die Klammerschreibweise (`[]`). Wenn die Eigenschaft des Objekts, auf das du zugreifen willst, ein Leerzeichen in ihrem Namen hat, musst du die Klammerschreibweise verwenden.
+
+Du kannst die Klammerschreibweise jedoch auch für Objekteigenschaften ohne Leerzeichen verwenden.
+
+Hier ist ein Beispiel für die Verwendung der Klammerschreibweise, um die Eigenschaft eines Objekts zu lesen:
+
+```js
+const myObj = {
+ "Space Name": "Kirk",
+ "More Space": "Spock",
+ "NoSpace": "USS Enterprise"
+};
+
+myObj["Space Name"];
+myObj['More Space'];
+myObj["NoSpace"];
+```
+
+`myObj["Space Name"]` wäre der String `Kirk`, `myObj['More Space']` wäre der String `Spock`, und `myObj["NoSpace"]` wäre der String `USS Enterprise`.
+
+Beachte, dass Eigenschaftsnamen mit Leerzeichen in Anführungszeichen stehen müssen (einfach oder doppelt).
+
+# --instructions--
+
+Lies die Werte der Eigenschaften `an entree` und `the drink` von `testObj` in Klammerschreibweise und weise sie `entreeValue` bzw. `drinkValue` zu.
+
+# --hints--
+
+`entreeValue` sollte ein String sein
+
+```js
+assert(typeof entreeValue === 'string');
+```
+
+Der Wert von `entreeValue` sollte der String `hamburger` sein
+
+```js
+assert(entreeValue === 'hamburger');
+```
+
+`drinkValue` sollte ein String sein
+
+```js
+assert(typeof drinkValue === 'string');
+```
+
+Der Wert von `drinkValue` sollte der String `water` sein
+
+```js
+assert(drinkValue === 'water');
+```
+
+Du solltest die Klammerschreibweise zweimal verwenden
+
+```js
+assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+ "an entree": "hamburger",
+ "my side": "veggies",
+ "the drink": "water"
+};
+
+// Only change code below this line
+const entreeValue = testObj; // Change this line
+const drinkValue = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+ "an entree": "hamburger",
+ "my side": "veggies",
+ "the drink": "water"
+};
+const entreeValue = testObj["an entree"];
+const drinkValue = testObj['the drink'];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
new file mode 100644
index 00000000000..40be65820fb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244c7
+title: Zugriff auf Objekteigenschaften mithilfe der Punktschreibweise
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cGryJs8'
+forumTopicId: 16164
+dashedName: accessing-object-properties-with-dot-notation
+---
+
+# --description--
+
+Es gibt zwei Möglichkeiten, auf die Eigenschaften eines Objekts zuzugreifen: die Punktschreibweise (`.`) und die Klammerschreibweise (`[]`), ähnlich wie bei einem Array.
+
+Die Punktschreibweise verwendest du, wenn du den Namen der Eigenschaft, auf die du zugreifen willst, schon vorher kennst.
+
+Hier ist ein Beispiel für die Verwendung der Punktschreibweise (`.`), um die Eigenschaft eines Objekts zu lesen:
+
+```js
+const myObj = {
+ prop1: "val1",
+ prop2: "val2"
+};
+
+const prop1val = myObj.prop1;
+const prop2val = myObj.prop2;
+```
+
+`prop1val` hätte einen String mit dem Wert `val1` und `prop2val` einen String mit dem Wert `val2`.
+
+# --instructions--
+
+Lies die Eigenschaftswerte von `testObj` in Punktschreibweise ein. Setze die Variable `hatValue` gleich der Eigenschaft `hat` des Objekts und setze die Variable `shirtValue` gleich der Eigenschaft `shirt` des Objekts.
+
+# --hints--
+
+`hatValue` sollte ein String sein
+
+```js
+assert(typeof hatValue === 'string');
+```
+
+Der Wert von `hatValue` sollte der String `ballcap` sein
+
+```js
+assert(hatValue === 'ballcap');
+```
+
+`shirtValue` sollte ein String sein
+
+```js
+assert(typeof shirtValue === 'string');
+```
+
+Der Wert von `shirtValue` sollte der String `jersey` sein
+
+```js
+assert(shirtValue === 'jersey');
+```
+
+Du solltest die Punktschreibweise zweimal verwenden
+
+```js
+assert(code.match(/testObj\.\w+/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+ "hat": "ballcap",
+ "shirt": "jersey",
+ "shoes": "cleats"
+};
+
+// Only change code below this line
+const hatValue = testObj; // Change this line
+const shirtValue = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+ "hat": "ballcap",
+ "shirt": "jersey",
+ "shoes": "cleats"
+};
+
+const hatValue = testObj.hat;
+const shirtValue = testObj.shirt;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
new file mode 100644
index 00000000000..e0fe93f071a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
@@ -0,0 +1,107 @@
+---
+id: 56533eb9ac21ba0edf2244c9
+title: Zugriff auf Objekteigenschaften mit Variablen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnQyKur'
+forumTopicId: 16165
+dashedName: accessing-object-properties-with-variables
+---
+
+# --description--
+
+Eine weitere Verwendung der Klammerschreibweise für Objekte ist der Zugriff auf eine Eigenschaft, die als Wert einer Variablen gespeichert ist. Das kann sehr nützlich sein, um die Eigenschaften eines Objekts zu durchlaufen oder auf eine Umsetzungstabelle (lookup table) zuzugreifen.
+
+Hier ist ein Beispiel für die Verwendung einer Variablen, um auf eine Eigenschaft zuzugreifen:
+
+```js
+const dogs = {
+ Fido: "Mutt",
+ Hunter: "Doberman",
+ Snoopie: "Beagle"
+};
+
+const myDog = "Hunter";
+const myBreed = dogs[myDog];
+console.log(myBreed);
+```
+
+Der String `Doberman` würde in der Konsole angezeigt werden.
+
+Beachte, dass wir die Variablenbezeichnungen *nicht* mit Anführungszeichen versehen, wenn wir auf die Eigenschaft zugreifen, da wir den *Wert* der Variablen verwenden, nicht die *Bezeichnungen*.
+
+# --instructions--
+
+Setze die Variable `playerNumber` auf `16`. Benutze dann die Variable, um den Namen des Spielers abzufragen und ihn `player` zuzuweisen.
+
+# --hints--
+
+`playerNumber` sollte eine Zahl sein
+
+```js
+assert(typeof playerNumber === 'number');
+```
+
+Die Variable `player` sollte ein String sein
+
+```js
+assert(typeof player === 'string');
+```
+
+Der Wert von `player` sollte der String `Montana` sein
+
+```js
+assert(player === 'Montana');
+```
+
+Du solltest die Klammerschreibweise verwenden, um auf `testObj` zuzugreifen
+
+```js
+assert(/testObj\s*?\[.*?\]/.test(code));
+```
+
+Du solltest den Wert `Montana` nicht direkt der Variable `player` zuweisen.
+
+```js
+assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
+```
+
+Du solltest die Variable `playerNumber` in deiner Klammerschreibweise verwenden
+
+```js
+assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof player !== "undefined"){(function(v){return v;})(player);}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+ 12: "Namath",
+ 16: "Montana",
+ 19: "Unitas"
+};
+
+// Only change code below this line
+const playerNumber = 42; // Change this line
+const player = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+ 12: "Namath",
+ 16: "Montana",
+ 19: "Unitas"
+};
+const playerNumber = 16;
+const player = testObj[playerNumber];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
new file mode 100644
index 00000000000..aec634d4706
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392d2
+title: Neue Eigenschaften zu einem JavaScript-Objekt hinzufügen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe38UD'
+forumTopicId: 301169
+dashedName: add-new-properties-to-a-javascript-object
+---
+
+# --description--
+
+Du kannst neue Eigenschaften zu bestehenden JavaScript-Objekten hinzufügen, genauso wie du sie ändern würdest.
+
+So würden wir eine Eigenschaft `bark` zu `ourDog` hinzufügen:
+
+```js
+ourDog.bark = "bow-wow";
+```
+
+oder
+
+```js
+ourDog["bark"] = "bow-wow";
+```
+
+Wenn wir jetzt `ourDog.bark` auswerten, bekommen wir sein Bellen, `bow-wow`.
+
+Beispiel:
+
+```js
+const ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+
+ourDog.bark = "bow-wow";
+```
+
+# --instructions--
+
+Füge die Eigenschaft `bark` zu `myDog` hinzu und setze sie auf ein Hundegeräusch, wie z. B. "woof". Du kannst entweder die Punkt- oder die Klammerschreibweise verwenden.
+
+# --hints--
+
+Du solltest die Eigenschaft `bark` zu `myDog` hinzufügen.
+
+```js
+assert(myDog.bark !== undefined);
+```
+
+Du solltest `bark` nicht zur Initialisierung von `myDog` hinzufügen.
+
+```js
+assert(!/bark[^\n]:/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+myDog.bark = "Woof Woof";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
new file mode 100644
index 00000000000..00e522fec52
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
@@ -0,0 +1,62 @@
+---
+id: cf1111c1c11feddfaeb3bdef
+title: Zwei Zahlen mit JavaScript addieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KBAG'
+forumTopicId: 16650
+dashedName: add-two-numbers-with-javascript
+---
+
+# --description--
+
+`Number` ist ein Datentyp in JavaScript, der numerische Daten darstellt.
+
+Lass uns versuchen, zwei Zahlen mit JavaScript zu addieren.
+
+JavaScript verwendet das Symbol `+` als Additionsoperator, wenn es zwischen zwei Zahlen steht.
+
+**Beispiel:**
+
+```js
+const myVar = 5 + 10;
+```
+
+`myVar` hat jetzt den Wert `15`.
+
+# --instructions--
+
+Ändere die `0` so, dass die Summe gleich `20` wird.
+
+# --hints--
+
+`sum` sollte gleich `20` sein.
+
+```js
+assert(sum === 20);
+```
+
+Du solltest den Operator `+` verwenden.
+
+```js
+assert(/\+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'sum = '+z;})(sum);
+```
+
+## --seed-contents--
+
+```js
+const sum = 10 + 0;
+```
+
+# --solutions--
+
+```js
+const sum = 10 + 10;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
new file mode 100644
index 00000000000..55b0196cfa2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244de
+title: Hinzufügen einer Standardoption in switch-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JvVfg'
+forumTopicId: 16653
+dashedName: adding-a-default-option-in-switch-statements
+---
+
+# --description--
+
+In einer `switch`-Anweisung kannst du möglicherweise nicht alle möglichen Werte als `case`-Anweisungen angeben. Stattdessen kannst du die `default`-Anweisung hinzufügen, die ausgeführt wird, wenn keine passenden `case`-Anweisungen gefunden werden. Stell dir das vor wie die letzte `else`-Anweisung in einer `if/else`-Kette.
+
+Eine `default`-Anweisung sollte der letzte Fall sein.
+
+```js
+switch (num) {
+ case value1:
+ statement1;
+ break;
+ case value2:
+ statement2;
+ break;
+...
+ default:
+ defaultStatement;
+ break;
+}
+```
+
+# --instructions--
+
+Schreibe eine switch-Anweisung, um `answer` für die folgenden Bedingungen zu setzen:
+`a` - `apple`
+`b` - `bird`
+`c` - `cat`
+`default` - `stuff`
+
+# --hints--
+
+`switchOfStuff("a")` sollte den String `apple` zurückgeben
+
+```js
+assert(switchOfStuff('a') === 'apple');
+```
+
+`switchOfStuff("b")` sollte den String `bird` zurückgeben
+
+```js
+assert(switchOfStuff('b') === 'bird');
+```
+
+`switchOfStuff("c")`sollte den String `cat` zurückgeben
+
+```js
+assert(switchOfStuff('c') === 'cat');
+```
+
+`switchOfStuff("d")` sollte den String `stuff` zurückgeben
+
+```js
+assert(switchOfStuff('d') === 'stuff');
+```
+
+`switchOfStuff(4)` sollte den String `stuff` zurückgeben
+
+```js
+assert(switchOfStuff(4) === 'stuff');
+```
+
+Du solltest keine `if` oder `else`-Anweisungen verwenden
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Du solltest eine `default`-Anweisung verwenden
+
+```js
+assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
+```
+
+Du solltest mindestens 3 `break`-Anweisungen verwenden
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function switchOfStuff(val) {
+ let answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+switchOfStuff(1);
+```
+
+# --solutions--
+
+```js
+function switchOfStuff(val) {
+ let answer = "";
+
+ switch(val) {
+ case "a":
+ answer = "apple";
+ break;
+ case "b":
+ answer = "bird";
+ break;
+ case "c":
+ answer = "cat";
+ break;
+ default:
+ answer = "stuff";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
new file mode 100644
index 00000000000..9f202367b61
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244ed
+title: Anhängen von Variablen an Strings
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmZfa'
+forumTopicId: 16656
+dashedName: appending-variables-to-strings
+---
+
+# --description--
+
+Genauso wie wir einen String über mehrere Zeilen aus Literalen aufbauen können, können wir auch Variablen an einen String anhängen, indem wir den Plus-Gleichheits-Operator (`+=`) verwenden.
+
+Beispiel:
+
+```js
+const anAdjective = "awesome!";
+let ourStr = "freeCodeCamp is ";
+ourStr += anAdjective;
+```
+
+`ourStr` hätte dann den Wert `freeCodeCamp is awesome!`.
+
+# --instructions--
+
+Setze `someAdjective` auf einen String von mindestens 3 Zeichen und füge ihn mit dem Operator `+=` an `myStr` an.
+
+# --hints--
+
+`someAdjective` sollte auf einen String mit mindestens 3 Zeichen Länge gesetzt werden.
+
+```js
+assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
+```
+
+Du solltest `someAdjective` an `myStr` mit dem Operator `+=` anhängen.
+
+```js
+assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ var output = [];
+ if(typeof someAdjective === 'string') {
+ output.push('someAdjective = "' + someAdjective + '"');
+ } else {
+ output.push('someAdjective is not a string');
+ }
+ if(typeof myStr === 'string') {
+ output.push('myStr = "' + myStr + '"');
+ } else {
+ output.push('myStr is not a string');
+ }
+ return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Change code below this line
+const someAdjective = "";
+let myStr = "Learning to code is ";
+```
+
+# --solutions--
+
+```js
+const someAdjective = "neat";
+let myStr = "Learning to code is ";
+myStr += someAdjective;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
new file mode 100644
index 00000000000..6a7e8bfe3b3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
@@ -0,0 +1,86 @@
+---
+id: 5ee127a03c3b35dd45426493
+title: Den Wert einer Variablen einer anderen zuweisen
+challengeType: 1
+videoUrl: ''
+forumTopicId: 418265
+dashedName: assigning-the-value-of-one-variable-to-another
+---
+
+# --description--
+
+Nachdem einer Variablen mit dem Zuweisungsoperator ein Wert zugewiesen wurde, kannst du den Wert dieser Variablen mit dem Zuweisungsoperator einer anderen Variablen zuweisen.
+
+```js
+var myVar;
+myVar = 5;
+var myNum;
+myNum = myVar;
+```
+
+Im obigen Beispiel wird eine Variable `myVar` ohne Wert deklariert und ihr dann der Wert `5` zugewiesen. Als nächstes wird eine Variable mit dem Namen `myNum` ohne Wert deklariert. Dann wird der Inhalt von `myVar` (der `5` ist) der Variablen `myNum` zugewiesen. Jetzt hat `myNum` auch den Wert von `5`.
+
+# --instructions--
+
+Weise der Variablen `b` den Inhalt von `a` zu.
+
+# --hints--
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
+```
+
+`b` sollte einen Wert von `7` besitzen.
+
+```js
+assert(typeof b === 'number' && b === 7);
+```
+
+`a` sollte `b` mit `=` zugewiesen werden.
+
+```js
+assert(/b\s*=\s*a\s*/g.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+ a = undefined;
+}
+if (typeof b != 'undefined') {
+ b = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a, b) {
+ return 'a = ' + a + ', b = ' + b;
+})(a, b);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+a = 7;
+var b;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+var b;
+b = a;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
new file mode 100644
index 00000000000..7047a78989d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244c3
+title: Zuweisung mit einem zurückgegebenen Wert
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2pEtB'
+forumTopicId: 16658
+dashedName: assignment-with-a-returned-value
+---
+
+# --description--
+
+Wenn du dich an unsere Diskussion über das Speichern von Werten mit dem Zuweisungsoperator erinnerst, wird alles rechts vom Gleichheitszeichen aufgelöst, bevor der Wert zugewiesen wird. Das bedeutet, wir können den Rückgabewert einer Funktion nehmen und ihn einer Variablen zuweisen.
+
+Angenommen, wir haben eine Funktion `sum` vordefiniert, die zwei Zahlen addiert, dann ruft:
+
+```js
+ourSum = sum(5, 12);
+```
+
+die `sum`-Funktion auf, die einen Wert von `17` zurückgibt und ihn der `ourSum`-Variablen zuweist.
+
+# --instructions--
+
+Rufe die Funktion `processArg` mit einem Argument von `7` auf und weise ihren Rückgabewert der Variablen `processed` zu.
+
+# --hints--
+
+`processed` sollte einen Wert von `2` haben
+
+```js
+assert(processed === 2);
+```
+
+Du solltest `processArg` zu `processed` zuweisen
+
+```js
+assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return "processed = " + processed})();
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let processed = 0;
+
+function processArg(num) {
+ return (num + 3) / 5;
+}
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+var processed = 0;
+
+function processArg(num) {
+ return (num + 3) / 5;
+}
+
+processed = processArg(7);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
new file mode 100644
index 00000000000..590044be137
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
@@ -0,0 +1,159 @@
+---
+id: 56bbb991ad1ed5201cd392d0
+title: JavaScript-Objekte erstellen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWGkbtd'
+forumTopicId: 16769
+dashedName: build-javascript-objects
+---
+
+# --description--
+
+Vielleicht hast du den Begriff `object` schon einmal gehört.
+
+Objekte sind vergleichbar mit `arrays`, mit dem Unterschied, dass du nicht über Indizes auf die Daten zugreifst und sie veränderst, sondern über so genannte `properties` (Eigenschaften).
+
+Objekte sind nützlich, um Daten strukturiert zu speichern, und können Objekte der realen Welt darstellen, wie zum Beispiel eine Katze.
+
+Hier ist ein Beispiel für ein Katzenobjekt:
+
+```js
+const cat = {
+ "name": "Whiskers",
+ "legs": 4,
+ "tails": 1,
+ "enemies": ["Water", "Dogs"]
+};
+```
+
+In diesem Beispiel werden alle Eigenschaften (Properties) als Strings gespeichert, z. B. `name`, `legs`, und `tails`. Du kannst aber auch Zahlen als Eigenschaften verwenden. Du kannst die Anführungszeichen auch weglassen, wenn es sich um einen String mit nur einem Wort handelt, wie im Folgenden beschrieben:
+
+```js
+const anotherObject = {
+ make: "Ford",
+ 5: "five",
+ "model": "focus"
+};
+```
+
+Wenn dein Objekt jedoch Eigenschaften hat, die keine Strings sind, wird JavaScript sie automatisch als Strings typisieren.
+
+# --instructions--
+
+Erstelle ein Objekt, das einen Hund namens `myDog` darstellt und die Eigenschaften `name` (ein String), `legs`, `tails` und `friends` enthält.
+
+Du kannst diese Objekteigenschaften auf jeden beliebigen Wert setzen, solange `name` ein String ist, `legs` und `tails` Zahlen sind und `friends` ein Array ist.
+
+# --hints--
+
+`myDog` sollte die Eigenschaft `name` enthalten und es sollte ein `string` sein.
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('name') &&
+ z.name !== undefined &&
+ typeof z.name === 'string'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` sollte die Eigenschaft `legs` enthalten und sie sollte eine `number` sein.
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('legs') &&
+ z.legs !== undefined &&
+ typeof z.legs === 'number'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` sollte die Eigenschaft `tails` enthalten und sie sollte eine `number` sein.
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('tails') &&
+ z.tails !== undefined &&
+ typeof z.tails === 'number'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` sollte die Eigenschaft `friends` enthalten und es sollte ein `array` sein.
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('friends') &&
+ z.friends !== undefined &&
+ Array.isArray(z.friends)
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` sollte nur alle angegebenen Eigenschaften enthalten.
+
+```js
+assert(
+ (function (z) {
+ return Object.keys(z).length === 4;
+ })(myDog)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+ // Only change code below this line
+
+
+ // Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+const myDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
new file mode 100644
index 00000000000..98129a5802e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244dc
+title: Verkettung von If-Else-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJgsw'
+forumTopicId: 16772
+dashedName: chaining-if-else-statements
+---
+
+# --description--
+
+`if/else`-Anweisungen können für komplexe Logik miteinander verkettet werden. Hier ist Pseudocode von mehreren verketteten `if` / `else if`-Anweisungen:
+
+```js
+if (condition1) {
+ statement1
+} else if (condition2) {
+ statement2
+} else if (condition3) {
+ statement3
+. . .
+} else {
+ statementN
+}
+```
+
+# --instructions--
+
+Schreibe verkettete `if`/`else if`-Anweisungen, um die folgenden Bedingungen zu erfüllen:
+
+`num < 5` - gibt `Tiny` zurück
+`num < 10` - gibt `Small` zurück
+zurück `num < 15` - gibt `Medium` zurück
+`num < 20` - gibt `Large` zurück
+`num >= 20` - gibt `Huge` zurück
+
+# --hints--
+
+Du solltest mindestens vier `else`-Anweisungen verwenden
+
+```js
+assert(code.match(/else/g).length > 3);
+```
+
+Du solltest mindestens vier `if`-Anweisungen verwenden
+
+```js
+assert(code.match(/if/g).length > 3);
+```
+
+Du solltest mindestens eine `return`-Anweisung verwenden
+
+```js
+assert(code.match(/return/g).length >= 1);
+```
+
+`testSize(0)` sollte den String `Tiny` zurückgeben
+
+```js
+assert(testSize(0) === 'Tiny');
+```
+
+`testSize(4)` sollte den String `Tiny` zurückgeben
+
+```js
+assert(testSize(4) === 'Tiny');
+```
+
+`testSize(5)` sollte den String `Small` zurückgeben
+
+```js
+assert(testSize(5) === 'Small');
+```
+
+`testSize(8)` sollte den String `Small` zurückgeben
+
+```js
+assert(testSize(8) === 'Small');
+```
+
+`testSize(10)` sollte den String `Medium` zurückgeben
+
+```js
+assert(testSize(10) === 'Medium');
+```
+
+`testSize(14)` sollte den String `Medium` zurückgeben
+
+```js
+assert(testSize(14) === 'Medium');
+```
+
+`testSize(15)` sollte den String `Large` zurückgeben
+
+```js
+assert(testSize(15) === 'Large');
+```
+
+`testSize(17)` sollte den String `Large` zurückgeben
+
+```js
+assert(testSize(17) === 'Large');
+```
+
+`testSize(20)` sollte den String `Huge` zurückgeben
+
+```js
+assert(testSize(20) === 'Huge');
+```
+
+`testSize(25)` sollte den String `Huge` zurückgeben
+
+```js
+assert(testSize(25) === 'Huge');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testSize(num) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+testSize(7);
+```
+
+# --solutions--
+
+```js
+function testSize(num) {
+ if (num < 5) {
+ return "Tiny";
+ } else if (num < 10) {
+ return "Small";
+ } else if (num < 15) {
+ return "Medium";
+ } else if (num < 20) {
+ return "Large";
+ } else {
+ return "Huge";
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
new file mode 100644
index 00000000000..bae19cd552d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
@@ -0,0 +1,63 @@
+---
+id: bd7123c9c441eddfaeb4bdef
+title: Kommentiere deinen JavaScript-Code
+challengeType: 1
+removeComments: false
+videoUrl: 'https://scrimba.com/c/c7ynnTp'
+forumTopicId: 16783
+dashedName: comment-your-javascript-code
+---
+
+# --description--
+
+Kommentare sind Codezeilen, die JavaScript bewusst ignoriert. Kommentare sind eine gute Möglichkeit, Notizen für sich selbst und für andere Personen zu hinterlassen, die später herausfinden müssen, was der Code bewirkt.
+
+Es gibt zwei Varianten, Kommentare in JavaScript zu schreiben:
+
+Mit `//` wird JavaScript angewiesen, den Rest des Textes in der aktuellen Zeile zu ignorieren. Dies ist ein Inline-Kommentar:
+
+```js
+// This is an in-line comment.
+```
+
+Du kannst einen mehrzeiligen Kommentar schreiben, der mit `/*` beginnt und mit `*/` endet. Dies ist ein mehrzeiliger Kommentar:
+
+```js
+/* This is a
+multi-line comment */
+```
+
+**HINWEIS:** Wenn du Code schreibst, solltest du regelmäßig Kommentare hinzufügen, um die Funktion von Teilen deines Codes zu erläutern. Eine gute Kommentierung kann dazu beitragen, den Zweck deines Codes zu erklären - sowohl für andere *als auch* für dein zukünftiges Ich.
+
+# --instructions--
+
+Versuche einen Kommentar von jeder Variante zu erstellen.
+
+# --hints--
+
+Du solltest einen Kommentar im Stil von `//` erstellen, der mindestens fünf Buchstaben enthält.
+
+```js
+assert(code.match(/(\/\/)...../g));
+```
+
+Du solltest einen Kommentar im Stil von `/* */` erstellen, der mindestens fünf Buchstaben enthält.
+
+```js
+assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+// Fake Comment
+/* Another Comment */
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
new file mode 100644
index 00000000000..de3d112e411
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
@@ -0,0 +1,89 @@
+---
+id: 56533eb9ac21ba0edf2244d0
+title: Vergleich mit dem Gleichheitsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKyVMAL'
+forumTopicId: 16784
+dashedName: comparison-with-the-equality-operator
+---
+
+# --description--
+
+Es gibt viele Vergleichsoperatoren in JavaScript. Alle diese Operatoren geben einen booleschen `true` oder `false`-Wert zurück.
+
+Der grundlegendste Operator ist der Gleichheitsoperator `==`. Der Gleichheitsoperator vergleicht zwei Werte und gibt `true` zurück, wenn sie gleichwertig sind oder `false`, wenn sie es nicht sind. Beachte, dass Gleichheit sich von der Zuweisung (`=`) unterscheidet, die den Wert rechts vom Operator einer Variablen links zuweist.
+
+```js
+function equalityTest(myVal) {
+ if (myVal == 10) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
+
+Wenn `myVal` gleich `10` ist, gibt der Gleichheitsoperator `true` zurück, also wird der Code in den geschweiften Klammern ausgeführt und die Funktion gibt `Equal` zurück. Andernfalls wird die Funktion `Not Equal` zurückgeben. Damit JavaScript zwei verschiedene Datentypen vergleichen kann (zum Beispiel `numbers` und `strings`), muss es einen Typ in einen anderen umwandeln. Dies ist bekannt als Typenzwang (Type Coercion). Danach kann es die Begriffe wie folgt vergleichen:
+
+```js
+1 == 1 // true
+1 == 2 // false
+1 == '1' // true
+"3" == 3 // true
+```
+
+# --instructions--
+
+Füge den Gleichheitsoperator in die angegebene Zeile hinzu, damit die Funktion den String `Equal` zurückgibt, wenn `val` gleich `12` ist.
+
+# --hints--
+
+`testEqual(10)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testEqual(10) === 'Not Equal');
+```
+
+`testEqual(12)` sollte den String `Equal` zurückgeben
+
+```js
+assert(testEqual(12) === 'Equal');
+```
+
+`testEqual("12")` sollte den String `Equal` zurückgeben
+
+```js
+assert(testEqual('12') === 'Equal');
+```
+
+Du solltest den Operator `==` verwenden
+
+```js
+assert(code.match(/==/g) && !code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testEqual(val) {
+ if (val) { // Change this line
+ return "Equal";
+ }
+ return "Not Equal";
+}
+
+testEqual(10);
+```
+
+# --solutions--
+
+```js
+function testEqual(val) {
+ if (val == 12) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
new file mode 100644
index 00000000000..5152fcf30e8
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
@@ -0,0 +1,111 @@
+---
+id: 56533eb9ac21ba0edf2244d4
+title: Vergleich mit dem Größer-als-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp6GbH4'
+forumTopicId: 16786
+dashedName: comparison-with-the-greater-than-operator
+---
+
+# --description--
+
+Der Größer-als-Operator (`>`) vergleicht die Werte von zwei Zahlen. Wenn die Zahl auf der linken Seite größer ist als die Zahl auf der rechten Seite, gibt er `true` zurück. Andernfalls gibt er `false` zurück.
+
+Wie der Gleichheitsoperator konvertiert auch der Größer-als-Operator die Datentypen der Werte beim Vergleich.
+
+**Beispiele**
+
+```js
+5 > 3 // true
+7 > '3' // true
+2 > 3 // false
+'1' > 9 // false
+```
+
+# --instructions--
+
+Füge den Größer-als-Operator zu den angegebenen Zeilen hinzu, damit die Rückgabeanweisungen einen Sinn ergeben.
+
+# --hints--
+
+`testGreaterThan(0)`sollte den String `10 or Under` zurückgeben
+
+```js
+assert(testGreaterThan(0) === '10 or Under');
+```
+
+`testGreaterThan(10)` sollte den String `10 or Under` zurückgeben
+
+```js
+assert(testGreaterThan(10) === '10 or Under');
+```
+
+`testGreaterThan(11)` sollte den String `Over 10` zurückgeben
+
+```js
+assert(testGreaterThan(11) === 'Over 10');
+```
+
+`testGreaterThan(99)` sollte den String `Over 10` zurückgeben
+
+```js
+assert(testGreaterThan(99) === 'Over 10');
+```
+
+`testGreaterThan(100)` sollte den String `Over 10` zurückgeben
+
+```js
+assert(testGreaterThan(100) === 'Over 10');
+```
+
+`testGreaterThan(101)` sollte den String `Over 100` zurückgeben
+
+```js
+assert(testGreaterThan(101) === 'Over 100');
+```
+
+`testGreaterThan(150)` sollte den String `Over 100` zurückgeben
+
+```js
+assert(testGreaterThan(150) === 'Over 100');
+```
+
+Du solltest den Operator `>` mindestens zweimal verwenden
+
+```js
+assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterThan(val) {
+ if (val) { // Change this line
+ return "Over 100";
+ }
+
+ if (val) { // Change this line
+ return "Over 10";
+ }
+
+ return "10 or Under";
+}
+
+testGreaterThan(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterThan(val) {
+ if (val > 100) { // Change this line
+ return "Over 100";
+ }
+ if (val > 10) { // Change this line
+ return "Over 10";
+ }
+ return "10 or Under";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
new file mode 100644
index 00000000000..03224dd32c8
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
@@ -0,0 +1,113 @@
+---
+id: 56533eb9ac21ba0edf2244d5
+title: Vergleich mit dem Größer-als-oder-Gleich-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KBqtV'
+forumTopicId: 16785
+dashedName: comparison-with-the-greater-than-or-equal-to-operator
+---
+
+# --description--
+
+Der Größer-als-oder-Gleich-Operator (`>=`) vergleicht die Werte von zwei Zahlen. Wenn die Zahl auf der linken Seite größer oder gleich der Zahl auf der rechten Seite ist, wird `true` zurückgegeben. Andernfalls wird `false` zurückgegeben.
+
+Wie der Gleichheitsoperator konvertiert auch der Größer-als-oder-Gleich-Operator Datentypen während des Vergleichs.
+
+**Beispiele**
+
+```js
+6 >= 6 // true
+7 >= '3' // true
+2 >= 3 // false
+'7' >= 9 // false
+```
+
+# --instructions--
+
+Füge den Größer-als-oder-Gleich-Operator zu den angegebenen Zeilen hinzu, damit die Rückgabeanweisungen einen Sinn ergeben.
+
+# --hints--
+
+`testGreaterOrEqual(0)` sollte den String `Less than 10` zurückgeben
+
+```js
+assert(testGreaterOrEqual(0) === 'Less than 10');
+```
+
+`testGreaterOrEqual(9)` sollte den String `Less than 10` zurückgeben
+
+```js
+assert(testGreaterOrEqual(9) === 'Less than 10');
+```
+
+`testGreaterOrEqual(10)` sollte den String `10 or Over` zurückgeben
+
+```js
+assert(testGreaterOrEqual(10) === '10 or Over');
+```
+
+`testGreaterOrEqual(11)` sollte den String `10 or Over` zurückgeben
+
+```js
+assert(testGreaterOrEqual(11) === '10 or Over');
+```
+
+`testGreaterOrEqual(19)` sollte den String `10 or Over` zurückgeben
+
+```js
+assert(testGreaterOrEqual(19) === '10 or Over');
+```
+
+`testGreaterOrEqual(100)` sollte den String `20 or Over` zurückgeben
+
+```js
+assert(testGreaterOrEqual(100) === '20 or Over');
+```
+
+`testGreaterOrEqual(21)` sollte den String `20 or Over` zurückgeben
+
+```js
+assert(testGreaterOrEqual(21) === '20 or Over');
+```
+
+Du solltest den `>=` Operator mindestens zweimal verwenden
+
+```js
+assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterOrEqual(val) {
+ if (val) { // Change this line
+ return "20 or Over";
+ }
+
+ if (val) { // Change this line
+ return "10 or Over";
+ }
+
+ return "Less than 10";
+}
+
+testGreaterOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterOrEqual(val) {
+ if (val >= 20) { // Change this line
+ return "20 or Over";
+ }
+
+ if (val >= 10) { // Change this line
+ return "10 or Over";
+ }
+
+ return "Less than 10";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
new file mode 100644
index 00000000000..82416ab088f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
@@ -0,0 +1,91 @@
+---
+id: 56533eb9ac21ba0edf2244d2
+title: Vergleich mit dem Ungleichheitsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBm9Sr'
+forumTopicId: 16787
+dashedName: comparison-with-the-inequality-operator
+---
+
+# --description--
+
+Der Ungleichheitsoperator (`!=`) ist das Gegenteil des Gleichheitsoperators. Es bedeutet nicht gleich und gibt `false` zurück, wo Gleichheit `true` zurückgeben würde und *umgekehrt*. Wie der Gleichheitsoperator konvertiert auch der Ungleichheitsoperator die Datentypen der Werte während des Vergleichs.
+
+**Beispiele**
+
+```js
+1 != 2 // true
+1 != "1" // false
+1 != '1' // false
+1 != true // false
+0 != false // false
+```
+
+# --instructions--
+
+Füge den Ungleichheitsoperator `!=` zu der `if` Anweisung hinzu, damit die Funktion den String `Not Equal` zurückgeben wird, wenn `val` nicht gleich `99` ist.
+
+# --hints--
+
+`testNotEqual(99)` sollte den String `Equal` zurückgeben
+
+```js
+assert(testNotEqual(99) === 'Equal');
+```
+
+`testNotEqual("99")` sollte den String `Equal` zurückgeben
+
+```js
+assert(testNotEqual('99') === 'Equal');
+```
+
+`testNotEqual(12)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testNotEqual(12) === 'Not Equal');
+```
+
+`testNotEqual("12")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testNotEqual('12') === 'Not Equal');
+```
+
+`testNotEqual("bob")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testNotEqual('bob') === 'Not Equal');
+```
+
+Du solltest den `!=` Operator verwenden
+
+```js
+assert(code.match(/(?!!==)!=/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testNotEqual(val) {
+ if (val) { // Change this line
+ return "Not Equal";
+ }
+ return "Equal";
+}
+
+testNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testNotEqual(val) {
+ if (val != 99) {
+ return "Not Equal";
+ }
+ return "Equal";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
new file mode 100644
index 00000000000..7e0c7380c42
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244d6
+title: Vergleich mit dem Kleiner-als-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVRWtB'
+forumTopicId: 16789
+dashedName: comparison-with-the-less-than-operator
+---
+
+# --description--
+
+Der Kleiner-als-Operator (`<`) vergleicht die Werte von zwei Zahlen. Wenn die Zahl auf der linken Seite kleiner ist als die Zahl auf der rechten Seite, gibt er `true` zurück. Andernfalls gibt er `false` zurück. Wie der Gleichheitsoperator konvertiert auch der Kleiner-als-Operator die Datentypen während des Vergleichs.
+
+**Beispiele**
+
+```js
+2 < 5 // true
+'3' < 7 // true
+5 < 5 // false
+3 < 2 // false
+'8' < 4 // false
+```
+
+# --instructions--
+
+Füge den Kleiner-als-Operator zu den angegebenen Zeilen hinzu, damit die Return-Anweisungen einen Sinn ergeben.
+
+# --hints--
+
+`testLessThan(0)` sollte den String `Under 25` zurückgeben
+
+```js
+assert(testLessThan(0) === 'Under 25');
+```
+
+`testLessThan(24)` sollte den String `Under 25` zurückgeben
+
+```js
+assert(testLessThan(24) === 'Under 25');
+```
+
+`testLessThan(25)` sollte den String `Under 55` zurückgeben
+
+```js
+assert(testLessThan(25) === 'Under 55');
+```
+
+`testLessThan(54)` sollte den String `Under 55` zurückgeben
+
+```js
+assert(testLessThan(54) === 'Under 55');
+```
+
+`testLessThan(55)` sollte den String `55 or Over` zurückgeben
+
+```js
+assert(testLessThan(55) === '55 or Over');
+```
+
+`testLessThan(99)` sollte den String `55 or Over` zurückgeben
+
+```js
+assert(testLessThan(99) === '55 or Over');
+```
+
+Du solltest den `<` Operator mindestens zweimal verwenden
+
+```js
+assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessThan(val) {
+ if (val) { // Change this line
+ return "Under 25";
+ }
+
+ if (val) { // Change this line
+ return "Under 55";
+ }
+
+ return "55 or Over";
+}
+
+testLessThan(10);
+```
+
+# --solutions--
+
+```js
+function testLessThan(val) {
+ if (val < 25) { // Change this line
+ return "Under 25";
+ }
+
+ if (val < 55) { // Change this line
+ return "Under 55";
+ }
+
+ return "55 or Over";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
new file mode 100644
index 00000000000..2c94279e454
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
@@ -0,0 +1,112 @@
+---
+id: 56533eb9ac21ba0edf2244d7
+title: Vergleich mit dem Kleiner-als-oder-Gleich-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVR7Am'
+forumTopicId: 16788
+dashedName: comparison-with-the-less-than-or-equal-to-operator
+---
+
+# --description--
+
+Der Kleiner-als-oder-Gleich-Operator (`<=`) vergleicht die Werte von zwei Zahlen. Wenn die Zahl auf der linken Seite kleiner oder gleich der Zahl auf der rechten Seite ist, gibt er `true` zurück. Wenn die Zahl auf der linken Seite größer als die Zahl auf der rechten Seite ist, gibt er `false` zurück. Wie der Gleichheitsoperator konvertiert auch der Kleiner-als-oder-Gleich-Operator Datentypen.
+
+**Beispiele**
+
+```js
+4 <= 5 // true
+'7' <= 7 // true
+5 <= 5 // true
+3 <= 2 // false
+'8' <= 4 // false
+```
+
+# --instructions--
+
+Füge den Kleiner-als-oder-Gleich-Operator zu den angegebenen Zeilen hinzu, damit die Return-Anweisungen einen Sinn ergeben.
+
+# --hints--
+
+`testLessOrEqual(0)` sollte den String `Smaller Than or Equal to 12` zurückgeben
+
+```js
+assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(11)` sollte den String `Smaller Than or Equal to 12` zurückgeben
+
+```js
+assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(12)` sollte den String `Smaller Than or Equal to 12` zurückgeben
+
+```js
+assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(23)` sollte den String `Smaller Than or Equal to 24` zurückgeben
+
+```js
+assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
+```
+
+`testLessOrEqual(24)` sollte den String `Smaller Than or Equal to 24` zurückgeben
+
+```js
+assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
+```
+
+`testLessOrEqual(25)` sollte den String `More Than 24` zurückgeben
+
+```js
+assert(testLessOrEqual(25) === 'More Than 24');
+```
+
+`testLessOrEqual(55)` sollte den String `More Than 24` zurückgeben
+
+```js
+assert(testLessOrEqual(55) === 'More Than 24');
+```
+
+Du solltest den `<=` Operator mindestens zweimal verwenden
+
+```js
+assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessOrEqual(val) {
+ if (val) { // Change this line
+ return "Smaller Than or Equal to 12";
+ }
+
+ if (val) { // Change this line
+ return "Smaller Than or Equal to 24";
+ }
+
+ return "More Than 24";
+}
+
+testLessOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testLessOrEqual(val) {
+ if (val <= 12) { // Change this line
+ return "Smaller Than or Equal to 12";
+ }
+
+ if (val <= 24) { // Change this line
+ return "Smaller Than or Equal to 24";
+ }
+
+ return "More Than 24";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
new file mode 100644
index 00000000000..c0c85bd65e3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244d1
+title: Vergleich mit dem strikten Gleichheitsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87atr'
+forumTopicId: 16790
+dashedName: comparison-with-the-strict-equality-operator
+---
+
+# --description--
+
+Strikte Gleichheit (`===`) ist das Gegenstück zum Gleichheitsoperator (`==`). Im Gegensatz zum Gleichheitsoperator, der versucht, beide zu vergleichenden Werte in einen gemeinsamen Typ zu konvertieren, führt der strikte Gleichheitsoperator jedoch keine Typkonvertierung durch.
+
+Wenn die zu vergleichenden Werte unterschiedliche Typen haben, werden sie als ungleich angesehen und der strikte Gleichheitsoperator wird false zurückgeben.
+
+**Beispiele**
+
+```js
+3 === 3 // true
+3 === '3' // false
+```
+
+Im zweiten Beispiel ist `3` ein `Number`-Typ und `'3'` ist ein `String`-Typ.
+
+# --instructions--
+
+Verwende den strikten Gleichheitsoperator in der `if`-Anweisung, damit die Funktion den String `Equal` zurückgibt, wenn `val` genau gleich `7` ist.
+
+# --hints--
+
+`testStrict(10)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testStrict(10) === 'Not Equal');
+```
+
+`testStrict(7)` sollte den String `Equal` zurückgeben
+
+```js
+assert(testStrict(7) === 'Equal');
+```
+
+`testStrict("7")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testStrict('7') === 'Not Equal');
+```
+
+Du solltest den `===` Operator verwenden
+
+```js
+assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrict(val) {
+ if (val) { // Change this line
+ return "Equal";
+ }
+ return "Not Equal";
+}
+
+testStrict(10);
+```
+
+# --solutions--
+
+```js
+function testStrict(val) {
+ if (val === 7) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
new file mode 100644
index 00000000000..534e99e6806
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
@@ -0,0 +1,83 @@
+---
+id: 56533eb9ac21ba0edf2244d3
+title: Vergleich mit dem strikten Ungleichheitsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKekkUy'
+forumTopicId: 16791
+dashedName: comparison-with-the-strict-inequality-operator
+---
+
+# --description--
+
+Der strikte Ungleichheitsoperator (`!==`) ist das logische Gegenteil des strikten Gleichheitsoperators. Es bedeutet " Strikt nicht gleich" und gibt `false` zurück, wo strikte Gleichheit `true` und *umgekehrt* zurückgeben würde. Der strikte Ungleichheitsoperator konvertiert keine Datentypen.
+
+**Beispiele**
+
+```js
+3 !== 3 // false
+3 !== '3' // true
+4 !== 3 // true
+```
+
+# --instructions--
+
+Füge den strikten Ungleichheitsoperator zu der `if`-Anweisung hinzu, damit die Funktion den String `Not Equal` zurückgibt, wenn `val` nicht strikt gleich `17` ist
+
+# --hints--
+
+`testStrictNotEqual(17)` sollte den String `Equal` zurückgeben
+
+```js
+assert(testStrictNotEqual(17) === 'Equal');
+```
+
+`testStrictNotEqual("17")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testStrictNotEqual('17') === 'Not Equal');
+```
+
+`testStrictNotEqual(12)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testStrictNotEqual(12) === 'Not Equal');
+```
+
+`testStrictNotEqual("bob")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(testStrictNotEqual('bob') === 'Not Equal');
+```
+
+Du solltest den Operator `!==` verwenden
+
+```js
+assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrictNotEqual(val) {
+ if (val) { // Change this line
+ return "Not Equal";
+ }
+ return "Equal";
+}
+
+testStrictNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testStrictNotEqual(val) {
+ if (val !== 17) {
+ return "Not Equal";
+ }
+ return "Equal";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
new file mode 100644
index 00000000000..6ca1912e656
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
@@ -0,0 +1,130 @@
+---
+id: 56533eb9ac21ba0edf2244d8
+title: Vergleiche mit dem logischen Und-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvbRVtr'
+forumTopicId: 16799
+dashedName: comparisons-with-the-logical-and-operator
+---
+
+# --description--
+
+Manchmal musst du mehr als eine Sache auf einmal testen. Der logische Und -Operator (`&&`) gibt `true` zurück, wenn und nur wenn die Operanden links und rechts von ihm wahr sind.
+
+Den gleichen Effekt kannst du erzielen, indem du eine if-Anweisung in eine andere if-Anweisung verschachtelst:
+
+```js
+if (num > 5) {
+ if (num < 10) {
+ return "Yes";
+ }
+}
+return "No";
+```
+
+gibt nur `Yes` zurück, wenn `num` größer als `5` und kleiner als `10` ist. Die gleiche Logik lässt sich wie folgt formulieren:
+
+```js
+if (num > 5 && num < 10) {
+ return "Yes";
+}
+return "No";
+```
+
+# --instructions--
+
+Ersetze die beiden if-Anweisungen durch eine Anweisung mit dem `&&`-Operator, die den String `Yes` zurückgibt, wenn `val` kleiner als oder gleich `50` und größer als oder gleich `25` ist. Andernfalls wird der String `No` zurückgegeben.
+
+# --hints--
+
+Du solltest den `&&`-Operator einmal verwenden
+
+```js
+assert(code.match(/&&/g).length === 1);
+```
+
+Du solltest nur eine `if`-Anweisung verwenden
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalAnd(0)` sollte den String `No` zurückgeben
+
+```js
+assert(testLogicalAnd(0) === 'No');
+```
+
+`testLogicalAnd(24)` sollte den String `No` zurückgeben
+
+```js
+assert(testLogicalAnd(24) === 'No');
+```
+
+`testLogicalAnd(25)` sollte den String `Yes` zurückgeben
+
+```js
+assert(testLogicalAnd(25) === 'Yes');
+```
+
+`testLogicalAnd(30)` sollte den String `Yes` zurückgeben
+
+```js
+assert(testLogicalAnd(30) === 'Yes');
+```
+
+`testLogicalAnd(50)` sollte den String `Yes` zurückgeben
+
+```js
+assert(testLogicalAnd(50) === 'Yes');
+```
+
+`testLogicalAnd(51)` sollte den String `No` zurückgeben
+
+```js
+assert(testLogicalAnd(51) === 'No');
+```
+
+`testLogicalAnd(75)` sollte den String `No` zurückgeben
+
+```js
+assert(testLogicalAnd(75) === 'No');
+```
+
+`testLogicalAnd(80)` sollte den String `No` zurückgeben
+
+```js
+assert(testLogicalAnd(80) === 'No');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalAnd(val) {
+ // Only change code below this line
+
+ if (val) {
+ if (val) {
+ return "Yes";
+ }
+ }
+
+ // Only change code above this line
+ return "No";
+}
+
+testLogicalAnd(10);
+```
+
+# --solutions--
+
+```js
+function testLogicalAnd(val) {
+ if (val >= 25 && val <= 50) {
+ return "Yes";
+ }
+ return "No";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
new file mode 100644
index 00000000000..86cbc5abf32
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
@@ -0,0 +1,135 @@
+---
+id: 56533eb9ac21ba0edf2244d9
+title: Vergleiche mit dem logischen Oder-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEPrGTN'
+forumTopicId: 16800
+dashedName: comparisons-with-the-logical-or-operator
+---
+
+# --description--
+
+Der logische Oder -Operator (`||`) gibt `true` zurück, wenn einer der Operanden `true` ist. Andernfalls wird `false` zurückgegeben.
+
+Der logische Oder -Operator besteht aus zwei Pipe-Symbolen: (`||`). Diese befindet sich normalerweise zwischen der Backspace- und der Enter-Taste.
+
+Das folgende Muster sollte dir von früheren Hinweisen bekannt vorkommen:
+
+```js
+if (num > 10) {
+ return "No";
+}
+if (num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+gibt nur dann `Yes` zurück, wenn `num` zwischen `5` und `10` liegt (einschließlich 5 und 10). Die gleiche Logik lässt sich wie folgt formulieren:
+
+```js
+if (num > 10 || num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+# --instructions--
+
+Kombiniere die beiden `if`-Anweisungen zu einer Anweisung, die den String `Outside` zurückgibt, wenn `val` nicht zwischen `10` und `20` liegt, einschließlich (10 und 20). Andernfalls wird der String `Inside` zurückgegeben.
+
+# --hints--
+
+Du solltest den Operator `||` einmal verwenden
+
+```js
+assert(code.match(/\|\|/g).length === 1);
+```
+
+Du solltest nur eine `if`-Anweisung verwenden
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalOr(0)` sollte den String `Outside` zurückgeben
+
+```js
+assert(testLogicalOr(0) === 'Outside');
+```
+
+`testLogicalOr(9)` sollte den String `Outside` zurückgeben
+
+```js
+assert(testLogicalOr(9) === 'Outside');
+```
+
+`testLogicalOr(10)` sollte den String `Inside` zurückgeben
+
+```js
+assert(testLogicalOr(10) === 'Inside');
+```
+
+`testLogicalOr(15)` sollte den String `Inside` zurückgeben
+
+```js
+assert(testLogicalOr(15) === 'Inside');
+```
+
+`testLogicalOr(19)` sollte den String `Inside` zurückgeben
+
+```js
+assert(testLogicalOr(19) === 'Inside');
+```
+
+`testLogicalOr(20)` sollte den String `Inside` zurückgeben
+
+```js
+assert(testLogicalOr(20) === 'Inside');
+```
+
+`testLogicalOr(21)` sollte den String `Outside` zurückgeben
+
+```js
+assert(testLogicalOr(21) === 'Outside');
+```
+
+`testLogicalOr(25)` sollte den String `Outside` zurückgeben
+
+```js
+assert(testLogicalOr(25) === 'Outside');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalOr(val) {
+ // Only change code below this line
+
+ if (val) {
+ return "Outside";
+ }
+
+ if (val) {
+ return "Outside";
+ }
+
+ // Only change code above this line
+ return "Inside";
+}
+
+testLogicalOr(15);
+```
+
+# --solutions--
+
+```js
+function testLogicalOr(val) {
+ if (val < 10 || val > 20) {
+ return "Outside";
+ }
+ return "Inside";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
new file mode 100644
index 00000000000..98560d205c5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
@@ -0,0 +1,101 @@
+---
+id: 56533eb9ac21ba0edf2244af
+title: Kombination von Zuordnung und Addition
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDR6LCb'
+forumTopicId: 16661
+dashedName: compound-assignment-with-augmented-addition
+---
+
+# --description--
+
+In der Programmierung ist es üblich, Zuweisungen zu verwenden, um den Inhalt einer Variablen zu ändern. Denke daran, dass alles, was rechts des Gleichheitszeichens steht, zuerst ausgewertet wird, so dass wir sagen können:
+
+```js
+myVar = myVar + 5;
+```
+
+um `5` zu `myVar` hinzuzufügen. Da dies ein so häufiges Muster ist, gibt es Operatoren, die sowohl eine mathematische Operation als auch eine Zuweisung in einem Schritt durchführen.
+
+Ein solcher Operator ist der Operator `+=`.
+
+```js
+let myVar = 1;
+myVar += 5;
+console.log(myVar);
+```
+
+`6` würde in der Konsole angezeigt werden.
+
+# --instructions--
+
+Ändere die Zuweisungen für `a`, `b` und `c`, um den Operator `+=` zu verwenden.
+
+# --hints--
+
+`a` sollte gleich `15` sein.
+
+```js
+assert(a === 15);
+```
+
+`b` sollte gleich `26` sein.
+
+```js
+assert(b === 26);
+```
+
+`c` sollte gleich `19` sein.
+
+```js
+assert(c === 19);
+```
+
+Du solltest den Operator `+=` für jede Variable verwenden.
+
+```js
+assert(code.match(/\+=/g).length === 3);
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht verändern.
+
+```js
+assert(
+ /let a = 3;/.test(code) &&
+ /let b = 17;/.test(code) &&
+ /let c = 12;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+// Only change code below this line
+a = a + 12;
+b = 9 + b;
+c = c + 7;
+```
+
+# --solutions--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+a += 12;
+b += 9;
+c += 7;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
new file mode 100644
index 00000000000..c2acee82a4e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b2
+title: Kombination von Zuordnung und Division
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvKT2'
+forumTopicId: 16659
+dashedName: compound-assignment-with-augmented-division
+---
+
+# --description--
+
+Der Operator `/=` teilt eine Variable durch eine andere Zahl.
+
+```js
+myVar = myVar / 5;
+```
+
+Teilt `myVar` durch `5`. Dies kann wie folgt umgeschrieben werden:
+
+```js
+myVar /= 5;
+```
+
+# --instructions--
+
+Ändere die Zuweisungen für `a`, `b` und `c` so, dass sie den Operator `/=` verwenden.
+
+# --hints--
+
+`a` sollte gleich `4` sein.
+
+```js
+assert(a === 4);
+```
+
+`b` sollte gleich `27` sein.
+
+```js
+assert(b === 27);
+```
+
+`c` sollte gleich `3` sein.
+
+```js
+assert(c === 3);
+```
+
+Du solltest für jede Variable den Operator `/=` verwenden.
+
+```js
+assert(code.match(/\/=/g).length === 3);
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht verändern.
+
+```js
+assert(
+ /let a = 48;/.test(code) &&
+ /let b = 108;/.test(code) &&
+ /let c = 33;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+// Only change code below this line
+a = a / 12;
+b = b / 4;
+c = c / 11;
+```
+
+# --solutions--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+a /= 12;
+b /= 4;
+c /= 11;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
new file mode 100644
index 00000000000..a63816942f4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b1
+title: Kombination von Zuordnung und Multiplikation
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c83vrfa'
+forumTopicId: 16662
+dashedName: compound-assignment-with-augmented-multiplication
+---
+
+# --description--
+
+Der Operator `*=` multipliziert eine Variable mit einer Zahl.
+
+```js
+myVar = myVar * 5;
+```
+
+multipliziert `myVar` mit `5`. Dies kann wie folgt umgeschrieben werden:
+
+```js
+myVar *= 5;
+```
+
+# --instructions--
+
+Ändere die Zuweisungen für `a`, `b` und `c` so, dass sie den Operator `*=` verwenden.
+
+# --hints--
+
+`a` sollte gleich `25` sein.
+
+```js
+assert(a === 25);
+```
+
+`b` sollte gleich `36` sein.
+
+```js
+assert(b === 36);
+```
+
+`c` sollte gleich `46` sein.
+
+```js
+assert(c === 46);
+```
+
+Du solltest den Operator `*=` für jede Variable verwenden.
+
+```js
+assert(code.match(/\*=/g).length === 3);
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht verändern.
+
+```js
+assert(
+ /let a = 5;/.test(code) &&
+ /let b = 12;/.test(code) &&
+ /let c = 4\.6;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+// Only change code below this line
+a = a * 5;
+b = 3 * b;
+c = c * 10;
+```
+
+# --solutions--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+a *= 5;
+b *= 3;
+c *= 10;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
new file mode 100644
index 00000000000..fa833d88dd3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244b0
+title: Kombination von Zuordnung und Subtraktion
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2Qv7AV'
+forumTopicId: 16660
+dashedName: compound-assignment-with-augmented-subtraction
+---
+
+# --description--
+
+Ähnlich dem Operator `+=`, subtrahiert `-=` eine Zahl von einer Variablen.
+
+```js
+myVar = myVar - 5;
+```
+
+subtrahiert `5` von `myVar`. Dies kann wie folgt umgeschrieben werden:
+
+```js
+myVar -= 5;
+```
+
+# --instructions--
+
+Ändere die Zuweisungen für `a`, `b` und `c` so, dass sie den Operator `-=` verwenden.
+
+# --hints--
+
+`a` sollte gleich `5` sein.
+
+```js
+assert(a === 5);
+```
+
+`b` sollte gleich `-6` sein.
+
+```js
+assert(b === -6);
+```
+
+`c` sollte gleich `2` sein.
+
+```js
+assert(c === 2);
+```
+
+Du solltest den Operator `-=` für jede Variable verwenden.
+
+```js
+assert(code.match(/-=/g).length === 3);
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht verändern.
+
+```js
+assert(
+ /let a = 11;/.test(code) && /let b = 9;/.test(code) && /let c = 3;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+// Only change code below this line
+a = a - 6;
+b = b - 15;
+c = c - 1;
+```
+
+# --solutions--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+a -= 6;
+b -= 15;
+c -= 1;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
new file mode 100644
index 00000000000..5c71bb2d973
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
@@ -0,0 +1,89 @@
+---
+id: 56533eb9ac21ba0edf2244b7
+title: Verkettung von Zeichenketten mit Plus-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNpM8AN'
+forumTopicId: 16802
+dashedName: concatenating-strings-with-plus-operator
+---
+
+# --description--
+
+Wenn in JavaScript der Operator `+` mit einem `String`-Wert verwendet wird, nennt man ihn den Verkettungsoperator . Du kannst einen neuen String aus anderen Strings zusammensetzen, indem du sie verkettest .
+
+**Beispiel**
+
+```js
+'My name is Alan,' + ' I concatenate.'
+```
+
+**Hinweis:** Achte auf Leerzeichen. Bei der Verkettung werden keine Leerzeichen zwischen den verketteten Zeichenfolgen eingefügt, so dass Sie diese selbst hinzufügen müssen.
+
+Beispiel:
+
+```js
+const ourStr = "I come first. " + "I come second.";
+```
+
+Der String `I come first. I come second.` würde in der Konsole angezeigt werden.
+# --instructions--
+
+Erstelle `myStr` aus den Strings `This is the start.` und `This is the end.` mit dem Operator `+`. Achte darauf, dass zwischen den beiden Strings ein Leerzeichen steht.
+
+# --hints--
+
+`myStr` sollte ein einzelnes Leerzeichen zwischen beiden Strings enthalten.
+
+```js
+assert(/start\. This/.test(myStr));
+```
+
+`myStr` sollte auf den String-Wert `This is the start. This is the end.` gesetzt sein
+
+```js
+assert(myStr === 'This is the start. This is the end.');
+```
+
+Du solltest den Operator `+` zur Kreierung von `myStr` verwenden.
+
+```js
+assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
+```
+
+`myStr` sollte mit dem Schlüsselwort `const` erstellt werden.
+
+```js
+assert(/const\s+myStr/.test(code));
+```
+
+Das Ergebnis solltest du der Variable `myStr` zuweisen.
+
+```js
+assert(/myStr\s*=/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ return 'myStr = "' + myStr + '"';
+ } else {
+ return 'myStr is not a string';
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "This is the start. " + "This is the end.";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
new file mode 100644
index 00000000000..28a8070607a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
@@ -0,0 +1,74 @@
+---
+id: 56533eb9ac21ba0edf2244b8
+title: Verkettung von Strings mit dem Plus-Gleich-Operator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmmC4'
+forumTopicId: 16803
+dashedName: concatenating-strings-with-the-plus-equals-operator
+---
+
+# --description--
+
+Wir können auch den Operator `+=` verwenden, um einen String an das Ende einer bestehenden String-Variablen zu verketten . Dies kann sehr hilfreich sein, um einen langen String auf mehrere Zeilen zu verteilen.
+
+**Hinweis:** Achte auf die Leerzeichen. Bei der Verkettung werden keine Leerzeichen zwischen den verketteten Strings eingefügt, so dass du sie selbst hinzufügen musst.
+
+Beispiel:
+
+```js
+let ourStr = "I come first. ";
+ourStr += "I come second.";
+```
+
+`ourStr` hat jetzt einen Wert des Strings `I come first. I come second.`.
+
+# --instructions--
+
+Erstelle `myStr` über mehrere Zeilen, indem du diese beiden Strings verkettest: `This is the first sentence.` und `This is the second sentence.` mit Hilfe des Operators `+=`. Verwende den Operator `+=` ähnlich wie im Beispiel und achte darauf, dass ein Leerzeichen zwischen den beiden Strings steht. Weise zunächst den ersten String `myStr` zu und füge dann den zweiten String hinzu.
+
+# --hints--
+
+`myStr` sollte ein einzelnes Leerzeichen zwischen beiden Strings enthalten.
+
+```js
+assert(/sentence\. This/.test(myStr));
+```
+
+`myStr` sollte auf den Wert des Strings `This is the first sentence. This is the second sentence.` gesetzt sein.
+
+```js
+assert(myStr === 'This is the first sentence. This is the second sentence.');
+```
+
+Du solltest den Operator `+=` zur Kreierung von `myStr` verwenden.
+
+```js
+assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ return 'myStr = "' + myStr + '"';
+ } else {
+ return 'myStr is not a string';
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+let myStr;
+```
+
+# --solutions--
+
+```js
+let myStr = "This is the first sentence. ";
+myStr += "This is the second sentence.";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
new file mode 100644
index 00000000000..de29040a340
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b9
+title: Strings mit Variablen erstellen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqk8rf4'
+forumTopicId: 16805
+dashedName: constructing-strings-with-variables
+---
+
+# --description--
+
+Manchmal musst du einen String erstellen. Mit dem Verkettungsoperator (`+`) kannst du eine oder mehrere Variablen in einen String einfügen, den du erstellst.
+
+Beispiel:
+
+```js
+const ourName = "freeCodeCamp";
+const ourStr = "Hello, our name is " + ourName + ", how are you?";
+```
+
+`ourStr` hätte einen Wert des Strings `Hello, our name is freeCodeCamp, how are you?`.
+
+# --instructions--
+
+Setze `myName` auf einen String, der deinem Namen entspricht, und bilde `myStr` mit `myName` zwischen den Strings `My name is` und `and I am well!`
+
+# --hints--
+
+`myName` sollte auf einen String mit mindestens 3 Zeichen Länge gesetzt werden.
+
+```js
+assert(typeof myName !== 'undefined' && myName.length > 2);
+```
+
+Du solltest zwei Operatoren `+` verwenden, um `myStr` mit `myName` darin zu bilden.
+
+```js
+assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ var output = [];
+ if(typeof myName === 'string') {
+ output.push('myName = "' + myName + '"');
+ } else {
+ output.push('myName is not a string');
+ }
+ if(typeof myStr === 'string') {
+ output.push('myStr = "' + myStr + '"');
+ } else {
+ output.push('myStr is not a string');
+ }
+ return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myName = "";
+const myStr = "";
+```
+
+# --solutions--
+
+```js
+const myName = "Bob";
+const myStr = "My name is " + myName + " and I am well!";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
new file mode 100644
index 00000000000..bef2e5af253
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
@@ -0,0 +1,77 @@
+---
+id: 56105e7b514f539506016a5e
+title: Rückwärts zählen mit einer for-Schleife
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2R6BHa'
+forumTopicId: 16808
+dashedName: count-backwards-with-a-for-loop
+---
+
+# --description--
+
+Eine for-Schleife kann auch rückwärts zählen, solange wir die richtigen Bedingungen definieren können.
+
+Um jede Iteration um zwei zu dekrementieren, müssen wir unsere Initialisierung, die Bedingung und den abschließenden Ausdruck ändern.
+
+Wir beginnen bei `i = 10` und machen eine Schleife, solange `i > 0`. Wir werden `i` in jeder Schleife mit `i -= 2` um 2 dekrementieren.
+
+```js
+const ourArray = [];
+
+for (let i = 10; i > 0; i -= 2) {
+ ourArray.push(i);
+}
+```
+
+`ourArray` wird jetzt `[10, 8, 6, 4, 2]` enthalten. Ändern wir unseren Initialisierungs- und Abschlussausdruck so, dass wir in Zweierschritten rückwärts zählen können, um ein Array mit absteigenden ungeraden Zahlen zu erstellen.
+
+# --instructions--
+
+Füge die ungeraden Zahlen von 9 bis 1 in `myArray` ein und verwende dazu eine `for`-Schleife.
+
+# --hints--
+
+Du solltest dafür eine `for`-Schleife verwenden.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+Du solltest die Array-Methode `push` verwenden.
+
+```js
+assert(code.match(/myArray.push/));
+```
+
+`myArray` sollte gleich `[9, 7, 5, 3, 1]` sein.
+
+```js
+assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 9; i > 0; i -= 2) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md
new file mode 100644
index 00000000000..a2332d1367d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md
@@ -0,0 +1,214 @@
+---
+id: 565bbe00e9cc8ac0725390f4
+title: Karten zählen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KE7ty'
+forumTopicId: 16809
+dashedName: counting-cards
+---
+
+# --description--
+
+Beim Kasinospiel Blackjack kann ein Spieler, indem er die relative Anzahl der im Deck verbliebenen hohen und niedrigen Karten im Auge behält, herausfinden, ob er in der nächsten Runde über einen Vorteil gegenüber dem Haus verfügt. Das nennt man das Zählen von Karten.
+
+Wenn mehr hohe Karten im Deck verbleiben, ist der Spieler im Vorteil. Jeder Karte wird ein Wert gemäß der folgenden Tabelle zugewiesen. Wenn die Zählung positiv ist, sollte der Spieler hoch setzen. Wenn die Anzahl null oder negativ ist, sollte der Spieler niedrig setzen.
+
+Veränderung der Zählung Karten +1 2, 3, 4, 5, 6 0 7, 8, 9 -1 10, 'J', 'Q', 'K', 'A'
+
+Du wirst eine Funktion zum Zählen von Karten schreiben. Sie erhält einen `card`-Parameter, der eine Zahl oder ein String sein kann, und erhöht oder verringert die globale `count`-Variable entsprechend dem Wert der Karte (siehe Tabelle). Die Funktion gibt dann einen String mit dem aktuellen Zählerstand und dem String `Bet` zurück, wenn der Zählerstand positiv ist, oder `Hold`, wenn der Zählerstand null oder negativ ist. Die aktuelle Anzahl und die Entscheidung des Spielers (`Bet` oder `Hold`) sollten durch ein einzelnes Leerzeichen getrennt werden.
+
+**Beispielausgaben:** `-3 Hold` oder `5 Bet`
+
+**Hinweis**
+Setze `count` NICHT auf 0 zurück, wenn der Wert 7, 8 oder 9 ist. Gib KEIN Array zurück.
+Die Ausgabe darf KEINE Anführungszeichen (einfach oder doppelt) enthalten.
+
+# --hints--
+
+Deine Funktion sollte einen Wert für die Anzahl und den Text (`Bet` oder `Hold`), mit einem Leerzeichen dazwischen, zurückgeben.
+
+```js
+assert(//
+ (function () {
+ count = 0;
+ let out = cc(10);
+ const hasSpace = /-?\d+ (Bet|Hold)/.test('' + out);
+ return hasSpace;
+ })()
+);
+```
+
+Die Kartenfolge 2, 3, 4, 5, 6 sollte den String `5 Bet` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc(3);
+ cc(4);
+ cc(5);
+ var out = cc(6);
+ if (out === '5 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 7, 8, 9 sollte den String `0 Hold` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(7);
+ cc(8);
+ var out = cc(9);
+ if (out === '0 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 10, J, Q, K, A sollte den String `-5 Hold` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(10);
+ cc('J');
+ cc('Q');
+ cc('K');
+ var out = cc('A');
+ if (out === '-5 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 3, 7, Q, 8, A sollte den String `-1 Hold` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(3);
+ cc(7);
+ cc('Q');
+ cc(8);
+ var out = cc('A');
+ if (out === '-1 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 2, J, 9, 2, 7 sollte den String `1 Bet` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc('J');
+ cc(9);
+ cc(2);
+ var out = cc(7);
+ if (out === '1 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 2, 2, 10 sollte den String `1 Bet` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc(2);
+ var out = cc(10);
+ if (out === '1 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+Die Kartenfolge 3, 2, A, 10, K sollte den String `-1 Hold` zurückgeben
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(3);
+ cc(2);
+ cc('A');
+ cc(10);
+ var out = cc('K');
+ if (out === '-1 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let count = 0;
+
+function cc(card) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+cc(2); cc(3); cc(7); cc('K'); cc('A');
+```
+
+# --solutions--
+
+```js
+let count = 0;
+function cc(card) {
+ switch(card) {
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ count++;
+ break;
+ case 10:
+ case 'J':
+ case 'Q':
+ case 'K':
+ case 'A':
+ count--;
+ }
+ if(count > 0) {
+ return count + " Bet";
+ } else {
+ return count + " Hold";
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
new file mode 100644
index 00000000000..17fc41d5968
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
@@ -0,0 +1,55 @@
+---
+id: cf1391c1c11feddfaeb4bdef
+title: Dezimalzahlen mit JavaScript erstellen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GEuW'
+forumTopicId: 16826
+dashedName: create-decimal-numbers-with-javascript
+---
+
+# --description--
+
+Wir können auch Dezimalzahlen in Variablen speichern. Dezimalzahlen werden manchmal auch als Gleitkommazahlen oder floats bezeichnet.
+
+**Hinweis:** Wenn du Zahlen berechnest, geschieht das mit begrenzter Genauigkeit. Berechnungen mit Gleitkommazahlen können zu unerwünschten Ergebnissen führen. Erhältst du ein solches Ergebnis, kannst du einen Thread im freeCodeCamp-Forum erstellen.
+
+# --instructions--
+
+Erstelle eine Variable `myDecimal` und gib ihr einen Dezimalwert mit einer Nachkommastelle (z.B. `5.7`).
+
+# --hints--
+
+`myDecimal` sollte eine Zahl sein.
+
+```js
+assert(typeof myDecimal === 'number');
+```
+
+`myDecimal` sollte einen Dezimalpunkt enthalten
+
+```js
+assert(myDecimal % 1 != 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
+```
+
+## --seed-contents--
+
+```js
+const ourDecimal = 5.7;
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDecimal = 9.9;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
new file mode 100644
index 00000000000..5418814102e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md
@@ -0,0 +1,88 @@
+---
+id: 587d7b87367417b2b2512b41
+title: Deklariere eine schreibgeschützte Variable mit dem Schlüsselwort const
+challengeType: 1
+forumTopicId: 301201
+dashedName: declare-a-read-only-variable-with-the-const-keyword
+---
+
+# --description--
+
+Das Schlüsselwort `let` ist nicht die einzige neue Möglichkeit, Variablen zu deklarieren. In ES6 kannst du Variablen auch mit dem Schlüsselwort `const` deklarieren.
+
+`const` hat die gleichen tollen Funktionen die auch `let` hat, mit dem zusätzlichen Vorteil, dass Variablen, die mit `const` deklariert werden, schreibgeschützt sind. Sie sind ein konstanter Wert, was bedeutet, dass eine Variable, die einmal mit `const` zugewiesen wurde, nicht mehr neu zugewiesen werden kann:
+
+```js
+const FAV_PET = "Cats";
+FAV_PET = "Dogs";
+```
+
+Die Konsole zeigt einen Fehler an, weil der Wert von `FAV_PET` neu zugewiesen wurde.
+
+Du solltest Variablen, die du nicht neu zuweisen willst, immer mit dem Schlüsselwort `const` benennen. Das hilft, wenn du versehentlich versuchst, eine Variable neu zuzuweisen, die eigentlich konstant bleiben soll.
+
+**Hinweis:** Es ist üblich, dass Entwickler für unveränderliche Werte Variablenbezeichnungen in Großbuchstaben schreiben und für Werte, die verändert werden können (Objekte und Arrays), Kleinbuchstaben oder CamelCase verwenden. In späteren Aufgaben wirst du mehr über Objekte, Arrays und veränderliche bzw. unveränderliche Werte erfahren. Du wirst dort ebenfalls mit Beispielen für Variablenbezeichnungen in Großbuchstaben, Kleinbuchstaben oder CamelCase vertraut gemacht.
+
+# --instructions--
+
+Verändere den Code so, dass alle Variablen mit `let` oder `const` deklariert werden. Nutze `let` wenn du willst, dass sich die Variable verändert und nutze `const`, wenn die Variable konstant bleiben soll. Benenne mit `const` deklarierte Variablen um, damit diese gängigen Standards entsprechen. Verändere keine den Variablen zugewiesenen Strings.
+
+# --hints--
+
+`var` sollte in deinem Code nicht vorkommen.
+
+```js
+assert.notMatch(code, /var/g);
+```
+
+Du solltest `fCC` komplett in Großbuchtsaben schreiben.
+
+```js
+assert.match(code, /(FCC)/);
+assert.notMatch(code, /(fCC)/);
+```
+
+`FCC` sollte eine konstante Variable sein, die mit `const` deklariert wurde.
+
+```js
+assert.match(code, /const\s+FCC/);
+```
+
+Der an `FCC` zugewiesene String sollte nicht verändert werden.
+
+```js
+assert.equal(FCC, 'freeCodeCamp');
+```
+
+`fact` sollte mit `let` deklariert werden.
+
+```js
+assert.match(code, /(let\s+fact)/g);
+```
+
+`console.log` sollte so verändert werden, dass die Variablen `FCC` und `fact` ausgegeben werden.
+
+```js
+assert.match(code, /console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var fCC = "freeCodeCamp"; // Change this line
+var fact = "is cool!"; // Change this line
+fact = "is awesome!";
+console.log(fCC, fact); // Change this line
+```
+
+# --solutions--
+
+```js
+const FCC = "freeCodeCamp";
+let fact = "is cool!";
+
+fact = "is awesome!";
+console.log(FCC, fact);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
new file mode 100644
index 00000000000..42177c32c9f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
@@ -0,0 +1,61 @@
+---
+id: bd7123c9c443eddfaeb5bdef
+title: JavaScript-Variablen deklarieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNanrHq'
+forumTopicId: 17556
+dashedName: declare-javascript-variables
+---
+
+# --description--
+
+In der Informatik versteht man unter Daten alles, was für den Computer von Bedeutung ist. JavaScript bietet acht verschiedene Datentypen , nämlich `undefined`, `null`, `boolean`, `string`, `symbol`, `bigint`, `number`, und `object`.
+
+Computer unterscheiden zum Beispiel zwischen Zahlen, wie der Zahl `12`, und `strings`, wie `"12"`, `"dog"` oder `"123 cats"`, die Sammlungen von Zeichen sind. Computer können mathematische Operationen mit einer Zahl durchführen, aber nicht mit einem String (Zeichenkette).
+
+Variablen ermöglichen es Computern, Daten auf dynamische Weise zu speichern und zu bearbeiten. Sie tun dies, indem sie ein "Etikett" verwenden, um auf die Daten hinzuweisen, anstatt die Daten selbst zu verwenden. Jeder der acht Datentypen kann in einer Variablen gespeichert werden.
+
+Variablen ähneln den x- und y-Variablen, die du in der Mathematik verwendest, d. h. sie sind ein einfacher Name, um die Daten zu repräsentieren, auf die wir uns beziehen wollen. Computervariablen unterscheiden sich von mathematischen Variablen dadurch, dass sie verschiedene Werte zu verschiedenen Zeiten speichern können.
+
+Wir sagen JavaScript, dass es eine Variable erstellen oder deklarieren soll, indem wir das Schlüsselwort `var` davor setzen, etwa so:
+
+```js
+var ourName;
+```
+
+erstellt eine Variable namens `ourName`. In JavaScript beenden wir Anweisungen (Statements) mit Semikolons. Variablennamen können aus Zahlen, Buchstaben und `$` oder `_` bestehen, dürfen aber keine Leerzeichen enthalten oder mit einer Zahl beginnen.
+
+# --instructions--
+
+Verwende das Schlüsselwort `var`, um eine Variable namens `myName` zu erstellen.
+
+**Hinweis**
+Schaue dir das `ourName`-Beispiel oben an, wenn du nicht weiterkommst.
+
+# --hints--
+
+Du solltest `myName` mit dem Schlüsselwort `var` deklarieren und mit einem Semikolon abschließen
+
+```js
+assert(/var\s+myName\s*;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myName;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
new file mode 100644
index 00000000000..ffd470e19db
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
@@ -0,0 +1,87 @@
+---
+id: bd7123c9c444eddfaeb5bdef
+title: String-Variablen deklarieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvWU6'
+forumTopicId: 17557
+dashedName: declare-string-variables
+---
+
+# --description--
+
+Zuvor hast du den folgenden Code verwendet, um eine Variable zu deklarieren:
+
+```js
+var myName;
+```
+
+Du kannst aber auch eine String-Variable wie folgt deklarieren:
+
+```js
+var myName = "your name";
+```
+
+`"your name"` wird als String literal bezeichnet. Ein String-Literal oder String ist eine Reihe von null oder mehr Zeichen, die in einfache oder doppelte Anführungszeichen eingeschlossen sind.
+
+# --instructions--
+
+Erstelle zwei neue String-Variablen: `myFirstName` und `myLastName` und weise ihnen die Werte deines Vor- bzw. Nachnamens zu.
+
+# --hints--
+
+`myFirstName` sollte ein String sein, der mindestens ein Zeichen enthält.
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myFirstName !== 'undefined' &&
+ typeof myFirstName === 'string' &&
+ myFirstName.length > 0
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+`myLastName` sollte ein String sein, der mindestens ein Zeichen enthält.
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myLastName !== 'undefined' &&
+ typeof myLastName === 'string' &&
+ myLastName.length > 0
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myFirstName = "Alan";
+var myLastName = "Turing";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
new file mode 100644
index 00000000000..df144dbe521
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
@@ -0,0 +1,84 @@
+---
+id: 56533eb9ac21ba0edf2244ad
+title: Dekrementieren einer Zahl mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KeS2'
+forumTopicId: 17558
+dashedName: decrement-a-number-with-javascript
+---
+
+# --description--
+
+Mit dem Operator `--` kannst du eine Variable einfach dekrementieren oder um eins verringern.
+
+```js
+i--;
+```
+
+ist das Äquivalent zu
+
+```js
+i = i - 1;
+```
+
+**Hinweis:** Die gesamte Zeile wird zu `i--;`, wodurch das Gleichheitszeichen überflüssig wird.
+
+# --instructions--
+
+Ändere den Code, um den `--` Operator auf `myVar` anzuwenden.
+
+# --hints--
+
+`myVar` sollte gleich `10` sein.
+
+```js
+assert(myVar === 10);
+```
+
+`myVar = myVar - 1;` sollte geändert werden.
+
+```js
+assert(!code.match(/myVar\s*=\s*myVar\s*[-]\s*1.*?;?/));
+```
+
+Du solltest `myVar` keine `10` zuordnen.
+
+```js
+assert(!code.match(/myVar\s*=\s*10.*?;?/));
+```
+
+Du solltest den `--` Operator auf `myVar` anwenden.
+
+```js
+assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(/let myVar = 11;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 11;
+
+// Only change code below this line
+myVar = myVar - 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 11;
+myVar--;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
new file mode 100644
index 00000000000..1e1cb464540
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
@@ -0,0 +1,96 @@
+---
+id: 56bbb991ad1ed5201cd392d3
+title: Eigenschaften eines JavaScript-Objekts löschen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqKdTv'
+forumTopicId: 17560
+dashedName: delete-properties-from-a-javascript-object
+---
+
+# --description--
+
+Wir können auch Eigenschaften von Objekten folgendermaßen löschen:
+
+```js
+delete ourDog.bark;
+```
+
+Beispiel:
+
+```js
+const ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"],
+ "bark": "bow-wow"
+};
+
+delete ourDog.bark;
+```
+
+Nach der letzten Zeile oben sieht `ourDog` wie folgt aus:
+
+```js
+{
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+}
+```
+
+# --instructions--
+
+Lösche die Eigenschaft `tails` von `myDog`. Du kannst entweder die Punkt- oder die Klammerschreibweise verwenden.
+
+# --hints--
+
+Du solltest die Eigenschaft `tails` aus `myDog` löschen.
+
+```js
+assert(typeof myDog === 'object' && myDog.tails === undefined);
+```
+
+Du solltest die Einstellungen von `myDog` nicht verändern.
+
+```js
+assert(code.match(/"tails": 1/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"],
+ "bark": "woof"
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"],
+ "bark": "woof"
+};
+delete myDog.tails;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
new file mode 100644
index 00000000000..30acc6e11f5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
@@ -0,0 +1,56 @@
+---
+id: bd7993c9ca9feddfaeb7bdef
+title: Dividieren einer Dezimalzahl durch eine andere mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZe9AW'
+forumTopicId: 18255
+dashedName: divide-one-decimal-by-another-with-javascript
+---
+
+# --description--
+
+Dividieren wir nun eine Dezimalzahl durch eine andere.
+
+# --instructions--
+
+Ändere `0.0`, so dass `quotient` gleich `2.2` wird.
+
+# --hints--
+
+Die Variable `quotient` sollte gleich `2.2` sein.
+
+```js
+assert(quotient === 2.2);
+```
+
+Verwende den Operator `/`, um 4,4 durch 2 zu teilen.
+
+```js
+assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
+```
+
+Die Quotientenvariable sollte nur einmal zugewiesen werden
+
+```js
+assert(code.match(/quotient/g).length === 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'quotient = '+y;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+const quotient = 0.0 / 2.0; // Change this line
+```
+
+# --solutions--
+
+```js
+const quotient = 4.4 / 2.0;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
new file mode 100644
index 00000000000..ea9e0313ff3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb6bdef
+title: Dividieren einer Zahl durch eine andere mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqkbdAr'
+forumTopicId: 17566
+dashedName: divide-one-number-by-another-with-javascript
+---
+
+# --description--
+
+Wir können auch eine Zahl durch eine andere dividieren.
+
+JavaScript verwendet das Symbol `/` für die Division.
+
+**Beispiel**
+
+```js
+const myVar = 16 / 2;
+```
+
+`myVar` hat jetzt den Wert `8`.
+# --instructions--
+
+Ändere die `0` so, dass der `quotient` gleich `2` ist.
+
+# --hints--
+
+Die Variable `quotient` sollte 2 sein.
+
+```js
+assert(quotient === 2);
+```
+
+Du solltest den Operator `/` verwenden.
+
+```js
+assert(/\d+\s*\/\s*\d+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'quotient = '+z;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+const quotient = 66 / 0;
+```
+
+# --solutions--
+
+```js
+const quotient = 66 / 33;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
new file mode 100644
index 00000000000..cf39e6baa62
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
@@ -0,0 +1,99 @@
+---
+id: 56533eb9ac21ba0edf2244b6
+title: Escape-Sequenzen in Strings
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqRh6'
+forumTopicId: 17567
+dashedName: escape-sequences-in-strings
+---
+
+# --description--
+
+Anführungszeichen sind nicht die einzigen Zeichen, die innerhalb eines Strings ausgelassen werden können. Es gibt zwei Gründe für die Verwendung von Escape-Zeichen:
+
+1. Um dir die Möglichkeit zu geben, Zeichen zu verwenden, die du sonst nicht eingeben könntest, wie zum Beispiel einen Wagenrücklauf (carriage return).
+2. Damit kannst du mehrere Anführungszeichen in einem String darstellen, ohne dass JavaScript fehlinterpretiert, was du meinst.
+
+Das haben wir in der letzten Herausforderung gelernt.
+
+Code Ausgabe \'einzelnes Anführungszeichen \"doppeltes Anführungszeichen \\Backslash \nZeilenumbruch \rWagenrücklauf (Carriage Return) \tTabulator \bBackspace \fSeitenvorschub (Formfeed)
+
+*Bitte beachte, dass das Backslash selbst mit einem Escape-Zeichen versehen werden muss, um als Backslash angezeigt zu werden.*
+
+# --instructions--
+
+Weise die folgenden drei Textzeilen der einzelnen Variablen `myStr` mit Hilfe von Escape-Sequenzen zu.
+
+FirstLine
+
+Um Sonderzeichen korrekt einzufügen, musst du Escape-Sequenzen verwenden. Du musst auch die Abstände so einhalten, wie sie oben aussehen, ohne Leerzeichen zwischen Escape-Sequenzen oder Wörtern.
+
+**Hinweis:** Die Einrückung für `SecondLine` wird mit dem Tabulator-Escape-Zeichen erreicht, nicht mit Leerzeichen.
+
+# --hints--
+
+`myStr` sollte keine Leerzeichen enthalten
+
+```js
+assert(!/ /.test(myStr));
+```
+
+`myStr` sollte die Strings `FirstLine`, `SecondLine` und `ThirdLine` enthalten (Groß- und Kleinschreibung beachten)
+
+```js
+assert(
+ /FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr)
+);
+```
+
+`FirstLine` sollte von einem Zeilenumbruchzeichen `\n` gefolgt werden.
+
+```js
+assert(/FirstLine\n/.test(myStr));
+```
+
+`myStr` sollte ein Tabulatorzeichen `\t` enthalten, das auf ein Zeilenumbruchzeichen folgt
+
+```js
+assert(/\n\t/.test(myStr));
+```
+
+`SecondLine` sollte das Backslash-Zeichen `\` vorangestellt werden.
+
+```js
+assert(/\\SecondLine/.test(myStr));
+```
+
+Zwischen `SecondLine` und `ThirdLine` sollte ein Zeilenumbruch stehen.
+
+```js
+assert(/SecondLine\nThirdLine/.test(myStr));
+```
+
+`myStr` sollte nur die in den Anweisungen angegebenen Zeichen enthalten.
+
+```js
+assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+if (myStr !== undefined){
+console.log('myStr:\n' + myStr);}})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
new file mode 100644
index 00000000000..484fb56706b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244b5
+title: Anführungszeichen in Strings verwenden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvgSr'
+forumTopicId: 17568
+dashedName: escaping-literal-quotes-in-strings
+---
+
+# --description--
+
+Wenn du einen String definierst, musst du ihn mit einem einfachen oder doppelten Anführungszeichen beginnen und beenden. Was passiert, wenn du ein wörtliches Zitat benötigst: `"` oder `'` innerhalb deines Strings?
+
+In JavaScript kannst du ein Anführungszeichen "ausblenden" , indem du einen backslash (`\`) vor das Anführungszeichen stellst.
+
+```js
+const sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+```
+
+Dies signalisiert JavaScript, dass das folgende Anführungszeichen nicht das Ende eines Strings ist, sondern innerhalb des Strings stehen sollte. Wenn du dies auf der Konsole ausgibst, würdest du folgendes erhalten:
+
+```js
+Alan said, "Peter is learning JavaScript".
+```
+
+# --instructions--
+
+Verwende Backlashes , um der Variablen `myStr` einen String zuzuweisen, so dass du ihn auf der Konsole ausgeben kannst:
+
+```js
+I am a "double quoted" string inside "double quotes".
+```
+
+# --hints--
+
+Du solltest zwei doppelte Anführungszeichen (`"`) und vier versteckte doppelte Anführungszeichen (`\"`) verwenden.
+
+```js
+assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
+```
+
+Die Variable `myStr` sollte den folgenden String enthalten: `I am a "double quoted" string inside "double quotes".`
+
+```js
+assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ console.log("myStr = \"" + myStr + "\"");
+ } else {
+ console.log("myStr is undefined");
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "I am a \"double quoted\" string inside \"double quotes\".";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md
new file mode 100644
index 00000000000..2c034b0a587
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b87367417b2b2512b3f
+title: Erkunde die Unterschiede zwischen den Schlüsselwörtern var und let
+challengeType: 1
+forumTopicId: 301202
+dashedName: explore-differences-between-the-var-and-let-keywords
+---
+
+# --description--
+
+Eines der größten Probleme bei der Deklaration von Variablen mit dem Schlüsselwort `var` ist, dass du Variablendeklarationen leicht überschreiben kannst:
+
+```js
+var camper = "James";
+var camper = "David";
+console.log(camper);
+```
+
+In dem obigen Code ist die Variable `camper` ursprünglich als `James` deklariert und wird dann mit der Variable `David` überschrieben. In der Konsole wird dann der String `David` angezeigt.
+
+In einer kleinen Anwendung wirst du möglicherweise nicht auf ein Problem dieser Art stoßen. Aber wenn deine Codebasis größer wird, könntest du versehentlich eine Variable überschreiben, die du nicht überschreiben wolltest. Da dieses Verhalten keine Fehler verursacht, wird die Suche nach dem Fehler und das Beheben des Fehlers schwieriger.
+
+Ein Schlüsselwort namens `let` wurde in ES6 eingeführt, ein wichtiges Update für JavaScript, um dieses potentielle Problem mit dem Schlüsselwort `var` zu lösen. In späteren Aufgaben wirst du weitere ES6-Funktionen kennenlernen.
+
+Wenn du in dem obigen Code `var` durch `let` ersetzt, wird dies zu einem Fehler führen:
+
+```js
+let camper = "James";
+let camper = "David";
+```
+
+Den Fehler kannst du in der Konsole deines Browsers sehen.
+
+Anders als bei `var`, kann bei der Verwendung von `let`, eine Variable mit demselben Namen nur einmal deklariert werden.
+
+# --instructions--
+
+Aktualisiere den Code, so dass es nur das Schlüsselwort `let` verwendet.
+
+# --hints--
+
+`var` sollte in deinem Code nicht existieren.
+
+```js
+assert.notMatch(code, /var/g);
+```
+
+`catName` sollte den String `Oliver` enthalten.
+
+```js
+assert.equal(catName, 'Oliver');
+```
+
+`catSound` sollte den String `Meow!` enthalten
+
+```js
+assert.equal(catSound, 'Meow!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var catName = "Oliver";
+var catSound = "Meow!";
+```
+
+# --solutions--
+
+```js
+let catName = "Oliver";
+let catSound = "Meow!";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
new file mode 100644
index 00000000000..8f3113a1387
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c448eddfaeb5bdef
+title: Ermitteln der Länge eines Strings
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqEAd'
+forumTopicId: 18182
+dashedName: find-the-length-of-a-string
+---
+
+# --description--
+
+Du kannst die Länge eines `String`-Wertes ermitteln, indem du `.length` hinter die String-Variable oder das String-Literal schreibst.
+
+```js
+console.log("Alan Peter".length);
+```
+
+Der Wert `10` würde in der Konsole angezeigt werden. Beachte, dass auch das Leerzeichen zwischen "Alan" und "Peter" gezählt wird.
+
+Wenn wir zum Beispiel eine Variable `const firstName = "Ada"` erstellen, können wir mit der Eigenschaft `firstName.length` herausfinden, wie lang der String `Ada` ist.
+
+# --instructions--
+
+Benutze die `.length`-Eigenschaft, um `lastNameLength` auf die Anzahl der Zeichen in `lastName` zu setzen.
+
+# --hints--
+
+Du solltest die Variablendeklarationen im Abschnitt `// Setup` nicht ändern.
+
+```js
+assert(
+ code.match(/let lastNameLength = 0;/) &&
+ code.match(/const lastName = "Lovelace";/)
+);
+```
+
+`lastNameLength` sollte gleich acht sein.
+
+```js
+assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
+```
+
+Du solltest die Länge von `lastName` erhalten, indem du `.length` wie folgt benutzt: `lastName.length`.
+
+```js
+assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let lastNameLength = 0;
+const lastName = "Lovelace";
+
+// Only change code below this line
+lastNameLength = lastName;
+```
+
+# --solutions--
+
+```js
+let lastNameLength = 0;
+const lastName = "Lovelace";
+lastNameLength = lastName.length;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
new file mode 100644
index 00000000000..0c4655c8ee8
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
@@ -0,0 +1,67 @@
+---
+id: 56533eb9ac21ba0edf2244ae
+title: Finden eines Rests in JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWP24Ub'
+forumTopicId: 18184
+dashedName: finding-a-remainder-in-javascript
+---
+
+# --description--
+
+Der Rest -Operator `%` gibt den Rest der Division von zwei Zahlen an.
+
+**Beispiel**
+
+5 % 2 = 1 weil
+
+**Verwendung**
+In der Mathematik kann man prüfen, ob eine Zahl gerade oder ungerade ist, indem man den Rest der Division der Zahl durch `2` prüft.
+
+17 % 2 = 1 (17 ist ungerade)
+
+**Hinweis:** Der Rest -Operator wird manchmal fälschlicherweise als Modulus-Operator bezeichnet. Es ist dem Modulus sehr ähnlich, funktioniert aber nicht richtig mit negativen Zahlen.
+
+# --instructions--
+
+Setze `remainder` gleich dem Rest von `11` geteilt durch `3` mit dem Rest (`%`) Operator.
+
+# --hints--
+
+Die Variable `remainder` sollte initialisiert werden.
+
+```js
+assert(/(const|let|var)\s+?remainder/.test(code));
+```
+
+Der Wert von `remainder` sollte `2` sein.
+
+```js
+assert(remainder === 2);
+```
+
+Du solltest den Operator `%` verwenden.
+
+```js
+assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'remainder = '+y;})(remainder);
+```
+
+## --seed-contents--
+
+```js
+const remainder = 0;
+```
+
+# --solutions--
+
+```js
+const remainder = 11 % 3;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
new file mode 100644
index 00000000000..0f5edac7bb0
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
@@ -0,0 +1,69 @@
+---
+id: cf1111c1c11feddfaeb9bdef
+title: Generiere zufällige Brüche mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJJs3'
+forumTopicId: 18185
+dashedName: generate-random-fractions-with-javascript
+---
+
+# --description--
+
+Zufallszahlen sind nützlich, um zufälliges Verhalten zu erzeugen.
+
+JavaScript hat eine Funktion `Math.random()`, die eine zufällige Dezimalzahl zwischen `0` (einschließlich) und `1` (ausschließlich) erzeugt. So kann `Math.random()` eine `0` zurückgeben, aber niemals eine `1`.
+
+**Hinweis:** Wie bei Speichern von Werten mit dem Zuweisungsoperator werden alle Funktionsaufrufe aufgelöst, bevor `return` ausgeführt wird, sodass wir den Wert der `Math.random()`-Funktion mittels `return` zurückgeben können.
+
+# --instructions--
+
+Ändere `randomFraction` so, dass es eine Zufallszahl zurückgibt, anstatt `0` zu liefern.
+
+# --hints--
+
+`randomFraction` sollte eine Zufallszahl zurückgeben.
+
+```js
+assert(typeof randomFraction() === 'number');
+```
+
+Die von `randomFraction` zurückgegebene Zahl sollte eine Dezimalzahl sein.
+
+```js
+assert((randomFraction() + '').match(/\./g));
+```
+
+Du solltest `Math.random` verwenden, um die zufällige Dezimalzahl zu erzeugen.
+
+```js
+assert(code.match(/Math\.random/g).length >= 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomFraction();})();
+```
+
+## --seed-contents--
+
+```js
+function randomFraction() {
+
+ // Only change code below this line
+
+ return 0;
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomFraction() {
+ return Math.random();
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
new file mode 100644
index 00000000000..2968ca78645
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
@@ -0,0 +1,90 @@
+---
+id: cf1111c1c12feddfaeb1bdef
+title: Zufällige Ganzzahlen mit JavaScript generieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6bfr'
+forumTopicId: 18186
+dashedName: generate-random-whole-numbers-with-javascript
+---
+
+# --description--
+
+Es ist großartig, dass wir zufällige Dezimalzahlen generieren können, aber es ist noch nützlicher, wenn wir es nutzen, um zufällige ganze Zahlen zu generieren.
+
+Verwende Math.random(), um eine zufällige Dezimalzahl zu erzeugen. Multipliziere diese zufällige Dezimalzahl mit 20. Verwende eine andere Funktion, Math.floor(), um die Zahl auf die nächste ganze Zahl abzurunden. scope auf die Sichtbarkeit von Variablen. Variablen, die außerhalb eines Funktionsblocks definiert werden, haben einen globalen Gültigkeitsbereich. Das heißt, sie sind überall in deinem JavaScript-Code zu sehen.
+
+Variablen, die ohne das Schlüsselwort `let` oder `const` deklariert werden, werden automatisch in dem Bereich `global` erstellt. Dies kann an anderer Stelle in deinem Code oder beim erneuten Ausführen einer Funktion unbeabsichtigte Folgen haben. Du solltest deine Variablen immer mit `let` oder `const` deklarieren.
+
+# --instructions--
+
+Benutze `let` oder `const`, um eine globale Variable namens `myGlobal` außerhalb jeglicher Funktion zu deklarieren. Initialisiere sie mit einem Wert von `10`.
+
+Weise innerhalb der Funktion `fun1`, `oopsGlobal` den Wert `5` zu, ***ohne*** die Schlüsselwörter `var`, `let` oder `const` zu verwenden.
+
+# --hints--
+
+`myGlobal` sollte definiert werden
+
+```js
+assert(typeof myGlobal != 'undefined');
+```
+
+`myGlobal` sollte einen Wert von `10` haben
+
+```js
+assert(myGlobal === 10);
+```
+
+`myGlobal` sollte mit dem Schlüsselwort `let` oder `const` deklariert werden
+
+```js
+assert(/(let|const)\s+myGlobal/.test(code));
+```
+
+`oopsGlobal` sollte eine globale Variable sein und einen Wert von `5` haben
+
+```js
+assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+ var nativeLog = console.log;
+ console.log = function (message) {
+ logOutput = message;
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+}
+
+function uncapture() {
+ console.log = originalConsole.log;
+}
+var oopsGlobal;
+capture();
+```
+
+## --after-user-code--
+
+```js
+fun1();
+fun2();
+uncapture();
+(function() { return logOutput || "console.log never called"; })();
+```
+
+## --seed-contents--
+
+```js
+// Declare the myGlobal variable below this line
+
+
+function fun1() {
+ // Assign 5 to oopsGlobal Here
+
+}
+
+// Only change code above this line
+
+function fun2() {
+ var output = "";
+ if (typeof myGlobal != "undefined") {
+ output += "myGlobal: " + myGlobal;
+ }
+ if (typeof oopsGlobal != "undefined") {
+ output += " oopsGlobal: " + oopsGlobal;
+ }
+ console.log(output);
+}
+```
+
+# --solutions--
+
+```js
+const myGlobal = 10;
+
+function fun1() {
+ oopsGlobal = 5;
+}
+
+function fun2() {
+ var output = "";
+ if(typeof myGlobal != "undefined") {
+ output += "myGlobal: " + myGlobal;
+ }
+ if(typeof oopsGlobal != "undefined") {
+ output += " oopsGlobal: " + oopsGlobal;
+ }
+ console.log(output);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
new file mode 100644
index 00000000000..131d7571cee
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244c0
+title: Globaler vs. lokaler Gültigkeitsbereich in Funktionen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QwKH2'
+forumTopicId: 18194
+dashedName: global-vs--local-scope-in-functions
+---
+
+# --description--
+
+Es ist möglich, sowohl lokale als auch globale Variablen mit demselben Namen zu haben. Wenn du dies tust, hat die lokale Variable Vorrang vor der globalen Variable.
+
+In diesem Beispiel:
+
+```js
+const someVar = "Hat";
+
+function myFun() {
+ const someVar = "Head";
+ return someVar;
+}
+```
+
+Die Funktion `myFun` wird den String `Head` zurückgeben, da die lokale Version der Variable vorhanden ist.
+
+# --instructions--
+
+Füge der Funktion `myOutfit` eine lokale Variable hinzu, um den Wert von `outerWear` mit dem String `sweater` zu überschreiben.
+
+# --hints--
+
+Du solltest den Wert der globalen `outerWear` nicht ändern.
+
+```js
+assert(outerWear === 'T-Shirt');
+```
+
+`myOutfit` sollte den String `sweater` zurückgeben.
+
+```js
+assert(myOutfit() === 'sweater');
+```
+
+Du solltest die Rückgabeanweisung nicht ändern.
+
+```js
+assert(/return outerWear/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const outerWear = "T-Shirt";
+
+function myOutfit() {
+ // Only change code below this line
+
+ // Only change code above this line
+ return outerWear;
+}
+
+myOutfit();
+```
+
+# --solutions--
+
+```js
+const outerWear = "T-Shirt";
+function myOutfit() {
+ const outerWear = "sweater";
+ return outerWear;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
new file mode 100644
index 00000000000..b9074ad7308
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
@@ -0,0 +1,136 @@
+---
+id: 5664820f61c48e80c9fa476c
+title: Golf Code
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9ykNUR'
+forumTopicId: 18195
+dashedName: golf-code
+---
+
+# --description--
+
+Beim Golf hat jedes Loch einen `par`, also die durchschnittliche Anzahl von `strokes` (Schlägen), die ein Golfer machen muss, um den Ball im Loch zu versenken und das Spiel zu beenden. Je nachdem, wie weit über oder unter `par` deine `strokes` liegen, gibt es einen anderen Spitznamen.
+
+Deiner Funktion werden die Argumente `par` und `strokes` übergeben. Gib den richtigen String gemäß dieser Tabelle zurück, die die Schläge in der Reihenfolge ihrer Priorität auflistet: von oben (am höchsten) nach unten (am niedrigsten):
+
+Schläge Ausgabe 1 "Hole-in-one!" <= par - 2 "Eagle" par - 1 "Birdie" par "Par" par + 1 "Bogey" par + 2 "Double Bogey" >= par + 3 "Go Home!"
+
+`par` und `strokes` werden immer numerisch und positiv sein. Wir haben eine Liste mit allen Namen für dich zusammengestellt.
+
+# --hints--
+
+`golfScore(4, 1)` sollte den String `Hole-in-one!` zurückgeben
+
+```js
+assert(golfScore(4, 1) === 'Hole-in-one!');
+```
+
+`golfScore(4, 2)` sollte den String `Eagle` zurückgeben
+
+```js
+assert(golfScore(4, 2) === 'Eagle');
+```
+
+`golfScore(5, 2)` sollte den String `Eagle` zurückgeben
+
+```js
+assert(golfScore(5, 2) === 'Eagle');
+```
+
+`golfScore(4, 3)` sollte den String `Birdie` zurückgeben
+
+```js
+assert(golfScore(4, 3) === 'Birdie');
+```
+
+`golfScore(4, 4)` sollte den String `Par` zurückgeben
+
+```js
+assert(golfScore(4, 4) === 'Par');
+```
+
+`golfScore(1, 1)` sollte den String `Hole-in-one!` zurückgeben
+
+```js
+assert(golfScore(1, 1) === 'Hole-in-one!');
+```
+
+`golfScore(5, 5)` sollte den String `Par` zurückgeben
+
+```js
+assert(golfScore(5, 5) === 'Par');
+```
+
+`golfScore(4, 5)` sollte den String `Bogey` zurückgeben
+
+```js
+assert(golfScore(4, 5) === 'Bogey');
+```
+
+`golfScore(4, 6)` sollte den String `Double Bogey` zurückgeben
+
+```js
+assert(golfScore(4, 6) === 'Double Bogey');
+```
+
+`golfScore(4, 7)` sollte den String `Go Home!` zurückgeben
+
+```js
+assert(golfScore(4, 7) === 'Go Home!');
+```
+
+`golfScore(5, 9)` sollte den String `Go Home!` zurückgeben
+
+```js
+assert(golfScore(5, 9) === 'Go Home!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+
+function golfScore(par, strokes) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+golfScore(5, 4);
+```
+
+# --solutions--
+
+```js
+function golfScore(par, strokes) {
+ if (strokes === 1) {
+ return "Hole-in-one!";
+ }
+
+ if (strokes <= par - 2) {
+ return "Eagle";
+ }
+
+ if (strokes === par - 1) {
+ return "Birdie";
+ }
+
+ if (strokes === par) {
+ return "Par";
+ }
+
+ if (strokes === par + 1) {
+ return "Bogey";
+ }
+
+ if(strokes === par + 2) {
+ return "Double Bogey";
+ }
+
+ return "Go Home!";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
new file mode 100644
index 00000000000..8ec746552bc
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ac
+title: Inkrementieren einer Zahl mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GLT9'
+forumTopicId: 18201
+dashedName: increment-a-number-with-javascript
+---
+
+# --description--
+
+Mit dem Operator `++` kannst du eine Variable einfach erhöhen oder um eins ergänzen.
+
+```js
+i++;
+```
+
+ist das Äquivalent zu
+
+```js
+i = i + 1;
+```
+
+**Hinweis:** Die gesamte Zeile wird zu `i++;`, wodurch das Gleichheitszeichen überflüssig wird.
+
+# --instructions--
+
+Ändere den Code, um den `++`-Operator auf `myVar` anzuwenden.
+
+# --hints--
+
+`myVar` sollte gleich `88` sein.
+
+```js
+assert(myVar === 88);
+```
+
+Du solltest den Zuweisungsoperator nicht verwenden.
+
+```js
+assert(
+ /let\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2})/.test(code)
+);
+```
+
+Du solltest den `++` Operator verwenden.
+
+```js
+assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(/let myVar = 87;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 87;
+
+// Only change code below this line
+myVar = myVar + 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 87;
+myVar++;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
new file mode 100644
index 00000000000..3bc69df39a9
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
@@ -0,0 +1,50 @@
+---
+id: 56533eb9ac21ba0edf2244a9
+title: Initialisierung von Variablen mit dem Zuweisungsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
+forumTopicId: 301171
+dashedName: initializing-variables-with-the-assignment-operator
+---
+
+# --description--
+
+Es ist üblich, eine Variable in der gleichen Zeile, in der sie deklariert wird, mit einem Anfangswert zu initialisieren .
+
+```js
+var myVar = 0;
+```
+
+Erzeugt eine neue Variable mit dem Namen `myVar` und weist ihr einen Anfangswert von `0` zu.
+
+# --instructions--
+
+Definiere eine Variable `a` mit `var` und initialisiere sie mit einem Wert von `9`.
+
+# --hints--
+
+Du solltest `a` mit einem Wert von `9` initialisieren.
+
+```js
+assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (function() {return 'a is undefined';})(); }
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var a = 9;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
new file mode 100644
index 00000000000..0107e47745f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244db
+title: Einführung in die Else If-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJ2hm'
+forumTopicId: 18206
+dashedName: introducing-else-if-statements
+---
+
+# --description--
+
+Wenn du mehrere Bedingungen zu erfüllen hast, kannst du `if`-Anweisungen mit `else if`-Anweisungen verketten.
+
+```js
+if (num > 15) {
+ return "Bigger than 15";
+} else if (num < 5) {
+ return "Smaller than 5";
+} else {
+ return "Between 5 and 15";
+}
+```
+
+# --instructions--
+
+Ändere die Logik, um `else if`-Anweisungen zu verwenden.
+
+# --hints--
+
+Du solltest mindestens zwei `else`-Anweisungen verwenden
+
+```js
+assert(code.match(/else/g).length > 1);
+```
+
+Du solltest mindestens zwei `if`-Anweisungen verwenden
+
+```js
+assert(code.match(/if/g).length > 1);
+```
+
+Du solltest für jeden `if else`-Codeblock öffnende und schließende geschweifte Klammern verwenden.
+
+```js
+assert(
+ code.match(
+ /if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s+if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/
+ )
+);
+```
+
+`testElseIf(0)` sollte den String `Smaller than 5` zurückgeben
+
+```js
+assert(testElseIf(0) === 'Smaller than 5');
+```
+
+`testElseIf(5)` sollte den String `Between 5 and 10` zurückgeben
+
+```js
+assert(testElseIf(5) === 'Between 5 and 10');
+```
+
+`testElseIf(7)` sollte den String `Between 5 and 10` zurückgeben
+
+```js
+assert(testElseIf(7) === 'Between 5 and 10');
+```
+
+`testElseIf(10)` sollte den String `Between 5 and 10` zurückgeben
+
+```js
+assert(testElseIf(10) === 'Between 5 and 10');
+```
+
+`testElseIf(12)` sollte den String `Greater than 10` zurückgeben
+
+```js
+assert(testElseIf(12) === 'Greater than 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElseIf(val) {
+ if (val > 10) {
+ return "Greater than 10";
+ }
+
+ if (val < 5) {
+ return "Smaller than 5";
+ }
+
+ return "Between 5 and 10";
+}
+
+testElseIf(7);
+```
+
+# --solutions--
+
+```js
+function testElseIf(val) {
+ if(val > 10) {
+ return "Greater than 10";
+ } else if(val < 5) {
+ return "Smaller than 5";
+ } else {
+ return "Between 5 and 10";
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
new file mode 100644
index 00000000000..320941c4697
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244da
+title: Einführung in die Else-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cek4Efq'
+forumTopicId: 18207
+dashedName: introducing-else-statements
+---
+
+# --description--
+
+Wenn eine Bedingung für eine `if`-Anweisung wahr ist, wird der darauf folgende Codeblock ausgeführt. Was ist, wenn diese Bedingung falsch ist? Normalerweise würde nichts passieren. Mit einer `else`-Anweisung kann ein alternativer Codeblock ausgeführt werden.
+
+```js
+if (num > 10) {
+ return "Bigger than 10";
+} else {
+ return "10 or Less";
+}
+```
+
+# --instructions--
+
+Kombiniere die `if`-Anweisungen zu einer einzigen `if/else`-Anweisung.
+
+# --hints--
+
+Du solltest nur eine `if`-Anweisung im Editor verwenden
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+Du solltest eine `else`-Anweisung verwenden
+
+```js
+assert(/else/g.test(code));
+```
+
+`testElse(4)` sollte den String `5 or Smaller` zurückgeben
+
+```js
+assert(testElse(4) === '5 or Smaller');
+```
+
+`testElse(5)` sollte den String `5 or Smaller` zurückgeben
+
+```js
+assert(testElse(5) === '5 or Smaller');
+```
+
+`testElse(6)` sollte den String `Bigger than 5` zurückgeben
+
+```js
+assert(testElse(6) === 'Bigger than 5');
+```
+
+`testElse(10)`sollte den String `Bigger than 5` zurückgeben
+
+```js
+assert(testElse(10) === 'Bigger than 5');
+```
+
+Du solltest den Code nicht oberhalb oder unterhalb der angegebenen Kommentare ändern.
+
+```js
+assert(/let result = "";/.test(code) && /return result;/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElse(val) {
+ let result = "";
+ // Only change code below this line
+
+ if (val > 5) {
+ result = "Bigger than 5";
+ }
+
+ if (val <= 5) {
+ result = "5 or Smaller";
+ }
+
+ // Only change code above this line
+ return result;
+}
+
+testElse(4);
+```
+
+# --solutions--
+
+```js
+function testElse(val) {
+ let result = "";
+ if(val > 5) {
+ result = "Bigger than 5";
+ } else {
+ result = "5 or Smaller";
+ }
+ return result;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
new file mode 100644
index 00000000000..1f463aac9de
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
@@ -0,0 +1,69 @@
+---
+id: 56104e9e514f539506016a5c
+title: Ungerade Zahlen mit einer For-Schleife iterieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8n7T9'
+forumTopicId: 18212
+dashedName: iterate-odd-numbers-with-a-for-loop
+---
+
+# --description--
+
+For-Schleifen müssen nicht eine nach der anderen durchlaufen. Indem wir unsere `final-expression` (abschießenden Ausdruck) ändern, können wir mit geraden Zahlen zählen.
+
+Wir beginnen bei `i = 0` und machen eine Schleife, solange `i < 10`. Wir werden `i` in jeder Schleife mit `i += 2` um 2 erhöhen.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 10; i += 2) {
+ ourArray.push(i);
+}
+```
+
+`ourArray` wird nun `[0, 2, 4, 6, 8]` enthalten. Ändern wir unsere `initialization`, damit wir mit ungeraden Zahlen zählen können.
+
+# --instructions--
+
+Füge die ungeraden Zahlen von 1 bis 9 in `myArray` ein und verwende dazu eine `for`-Schleife.
+
+# --hints--
+
+Du solltest dafür eine `for`-Schleife verwenden.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` sollte gleich `[1, 3, 5, 7, 9]` sein.
+
+```js
+assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 10; i += 2) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
new file mode 100644
index 00000000000..3f03a743d3a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
@@ -0,0 +1,81 @@
+---
+id: 5675e877dbd60be8ad28edc6
+title: Mit einer for-Schleife durch ein Array iterieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeR3HB'
+forumTopicId: 18216
+dashedName: iterate-through-an-array-with-a-for-loop
+---
+
+# --description--
+
+Eine häufige Aufgabe in JavaScript ist es, durch den Inhalt eines Arrays zu iterieren. Eine Möglichkeit, das zu tun, ist eine `for`-Schleife. Dieser Code gibt jedes Element des Arrays `arr` auf der Konsole aus:
+
+```js
+const arr = [10, 9, 8, 7, 6];
+
+for (let i = 0; i < arr.length; i++) {
+ console.log(arr[i]);
+}
+```
+
+Denke daran, dass Arrays eine nullbasierte Indizierung haben, was bedeutet, dass der letzte Index des Arrays `length - 1` ist. Unsere Bedingung für diese Schleife ist `i < arr.length`, die die Schleife anhält, wenn `i` gleich `length` ist. In diesem Fall ist die letzte Iteration `i === 4`, d.h. wenn `i` gleich `arr.length - 1` wird und `6` auf der Konsole ausgibt. Dann erhöht sich `i` auf `5`, und die Schleife wird beendet, weil `i < arr.length` `false` ist.
+
+# --instructions--
+
+Deklariere und initialisiere eine Variable `total` auf `0`. Verwende eine `for`-Schleife, um den Wert jedes Elements des `myArr`-Arrays zu `total` zu addieren.
+
+# --hints--
+
+`total` sollte deklariert und auf 0 initialisiert werden.
+
+```js
+assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
+```
+
+`total` sollte gleich 20 sein.
+
+```js
+assert(total === 20);
+```
+
+Du solltest eine `for`-Schleife verwenden, um durch `myArr` zu iterieren.
+
+```js
+assert(/for\s*\(/g.test(code) && /myArr\s*\[/g.test(code));
+```
+
+Du solltest nicht versuchen, `total` direkt den Wert 20 zuzuweisen.
+
+```js
+assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArr = [2, 3, 4, 5, 6];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArr = [2, 3, 4, 5, 6];
+let total = 0;
+
+for (let i = 0; i < myArr.length; i++) {
+ total += myArr[i];
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
new file mode 100644
index 00000000000..cd98f3d9cc9
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
@@ -0,0 +1,105 @@
+---
+id: 5a2efd662fb457916e1fe604
+title: Mit JavaScript Do...While-Schleifen iterieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqWGcp'
+forumTopicId: 301172
+dashedName: iterate-with-javascript-do---while-loops
+---
+
+# --description--
+
+Die nächste Art von Schleife, die du lernen wirst, heißt `do...while`-Schleife. Sie wird `do...while`-Schleife genannt, weil sie zuerst `do` einen Durchlauf des Codes innerhalb der Schleife macht, egal was passiert, und dann die Schleife `while` weiterlaufen lässt, wenn die angegebene Bedingung als `true` ausgewertet wird.
+
+```js
+const ourArray = [];
+let i = 0;
+
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+Das obige Beispiel verhält sich ähnlich wie andere Arten von Schleifen, und das resultierende Array sieht folgendermaßen aus: `[0, 1, 2, 3, 4]`. Was die `do...while`-Schleife jedoch von anderen Schleifen unterscheidet, ist, wie sie sich verhält, wenn die Bedingung bei der ersten Überprüfung fehlschlägt. Schauen wir uns das in Aktion an. Hier ist eine reguläre `while`-Schleife, die den Code in der Schleife so lange ausführt, wie `i < 5` gilt:
+
+```js
+const ourArray = [];
+let i = 5;
+
+while (i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+In diesem Beispiel initialisieren wir den Wert von `ourArray` auf ein leeres Array und den Wert von `i` auf 5. Wenn wir die `while`-Schleife ausführen, wird die Bedingung als `false` ausgewertet, weil `i` nicht kleiner als 5 ist. Das Ergebnis ist, dass `ourArray` am Ende keine Werte mehr enthält und immer noch wie `[]` aussieht, wenn der Code im obigen Beispiel vollständig ausgeführt wurde. Sieh dir jetzt eine `do...while`-Schleife an:
+
+```js
+const ourArray = [];
+let i = 5;
+
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+In diesem Fall initialisieren wir den Wert von `i` auf 5, genau wie in der `while` Schleife. Wenn wir zur nächsten Zeile kommen, gibt es keine Bedingung, die wir auswerten müssen, also gehen wir zum Code innerhalb der geschweiften Klammern und führen ihn aus. Wir fügen dem Array ein einzelnes Element hinzu und erhöhen dann `i`, bevor wir zur Bedingungsprüfung kommen. Wenn wir schließlich die Bedingung `i < 5` in der letzten Zeile auswerten, sehen wir, dass `i` jetzt 6 ist, was die Bedingungsprüfung nicht bestanden hat, also verlassen wir die Schleife und sind fertig. Am Ende des obigen Beispiels ist der Wert von `ourArray` `[5]`. Eine `do...while`-Schleife sorgt dafür, dass der Code innerhalb der Schleife mindestens einmal ausgeführt wird. Versuchen wir, eine `do...while`-Schleife zum Laufen zu bringen, indem wir Werte in ein Array einfügen.
+
+# --instructions--
+
+Ändere die `while`-Schleife im Code in eine `do...while`-Schleife, damit die Schleife nur die Zahl `10` in `myArray` einfügt und `i` gleich `11` ist, wenn dein Code zu Ende ausgeführt wurde.
+
+# --hints--
+
+Du solltest für diese Übung eine `do...while`-Schleife verwenden.
+
+```js
+assert(code.match(/do/g));
+```
+
+`myArray` sollte gleich `[10]` sein.
+
+```js
+assert.deepEqual(myArray, [10]);
+```
+
+`i` sollte gleich `11` sein
+
+```js
+assert.equal(i, 11);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+let i = 10;
+
+// Only change code below this line
+while (i < 5) {
+ myArray.push(i);
+ i++;
+}
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 10;
+do {
+ myArray.push(i);
+ i++;
+} while (i < 5)
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
new file mode 100644
index 00000000000..4b71cb58f11
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
@@ -0,0 +1,81 @@
+---
+id: cf1111c1c11feddfaeb5bdef
+title: Iterieren mit JavaScript For-Schleifen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNVCe'
+forumTopicId: 18219
+dashedName: iterate-with-javascript-for-loops
+---
+
+# --description--
+
+Du kannst denselben Code mehrmals ausführen, indem du eine Schleife verwendest.
+
+Die häufigste Art von JavaScript-Schleifen wird `for`-Schleife genannt, weil sie eine bestimmte Anzahl von Malen ausgeführt wird.
+
+For-Schleifen werden mit drei optionalen Ausdrücken deklariert, die durch Semikolons getrennt sind:
+
+`for (a; b; c)`, wobei `a` die Initialisierungsanweisung, `b` die Bedingungsanweisung und `c` der endgültige Ausdruck ist.
+
+Die Initialisierungsanweisung wird nur einmal ausgeführt, bevor die Schleife beginnt. Sie wird normalerweise verwendet, um deine Schleifenvariable zu definieren und einzurichten.
+
+Die Bedingungsanweisung wird zu Beginn jeder Schleifeniteration ausgewertet und wird so lange fortgesetzt, wie sie `true` ist. Wenn die Bedingung zu Beginn der Iteration `false` ist, wird die Schleife nicht weiter ausgeführt. Das bedeutet, dass deine Schleife nie ausgeführt wird, wenn die Bedingung als falsch beginnt.
+
+Der abschließende Ausdruck wird am Ende jeder Schleifeniteration vor der nächsten Bedingungsprüfung ausgeführt und dient normalerweise dazu, deinen Schleifenzähler zu erhöhen (inkrementieren) oder zu verringern (dekrementieren).
+
+Im folgenden Beispiel initialisieren wir mit `i = 0` und iterieren, solange unsere Bedingung `i < 5` wahr ist. Wir erhöhen `i` in jeder Schleifeniteration um `1` mit `i++` als abschließendem Ausdruck.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 5; i++) {
+ ourArray.push(i);
+}
+```
+
+`ourArray` wird jetzt den Wert `[0, 1, 2, 3, 4]` haben.
+
+# --instructions--
+
+Verwende eine `for`-Schleife, um die Werte 1 bis 5 in `myArray` zu übertragen.
+
+# --hints--
+
+Du solltest dafür eine `for`-Schleife verwenden.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` sollte gleich `[1, 2, 3, 4, 5]` sein.
+
+```js
+assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 6; i++) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
new file mode 100644
index 00000000000..1e48478ac83
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
@@ -0,0 +1,75 @@
+---
+id: cf1111c1c11feddfaeb1bdef
+title: Iterieren mit JavaScript While-Schleifen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c8QbnCM'
+forumTopicId: 18220
+dashedName: iterate-with-javascript-while-loops
+---
+
+# --description--
+
+Du kannst denselben Code mehrmals ausführen, indem du eine Schleife verwendest.
+
+Die erste Art von Schleife, die wir lernen werden, heißt `while`-Schleife, weil sie läuft, solange eine bestimmte Bedingung wahr ist und stoppt, sobald diese Bedingung nicht mehr wahr ist.
+
+```js
+const ourArray = [];
+let i = 0;
+
+while (i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+Im obigen Codebeispiel wird die `while`-Schleife 5 Mal ausgeführt und fügt die Zahlen 0 bis 4 an `ourArray` an.
+
+Versuchen wir, eine while-Schleife zum Laufen zu bringen, indem wir Werte in ein Array einfügen.
+
+# --instructions--
+
+Füge die Zahlen 5 bis 0 (einschließlich) in absteigender Reihenfolge zu `myArray` hinzu, indem du eine `while`-Schleife benutzt.
+
+# --hints--
+
+Du solltest dafür eine `while`-Schleife verwenden.
+
+```js
+assert(code.match(/while/g));
+```
+
+`myArray` sollte gleich `[5, 4, 3, 2, 1, 0]` sein.
+
+```js
+assert.deepEqual(myArray, [5, 4, 3, 2, 1, 0]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 5;
+while (i >= 0) {
+ myArray.push(i);
+ i--;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
new file mode 100644
index 00000000000..a2561f2b799
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
@@ -0,0 +1,86 @@
+---
+id: 56533eb9ac21ba0edf2244bf
+title: Lokaler Gültigkeitsbereich und Funktionen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd62NhM'
+forumTopicId: 18227
+dashedName: local-scope-and-functions
+---
+
+# --description--
+
+Variablen, die innerhalb einer Funktion deklariert werden, sowie die Funktionsparameter, haben einen lokalen Gültigkeitsbereich. Das bedeutet, dass sie nur innerhalb dieser Funktion sichtbar sind.
+
+Hier ist eine Funktion `myTest` mit einer lokalen Variable namens `loc`.
+
+```js
+function myTest() {
+ const loc = "foo";
+ console.log(loc);
+}
+
+myTest();
+console.log(loc);
+```
+
+Der `myTest()` Funktionsaufruf wird den String `foo` in der Konsole anzeigen. Die Zeile `console.log(loc)` (außerhalb der Funktion `myTest`) führt zu einem Fehler, da `loc` außerhalb der Funktion nicht definiert ist.
+
+# --instructions--
+
+Der Editor hat zwei `console.log`s, damit du sehen kannst, was passiert. Überprüfe die Konsole während du programmierst, um zu sehen, wie sie sich verändert. Deklariere eine lokale Variable `myVar` innerhalb von `myLocalScope` und führe die Tests aus.
+
+**Hinweis:** Die Konsole wird immer noch `ReferenceError: myVar is not defined` anzeigen, aber das wird nicht dazu führen, dass die Tests fehlschlagen.
+
+# --hints--
+
+Der Code sollte keine globale Variable `myVar` enthalten.
+
+```js
+function declared() {
+ myVar;
+}
+
+assert.throws(declared, ReferenceError);
+```
+
+Du solltest eine lokale Variable `myVar` hinzufügen.
+
+```js
+assert(
+ /functionmyLocalScope\(\)\{.*(var|let|const)myVar[\s\S]*}/.test(
+ __helpers.removeWhiteSpace(code)
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myLocalScope() {
+ // Only change code below this line
+
+ console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
+
+# --solutions--
+
+```js
+function myLocalScope() {
+ // Only change code below this line
+ let myVar;
+ console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
new file mode 100644
index 00000000000..7cd20e3c712
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
@@ -0,0 +1,109 @@
+---
+id: 5690307fddb111c6084545d7
+title: Logische Reihenfolge in If-Else-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cwNvMUV'
+forumTopicId: 18228
+dashedName: logical-order-in-if-else-statements
+---
+
+# --description--
+
+Die Reihenfolge ist wichtig in `if`, `else if`-Anweisungen.
+
+Die Funktion wird von oben nach unten ausgeführt, also musst du darauf achten, welche Anweisung zuerst kommt.
+
+Schau dir diese beiden Funktionen als Beispiel an.
+
+Hier ist die erste:
+
+```js
+function foo(x) {
+ if (x < 1) {
+ return "Less than one";
+ } else if (x < 2) {
+ return "Less than two";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+Und die zweite ändert einfach die Reihenfolge der Anweisungen:
+
+```js
+function bar(x) {
+ if (x < 2) {
+ return "Less than two";
+ } else if (x < 1) {
+ return "Less than one";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+Diese beiden Funktionen sehen zwar fast identisch aus, aber wenn wir beiden eine Zahl übergeben, erhalten wir unterschiedliche Ausgaben.
+
+```js
+foo(0)
+bar(0)
+```
+
+`foo(0)` gibt den String `Less than one` zurück, und `bar(0)` gibt den String `Less than two` zurück.
+
+# --instructions--
+
+Ändere die Reihenfolge der Logik in der Funktion so, dass sie in allen Fällen die richtigen Aussagen zurückgibt.
+
+# --hints--
+
+`orderMyLogic(4)` sollte den String `Less than 5` zurückgeben
+
+```js
+assert(orderMyLogic(4) === 'Less than 5');
+```
+
+`orderMyLogic(6)` sollte den String `Less than 10` zurückgeben
+
+```js
+assert(orderMyLogic(6) === 'Less than 10');
+```
+
+`orderMyLogic(11)` sollte den String `Greater than or equal to 10` zurückgeben
+
+```js
+assert(orderMyLogic(11) === 'Greater than or equal to 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orderMyLogic(val) {
+ if (val < 10) {
+ return "Less than 10";
+ } else if (val < 5) {
+ return "Less than 5";
+ } else {
+ return "Greater than or equal to 10";
+ }
+}
+
+orderMyLogic(7);
+```
+
+# --solutions--
+
+```js
+function orderMyLogic(val) {
+ if(val < 5) {
+ return "Less than 5";
+ } else if (val < 10) {
+ return "Less than 10";
+ } else {
+ return "Greater than or equal to 10";
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
new file mode 100644
index 00000000000..2ec237b31a5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392cc
+title: Arrays mit pop() manipulieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVZAB'
+forumTopicId: 18236
+dashedName: manipulate-arrays-with-pop
+---
+
+# --description--
+
+Eine andere Möglichkeit, die Daten in einem Array zu ändern, ist die `.pop()` Funktion.
+
+`.pop()` wird verwendet, um einen Wert am Ende eines Arrays zu entfernen. Wir können diesen entfernten Wert speichern, indem wir ihn einer Variablen zuweisen. Mit anderen Worten: `.pop()` entfernt das letzte Element aus einem Array und gibt dieses Element zurück.
+
+Jede Art von Eintrag kann aus einem Array entfernt werden - Zahlen, Strings, sogar verschachtelte Arrays.
+
+```js
+const threeArr = [1, 4, 6];
+const oneDown = threeArr.pop();
+console.log(oneDown);
+console.log(threeArr);
+```
+
+Das erste `console.log` wird den Wert `6` anzeigen und das zweite wird den Wert `[1, 4]` anzeigen.
+
+# --instructions--
+
+Benutze die Funktion `.pop()`, um das letzte Element aus `myArray` zu entfernen und weise den entfernten Wert einer neuen Variablen `removedFromMyArray` zu.
+
+# --hints--
+
+`myArray` sollte nur `[["John", 23]]` enthalten.
+
+```js
+assert(
+ (function (d) {
+ if (d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+Du solltest `pop()` auf `myArray` anwenden.
+
+```js
+assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
+```
+
+`removedFromMyArray` sollte nur `["cat", 2]` enthalten.
+
+```js
+assert(
+ (function (d) {
+ if (d[0] == 'cat' && d[1] === 2 && d[2] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+const removedFromMyArray = myArray.pop();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
new file mode 100644
index 00000000000..b7134d55e08
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392cb
+title: Arrays mit push() manipulieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnqmVtJ'
+forumTopicId: 18237
+dashedName: manipulate-arrays-with-push
+---
+
+# --description--
+
+Eine einfache Möglichkeit, Daten an das Ende eines Arrays anzuhängen, ist die `push()` Funktion.
+
+`.push()` nimmt einen oder mehrere Parameter und "schiebt" sie an das Ende des Arrays.
+
+Beispiele:
+
+```js
+const arr1 = [1, 2, 3];
+arr1.push(4);
+
+const arr2 = ["Stimpson", "J", "cat"];
+arr2.push(["happy", "joy"]);
+```
+
+`arr1` hat jetzt den Wert `[1, 2, 3, 4]` und `arr2` hat den Wert `["Stimpson", "J", "cat", ["happy", "joy"]]`.
+
+# --instructions--
+
+Füge `["dog", 3]` an das Ende der Variablen `myArray` an.
+
+# --hints--
+
+`myArray` sollte gleich `[["John", 23], ["cat", 2], ["dog", 3]]` sein.
+
+```js
+assert(
+ (function (d) {
+ if (
+ d[2] != undefined &&
+ d[0][0] == 'John' &&
+ d[0][1] === 23 &&
+ d[2][0] == 'dog' &&
+ d[2][1] === 3 &&
+ d[2].length == 2
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+myArray.push(["dog",3]);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
new file mode 100644
index 00000000000..038b0137c2d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
@@ -0,0 +1,88 @@
+---
+id: 56bbb991ad1ed5201cd392cd
+title: Arrays mit shift() manipulieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVETW'
+forumTopicId: 18238
+dashedName: manipulate-arrays-with-shift
+---
+
+# --description--
+
+`pop()` entfernt immer das letzte Element eines Arrays. Was, wenn du das erste entfernen möchtest?
+
+Das ist der Moment, in dem `.shift()` ins Spiel kommt. Es funktioniert genau wie `.pop()`, nur dass es das erste Element entfernt, anstatt das letzte.
+
+Beispiel:
+
+```js
+const ourArray = ["Stimpson", "J", ["cat"]];
+const removedFromOurArray = ourArray.shift();
+```
+
+`removedFromOurArray` hätte einen Wert des Strings `Stimpson`, und `ourArray` hätte `["J", ["cat"]]`.
+
+# --instructions--
+
+Benutze die Funktion `.shift()`, um das erste Element aus `myArray` zu entfernen und weise dem entfernten Wert einer neue Variable `removedFromMyArray` zu.
+
+# --hints--
+
+`myArray` sollte nun gleich `[["dog", 3]]` sein.
+
+```js
+assert(
+ (function (d) {
+ if (d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+`removedFromMyArray` sollte `["John", 23]` enthalten.
+
+```js
+assert(
+ (function (d) {
+ if (
+ d[0] == 'John' &&
+ d[1] === 23 &&
+ typeof removedFromMyArray === 'object'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+const removedFromMyArray = myArray.shift();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
new file mode 100644
index 00000000000..5865f31bf12
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
@@ -0,0 +1,79 @@
+---
+id: 56bbb991ad1ed5201cd392ce
+title: Arrays mit unshift() manipulieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckNDESv'
+forumTopicId: 18239
+dashedName: manipulate-arrays-with-unshift
+---
+
+# --description--
+
+Du kannst nicht nur mit `shift` Elemente vom Anfang eines Arrays entfernen, du kannst auch mit `unshift` Elemente an den Anfang eines Arrays setzen, d.h. Elemente vor dem Array hinzufügen.
+
+`.unshift()` funktioniert genau wie `.push()`, aber anstatt das Element am Ende des Arrays hinzuzufügen, fügt `unshift()` das Element am Anfang des Arrays hinzu.
+
+Beispiel:
+
+```js
+const ourArray = ["Stimpson", "J", "cat"];
+ourArray.shift();
+ourArray.unshift("Happy");
+```
+
+Nach dem `shift` würde `ourArray` den Wert `["J", "cat"]` besitzen. Nach dem `unshift` würde `ourArray` den Wert `["Happy", "J", "cat"]` aufweisen.
+
+# --instructions--
+
+Füge `["Paul", 35]` am Anfang der Variable `myArray` mit `unshift()` hinzu.
+
+# --hints--
+
+`myArray` sollte jetzt `[["Paul", 35], ["dog", 3]]` enthalten.
+
+```js
+assert(
+ (function (d) {
+ if (
+ typeof d[0] === 'object' &&
+ d[0][0] == 'Paul' &&
+ d[0][1] === 35 &&
+ d[1][0] != undefined &&
+ d[1][0] == 'dog' &&
+ d[1][1] != undefined &&
+ d[1][1] == 3
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+myArray.unshift(["Paul", 35]);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
new file mode 100644
index 00000000000..54136e3f196
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
@@ -0,0 +1,165 @@
+---
+id: 56533eb9ac21ba0edf2244cb
+title: Manipulation komplexer Objekte
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNMfR'
+forumTopicId: 18208
+dashedName: manipulating-complex-objects
+---
+
+# --description--
+
+Manchmal möchte man Daten in einer flexiblen Datenstruktur speichern. Ein JavaScript-Objekt ist eine Möglichkeit, flexible Daten zu verarbeiten. Sie erlauben beliebige Kombinationen von Strings , Zahlen , Booleans , Arrays , Funktionen und Objekten .
+
+Hier ist ein Beispiel für eine komplexe Datenstruktur:
+
+```js
+const ourMusic = [
+ {
+ "artist": "Daft Punk",
+ "title": "Homework",
+ "release_year": 1997,
+ "formats": [
+ "CD",
+ "Cassette",
+ "LP"
+ ],
+ "gold": true
+ }
+];
+```
+
+Dies ist ein Array, in dem ein Objekt enthalten ist. Das Objekt enthält verschiedene Metadaten über ein Album. Es hat auch ein verschachteltes `formats`-Array. Wenn du weitere Albumdatensätze hinzufügen möchtest, kannst du dies tun, indem du dem Array der obersten Ebene Datensätze hinzufügst. Objekte enthalten Daten in einer Eigenschaft, die ein Schlüssel-Wert-Format hat. Im obigen Beispiel ist `"artist": "Daft Punk"` eine Eigenschaft, die einen Schlüssel `artist` und einen Wert `Daft Punk` hat.
+
+**Hinweis:** Du musst nach jedem Objekt im Array ein Komma setzen, außer es ist das letzte Objekt im Array.
+
+# --instructions--
+
+Füge ein neues Album zum Array `myMusic` hinzu. Füge `artist` und `title` Strings, `release_year` Nummer und ein `formats` Array mit Strings hinzu.
+
+# --hints--
+
+`myMusic` sollte ein Array sein
+
+```js
+assert(Array.isArray(myMusic));
+```
+
+`myMusic` sollte mindestens zwei Elemente enthalten
+
+```js
+assert(myMusic.length > 1);
+```
+
+Die Elemente im Array `myMusic` sollten Objekte sein
+
+```js
+myMusic.forEach(object => {assert.typeOf(object, 'object')})
+```
+
+Dein Objekt in `myMusic` sollte mindestens 4 Eigenschaften haben
+
+```js
+myMusic.forEach(object => {assert(Object.keys(object).length > 3); });
+```
+
+Dein Objekt in `myMusic` sollte die Eigenschaft `artist` enthalten, die ein String ist
+
+```js
+myMusic.forEach(object => {
+ assert.containsAllKeys(object, ['artist']);
+ assert.typeOf(object.artist, 'string')
+})
+```
+
+Dein Objekt in `myMusic` sollte die Eigenschaft `title` enthalten, die ein String ist
+
+```js
+myMusic.forEach(object => {
+ assert.containsAllKeys(object, ['title']);
+ assert.typeOf(object.title, 'string')
+})
+```
+
+Dein Objekt in `myMusic` sollte die Eigenschaft `release_year` enthalten, die eine Zahl ist
+
+```js
+myMusic.forEach(object => {
+ assert.containsAllKeys(object, ['release_year']);
+ assert.typeOf(object.release_year, 'number')
+})
+```
+
+Dein Objekt in `myMusic` sollte eine Eigenschaft `formats` enthalten, die ein Array ist
+
+```js
+myMusic.forEach(object => {
+ assert.containsAllKeys(object, ['formats']);
+ assert.typeOf(object.formats, 'array')
+})
+```
+
+`formats` sollte ein Array von Strings mit mindestens zwei Elementen sein
+
+```js
+myMusic.forEach(object => {
+ object.formats.forEach(format => {
+ assert.typeOf(format, 'string')
+ });
+ assert.isAtLeast(object.formats.length, 2)
+})
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
+```
+
+## --seed-contents--
+
+```js
+const myMusic = [
+ {
+ "artist": "Billy Joel",
+ "title": "Piano Man",
+ "release_year": 1973,
+ "formats": [
+ "CD",
+ "8T",
+ "LP"
+ ],
+ "gold": true
+ }
+];
+```
+
+# --solutions--
+
+```js
+const myMusic = [
+ {
+ "artist": "Billy Joel",
+ "title": "Piano Man",
+ "release_year": 1973,
+ "formats": [
+ "CS",
+ "8T",
+ "LP" ],
+ "gold": true
+ },
+ {
+ "artist": "ABBA",
+ "title": "Ring Ring",
+ "release_year": 1973,
+ "formats": [
+ "CS",
+ "8T",
+ "LP",
+ "CD",
+ ]
+ }
+];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
new file mode 100644
index 00000000000..9719b081458
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
@@ -0,0 +1,87 @@
+---
+id: cf1111c1c11feddfaeb8bdef
+title: Ändern von Array-Daten mittels Indizes
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/czQM4A8'
+forumTopicId: 18241
+dashedName: modify-array-data-with-indexes
+---
+
+# --description--
+
+Anders als bei Strings, sind die Einträge von Arrays änderbar (mutable) und können frei geändert werden, auch wenn das Array mit `const` deklariert wurde.
+
+**Beispiel**
+
+```js
+const ourArray = [50, 40, 30];
+ourArray[0] = 15;
+```
+
+`ourArray` hat jetzt den Wert `[15, 40, 30]`.
+
+**Hinweis:** Zwischen dem Array-Namen und den eckigen Klammern sollten keine Leerzeichen stehen, wie `array [0]`. Obwohl JavaScript in der Lage ist, dies korrekt zu verarbeiten, kann dies andere Programmierer verwirren, die deinen Code lesen.
+
+# --instructions--
+
+Ändere die Daten, die bei Index `0` von `myArray` gespeichert sind, auf einen Wert von `45`.
+
+# --hints--
+
+`myArray` sollte jetzt `[45, 64, 99]` sein.
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myArray != 'undefined' &&
+ myArray[0] == 45 &&
+ myArray[1] == 64 &&
+ myArray[2] == 99
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+Du solltest den richtigen Index verwenden, um den Wert in `myArray` zu ändern.
+
+```js
+assert(
+ (function () {
+ if (code.match(/myArray\[0\]\s*=\s*/g)) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [18, 64, 99];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [18, 64, 99];
+myArray[0] = 45;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
new file mode 100644
index 00000000000..6b43ff2680f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244df
+title: Mehrere identische Optionen in switch-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBKWCV'
+forumTopicId: 18242
+dashedName: multiple-identical-options-in-switch-statements
+---
+
+# --description--
+
+Wenn die Anweisung `break` im `case` einer `switch`-Anweisung weggelassen wird, werden die folgende(n) `case`-Anweisung(en) ausgeführt, bis ein `break` gefunden wird. Wenn du mehrere Eingänge mit demselben Ausgang hast, kannst du sie in einer `switch`-Anweisung wie dieser darstellen:
+
+```js
+let result = "";
+switch (val) {
+ case 1:
+ case 2:
+ case 3:
+ result = "1, 2, or 3";
+ break;
+ case 4:
+ result = "4 alone";
+}
+```
+
+Die Cases für 1, 2 und 3 führen alle zum gleichen Ergebnis.
+
+# --instructions--
+
+Schreibe eine switch-Anweisung, um `answer` für die folgenden Bereiche zu setzen:
+`1-3` - `Low`
+`4-6` - `Mid`
+`7-9` - `High`
+
+**Hinweis:** Du brauchst eine `case`-Anweisung für jede Zahl im Bereich.
+
+# --hints--
+
+`sequentialSizes(1)` sollte den String `Low` zurückgeben
+
+```js
+assert(sequentialSizes(1) === 'Low');
+```
+
+`sequentialSizes(2)` sollte den String `Low` zurückgeben
+
+```js
+assert(sequentialSizes(2) === 'Low');
+```
+
+`sequentialSizes(3)` sollte den String `Low` zurückgeben
+
+```js
+assert(sequentialSizes(3) === 'Low');
+```
+
+`sequentialSizes(4)` sollte den String `Mid` zurückgeben
+
+```js
+assert(sequentialSizes(4) === 'Mid');
+```
+
+`sequentialSizes(5)` sollte den String `Mid` zurückgeben
+
+```js
+assert(sequentialSizes(5) === 'Mid');
+```
+
+`sequentialSizes(6)` sollte den String `Mid` zurückgeben
+
+```js
+assert(sequentialSizes(6) === 'Mid');
+```
+
+`sequentialSizes(7)` sollte den String `High` zurückgeben
+
+```js
+assert(sequentialSizes(7) === 'High');
+```
+
+`sequentialSizes(8)` sollte den String `High` zurückgeben
+
+```js
+assert(sequentialSizes(8) === 'High');
+```
+
+`sequentialSizes(9)` sollte den String `High` zurückgeben
+
+```js
+assert(sequentialSizes(9) === 'High');
+```
+
+Du solltest keine `if` oder `else`-Anweisungen verwenden
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Du solltest neun `case`-Anweisungen verwenden
+
+```js
+assert(code.match(/case/g).length === 9);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sequentialSizes(val) {
+ let answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+sequentialSizes(1);
+```
+
+# --solutions--
+
+```js
+function sequentialSizes(val) {
+ let answer = "";
+
+ switch (val) {
+ case 1:
+ case 2:
+ case 3:
+ answer = "Low";
+ break;
+ case 4:
+ case 5:
+ case 6:
+ answer = "Mid";
+ break;
+ case 7:
+ case 8:
+ case 9:
+ answer = "High";
+ }
+
+ return answer;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
new file mode 100644
index 00000000000..bf86f37cfc3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
@@ -0,0 +1,52 @@
+---
+id: bd7993c9c69feddfaeb7bdef
+title: Multiplikation zweier Dezimalzahlen mit JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2GeHq'
+forumTopicId: 301173
+dashedName: multiply-two-decimals-with-javascript
+---
+
+# --description--
+
+In JavaScript kannst du auch Berechnungen mit Dezimalzahlen durchführen, ebenso wie mit ganzen Zahlen.
+
+Jetzt multiplizieren wir zwei Dezimalzahlen miteinander, um ihr Produkt zu erhalten.
+
+# --instructions--
+
+Ändere `0.0` so, dass das Produkt gleich `5.0` wird.
+
+# --hints--
+
+Die Variable `product` sollte gleich `5.0` sein.
+
+```js
+assert(product === 5.0);
+```
+
+Du solltest den Operator `*` verwenden
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'product = '+y;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 2.0 * 0.0;
+```
+
+# --solutions--
+
+```js
+const product = 2.0 * 2.5;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
new file mode 100644
index 00000000000..3528dd58b40
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
@@ -0,0 +1,60 @@
+---
+id: cf1231c1c11feddfaeb5bdef
+title: Zwei Zahlen mit JavaScript multiplizieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3y3Aq'
+forumTopicId: 18243
+dashedName: multiply-two-numbers-with-javascript
+---
+
+# --description--
+
+Wir können auch eine Zahl mit einer anderen multiplizieren.
+
+JavaScript verwendet das Symbol `*` für die Multiplikation von zwei Zahlen.
+
+**Beispiel**
+
+```js
+const myVar = 13 * 13;
+```
+
+`myVar` würde den Wert `169` haben.
+
+# --instructions--
+
+Ändere die `0` so, dass das Produkt gleich `80` ist.
+
+# --hints--
+
+Die Variable `product` sollte den Wert 80 haben.
+
+```js
+assert(product === 80);
+```
+
+Du solltest den Operator `*` verwenden.
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'product = '+z;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 8 * 0;
+```
+
+# --solutions--
+
+```js
+const product = 8 * 10;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
new file mode 100644
index 00000000000..0dfa9b4918e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
@@ -0,0 +1,51 @@
+---
+id: cf1111c1c11feddfaeb7bdef
+title: Ein Array in ein anderes Array einbetten
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQZf8'
+forumTopicId: 18247
+dashedName: nest-one-array-within-another-array
+---
+
+# --description--
+
+Du kannst auch Arrays innerhalb anderer Arrays einbetten, wie unten gezeigt:
+
+```js
+const teams = [["Bulls", 23], ["White Sox", 45]];
+```
+
+Dies wird auch als Mehrdimensionales Array bezeichnet.
+
+# --instructions--
+
+Erstelle ein verschachteltes Array mit dem Namen `myArray`.
+
+# --hints--
+
+`myArray` sollte mindestens ein Array in einem anderen Array eingebettet haben.
+
+```js
+assert(Array.isArray(myArray) && myArray.some(Array.isArray));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3]];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
new file mode 100644
index 00000000000..aafe9adc423
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
@@ -0,0 +1,92 @@
+---
+id: 56533eb9ac21ba0edf2244e1
+title: for-Schleifen verschachteln
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6GHM'
+forumTopicId: 18248
+dashedName: nesting-for-loops
+---
+
+# --description--
+
+Wenn du ein mehrdimensionales Array hast, kannst du die gleiche Logik wie in der vorherigen Aufgabe verwenden, um eine Schleife durch das Array und alle Unterarrays zu ziehen. Hier ist ein Beispiel:
+
+```js
+const arr = [
+ [1, 2], [3, 4], [5, 6]
+];
+
+for (let i = 0; i < arr.length; i++) {
+ for (let j = 0; j < arr[i].length; j++) {
+ console.log(arr[i][j]);
+ }
+}
+```
+
+Dies gibt jedes Unterelement in `arr` nacheinander aus. Beachte, dass wir in der inneren Schleife die `.length` von `arr[i]` überprüfen, da `arr[i]` selbst ein Array ist.
+
+# --instructions--
+
+Ändere die Funktion `multiplyAll` so, dass sie das Produkt aller Zahlen in den Unterarrays von `arr` zurückgibt.
+
+# --hints--
+
+`multiplyAll([[1], [2], [3]])` sollte `6` zurückgeben
+
+```js
+assert(multiplyAll([[1], [2], [3]]) === 6);
+```
+
+`multiplyAll([[1, 2], [3, 4], [5, 6, 7]])` sollte `5040` zurückgeben
+
+```js
+assert(
+ multiplyAll([
+ [1, 2],
+ [3, 4],
+ [5, 6, 7]
+ ]) === 5040
+);
+```
+
+`multiplyAll([[5, 1], [0.2, 4, 0.5], [3, 9]])` sollte `54` zurückgeben
+
+```js
+assert(
+ multiplyAll([
+ [5, 1],
+ [0.2, 4, 0.5],
+ [3, 9]
+ ]) === 54
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function multiplyAll(arr) {
+ let product = 1;
+ // Only change code below this line
+
+ // Only change code above this line
+ return product;
+}
+
+multiplyAll([[1, 2], [3, 4], [5, 6, 7]]);
+```
+
+# --solutions--
+
+```js
+function multiplyAll(arr) {
+ let product = 1;
+ for (let i = 0; i < arr.length; i++) {
+ for (let j = 0; j < arr[i].length; j++) {
+ product *= arr[i][j];
+ }
+ }
+ return product;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
new file mode 100644
index 00000000000..f78cbfe5933
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
@@ -0,0 +1,120 @@
+---
+id: 56533eb9ac21ba0edf2244bd
+title: Übergabe von Werten an Funktionen mit Argumenten
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy8rahW'
+forumTopicId: 18254
+dashedName: passing-values-to-functions-with-arguments
+---
+
+# --description--
+
+Parameter sind Variablen, die als Platzhalter für die Werte dienen, die an eine Funktion übergeben werden sollen, wenn sie aufgerufen wird. Wenn eine Funktion definiert wird, wird sie typischerweise zusammen mit einem oder mehreren Parametern definiert. Die tatsächlichen Werte, die in eine Funktion eingegeben (oder an sie "übergeben" werden), wenn sie aufgerufen wird, nennt man Argumente .
+
+Hier ist eine Funktion mit zwei Parametern, `param1` und `param2`:
+
+```js
+function testFun(param1, param2) {
+ console.log(param1, param2);
+}
+```
+
+Dann können wir `testFun` wie folgt aufrufen: `testFun("Hello", "World");`. Wir haben zwei String-Argumente übergeben, `Hello` und `World`. Innerhalb der Funktion wird `param1` gleich dem String `Hello` und `param2` wird gleich dem String `World`. Beachte, dass du `testFun` erneut mit anderen Argumenten aufrufen könntest und die Parameter den Wert der neuen Argumente annehmen würden.
+
+# --instructions--
+
+Erstelle eine Funktion namens functionWithArgs, die zwei Argumente akzeptiert und deren Summe auf der Konsole ausgibt. Rufe die Funktion mit zwei Zahlen als Argumente auf. String -Werte in JavaScript können mit einfachen oder doppelten Anführungszeichen geschrieben werden, solange sie mit der gleichen Art von Anführungszeichen beginnen und enden. Im Gegensatz zu einigen anderen Programmiersprachen funktionieren einfache und doppelte Anführungszeichen in JavaScript gleich.
+
+```js
+const doubleQuoteStr = "This is a string";
+const singleQuoteStr = 'This is also a string';
+```
+
+Der Grund, warum du eine Anführungszeichenart der anderen vorziehen solltest, ist, wenn du beide in einer Zeichenkette verwenden willst. Dies kann der Fall sein, wenn du eine Konversation in einem String speichern willst und die Konversation in Anführungszeichen steht. Eine andere Verwendung wäre das Speichern eines ``-Tags mit verschiedenen Attributen in Anführungszeichen, die alle in einem String enthalten sind.
+
+```js
+const conversation = 'Finn exclaims to Jake, "Algebraic!"';
+```
+
+Dies wird jedoch zu einem Problem, wenn du die äußeren Anführungszeichen darin verwenden musst. Denke daran, dass ein String am Anfang und am Ende dieselbe Art von Anführungszeichen haben muss. Wenn du aber dasselbe Anführungszeichen irgendwo in der Mitte hast, wird die Zeichenkette vorzeitig beendet und ein Fehler ausgegeben.
+
+```js
+const goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
+const badStr = 'Finn responds, "Let's go!"';
+```
+
+Hier wird `badStr` einen Fehler auslösen.
+
+In dem obigen goodStr kannst du beide Anführungszeichen sicher verwenden, indem du den Backslash `\` als Escape-Zeichen benutzt.
+
+**Hinweis:** Der Backslash `\` ist nicht zu verwechseln mit dem Schrägstrich (Forward Slash) `/`. Sie tun nicht dasselbe.
+
+# --instructions--
+
+Ändere den vorgegebenen String in einen String mit einfachen Anführungszeichen am Anfang und Ende und ohne Escape-Zeichen.
+
+Derzeit werden im ` `-Tag in dem String überall doppelte Anführungszeichen verwendet. Du musst die äußeren Anführungszeichen in einfache Anführungszeichen ändern, damit du die Escape-Zeichen entfernen kannst.
+
+# --hints--
+
+Du solltest alle Backslashes (`\`) entfernen.
+
+```js
+assert(
+ !/\\/g.test(code) &&
+ myStr.match(
+ '\\s* \\s*Link\\s* \\s*'
+ )
+);
+```
+
+Du solltest zwei einfache Anführungszeichen `'` und vier doppelte Anführungszeichen `"` verwenden.
+
+```js
+assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function() { return "myStr = " + myStr; })();
+```
+
+## --seed-contents--
+
+```js
+const myStr = "Link ";
+```
+
+# --solutions--
+
+```js
+const myStr = 'Link ';
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
new file mode 100644
index 00000000000..91a35552758
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
@@ -0,0 +1,181 @@
+---
+id: 56533eb9ac21ba0edf2244cf
+title: Schallplattensammlung
+challengeType: 1
+forumTopicId: 18261
+dashedName: record-collection
+---
+
+# --description--
+
+Du bekommst ein Objektliteral, das einen Teil deiner Musikalbensammlung darstellt. Jedes Album hat eine eindeutige ID-Nummer als Schlüssel und verschiedene andere Eigenschaften. Nicht alle Alben enthalten vollständige Informationen.
+
+Du beginnst mit einer Funktion `updateRecords`, die ein Objektliteral, `records`, mit der Musikalbensammlung, einer `id`, einer `prop` (wie `artist` oder `tracks`) und einem `value` nimmt. Vervollständige die Funktion mit Hilfe der folgenden Regeln, um das an die Funktion übergebene Objekt zu verändern.
+
+- Deine Funktion muss immer das gesamte Objekt der Datensammlung zurückgeben.
+- Wenn `prop` nicht `tracks` ist und `value` keinen leeren String enthält, aktualisiere oder setze `prop` für dieses Album auf `value`.
+- Wenn `prop` `tracks` ist, das Album aber keine Eigenschaft `tracks` hat, erstelle ein leeres Array und füge `value` hinzu.
+- Wenn `prop` `tracks` ist und `value` keinen leeren String darstellt, füge `value` an das Ende des bestehenden Arrays `tracks` des Albums an.
+- Wenn `value` ein leerer String ist, lösche die angegebene Eigenschaft `prop` aus dem Album.
+
+**Hinweis:** Für die Tests wird eine Kopie des Objekts `recordCollection` verwendet.
+
+# --hints--
+
+Nach `updateRecords(recordCollection, 5439, "artist", "ABBA")`, sollte `artist` der String `ABBA` sein
+
+```js
+assert(
+ updateRecords(_recordCollection, 5439, 'artist', 'ABBA')[5439]['artist'] ===
+ 'ABBA'
+);
+```
+
+Nach `updateRecords(recordCollection, 5439, "tracks", "Take a Chance on Me")`, sollte `tracks` den String `Take a Chance on Me` als einziges und letztes Element enthalten.
+
+```js
+assert(
+ updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me') &&
+ _recordCollection[5439]['tracks'].length === 1 &&
+ _recordCollection[5439]['tracks'].pop() === 'Take a Chance on Me'
+);
+```
+
+Nach `updateRecords(recordCollection, 2548, "artist", "")`, sollte `artist` nicht gesetzt werden
+
+```js
+updateRecords(_recordCollection, 2548, 'artist', '');
+assert(!_recordCollection[2548].hasOwnProperty('artist'));
+```
+
+Nach `updateRecords(recordCollection, 1245, "tracks", "Addicted to Love")` sollte `tracks` den String `Addicted to Love` als letztes Element enthalten.
+
+```js
+assert(
+ updateRecords(_recordCollection, 1245, 'tracks', 'Addicted to Love')[1245][
+ 'tracks'
+ ].pop() === 'Addicted to Love'
+);
+```
+
+Nach `updateRecords(recordCollection, 2468, "tracks", "Free")` sollte `tracks` den String `1999` als erstes Element enthalten.
+
+```js
+assert(
+ updateRecords(_recordCollection, 2468, 'tracks', 'Free')[2468][
+ 'tracks'
+ ][0] === '1999'
+);
+```
+
+Nach `updateRecords(recordCollection, 2548, "tracks", "")`, sollte `tracks` nicht gesetzt werden
+
+```js
+updateRecords(_recordCollection, 2548, 'tracks', '');
+assert(!_recordCollection[2548].hasOwnProperty('tracks'));
+```
+
+Nach `updateRecords(recordCollection, 1245, "albumTitle", "Riptide")`, sollte `albumTitle` der String `Riptide` sein
+
+```js
+assert(
+ updateRecords(_recordCollection, 1245, 'albumTitle', 'Riptide')[1245][
+ 'albumTitle'
+ ] === 'Riptide'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const _recordCollection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const recordCollection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+ return records;
+}
+
+updateRecords(recordCollection, 5439, 'artist', 'ABBA');
+```
+
+# --solutions--
+
+```js
+const recordCollection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+ if (value === '') delete records[id][prop];
+ else if (prop === 'tracks') {
+ records[id][prop] = records[id][prop] || [];
+ records[id][prop].push(value);
+ } else {
+ records[id][prop] = value;
+ }
+
+ return records;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
new file mode 100644
index 00000000000..c296be36ef6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
@@ -0,0 +1,105 @@
+---
+id: 5cfa3679138e7d9595b9d9d4
+title: Schleifen durch Rekursion ersetzen
+challengeType: 1
+videoUrl: >-
+ https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/
+forumTopicId: 301175
+dashedName: replace-loops-using-recursion
+---
+
+# --description--
+
+Rekursion ist das Konzept, dass eine Funktion durch sich selbst aufgerufen werden kann. Damit du das besser verstehst, solltest du dir folgende Aufgabe vorstellen: Multipliziere die ersten `n` Elemente eines Arrays, um das Produkt dieser Elemente zu bilden. Mit einer `for`-Schleife könntest du dies tun:
+
+```js
+ function multiply(arr, n) {
+ let product = 1;
+ for (let i = 0; i < n; i++) {
+ product *= arr[i];
+ }
+ return product;
+ }
+```
+
+Beachte jedoch, dass `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. Das bedeutet, dass du `multiply` in Bezug auf sich selbst umschreiben kannst und nie eine Schleife verwenden musst.
+
+```js
+ function multiply(arr, n) {
+ if (n <= 0) {
+ return 1;
+ } else {
+ return multiply(arr, n - 1) * arr[n - 1];
+ }
+ }
+```
+
+Die rekursive Version von `multiply` funktioniert folgendermaßen. Im Basisfall , in dem `n <= 0` ist, gibt sie 1 zurück. Bei größeren Werten von `n` ruft sie sich selbst auf, aber mit `n - 1`. Dieser Funktionsaufruf wird auf die gleiche Weise ausgewertet, indem `multiply` erneut aufgerufen wird, bis `n <= 0`. An diesem Punkt können alle Funktionen zurückkehren und die ursprüngliche `multiply` liefert die Antwort.
+
+**Beachte:** Rekursive Funktionen müssen einen Basisfall haben, in den sie zurückkehren, ohne die Funktion erneut aufzurufen (in diesem Beispiel, wenn `n <= 0`), sonst können sie ihre Ausführung nie beenden.
+
+# --instructions--
+
+Schreibe eine rekursive Funktion, `sum(arr, n)`, die die Summe der ersten `n` Elemente eines Arrays `arr` zurückgibt.
+
+# --hints--
+
+`sum([1], 0)` sollte gleich 0 sein.
+
+```js
+assert.equal(sum([1], 0), 0);
+```
+
+`sum([2, 3, 4], 1)` sollte gleich 2 sein.
+
+```js
+assert.equal(sum([2, 3, 4], 1), 2);
+```
+
+`sum([2, 3, 4, 5], 3)` sollte gleich 9 sein.
+
+```js
+assert.equal(sum([2, 3, 4, 5], 3), 9);
+```
+
+Dein Code sollte keine Schleifen enthalten (`for` oder `while` oder Funktionen höherer Ordnung wie `forEach`, `map`, `filter`, oder `reduce`).
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+Um dieses Problem zu lösen, solltest du eine Rekursion verwenden.
+
+```js
+assert(
+ sum.toString().match(/sum\(.*\)/g).length > 1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sum(arr, n) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function sum(arr, n) {
+ // Only change code below this line
+ if(n <= 0) {
+ return 0;
+ } else {
+ return sum(arr, n - 1) + arr[n - 1];
+ }
+ // Only change code above this line
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
new file mode 100644
index 00000000000..ec8f663898b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
@@ -0,0 +1,157 @@
+---
+id: 56533eb9ac21ba0edf2244e0
+title: Ersetzen von If-Else-Ketten durch switch
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JE8fy'
+forumTopicId: 18266
+dashedName: replacing-if-else-chains-with-switch
+---
+
+# --description--
+
+Wenn du viele Optionen zur Auswahl hast, kann eine `switch`-Anweisung einfacher zu schreiben sein als viele verkettete `if`/`else if`-Anweisungen. Das Folgende:
+
+```js
+if (val === 1) {
+ answer = "a";
+} else if (val === 2) {
+ answer = "b";
+} else {
+ answer = "c";
+}
+```
+
+kann ersetzt werden durch:
+
+```js
+switch (val) {
+ case 1:
+ answer = "a";
+ break;
+ case 2:
+ answer = "b";
+ break;
+ default:
+ answer = "c";
+}
+```
+
+# --instructions--
+
+Ändere die verketteten `if`/`else if`-Anweisungen in eine `switch`-Anweisung.
+
+# --hints--
+
+Du solltest nirgendwo im Editor `else`-Anweisungen verwenden
+
+```js
+assert(!/else/g.test(code));
+```
+
+Du solltest nirgendwo im Editor `if`-Anweisungen verwenden
+
+```js
+assert(!/if/g.test(code));
+```
+
+Du solltest mindestens vier `break`-Anweisungen verwenden
+
+```js
+assert(code.match(/break/g).length >= 4);
+```
+
+`chainToSwitch("bob")` sollte den String `Marley` ausgeben
+
+```js
+assert(chainToSwitch('bob') === 'Marley');
+```
+
+`chainToSwitch(42)` sollte den String `The Answer` ausgeben
+
+```js
+assert(chainToSwitch(42) === 'The Answer');
+```
+
+`chainToSwitch(1)` sollte den String `There is no #1` ausgeben
+
+```js
+assert(chainToSwitch(1) === 'There is no #1');
+```
+
+`chainToSwitch(99)` sollte den String `Missed me by this much!` ausgeben
+
+```js
+assert(chainToSwitch(99) === 'Missed me by this much!');
+```
+
+`chainToSwitch(7)` sollte den String `Ate Nine` ausgeben
+
+```js
+assert(chainToSwitch(7) === 'Ate Nine');
+```
+
+`chainToSwitch("John")` sollte `""` (leerer String) ausgeben
+
+```js
+assert(chainToSwitch('John') === '');
+```
+
+`chainToSwitch(156)` sollte `""` (leerer String) ausgeben
+
+```js
+assert(chainToSwitch(156) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chainToSwitch(val) {
+ let answer = "";
+ // Only change code below this line
+
+ if (val === "bob") {
+ answer = "Marley";
+ } else if (val === 42) {
+ answer = "The Answer";
+ } else if (val === 1) {
+ answer = "There is no #1";
+ } else if (val === 99) {
+ answer = "Missed me by this much!";
+ } else if (val === 7) {
+ answer = "Ate Nine";
+ }
+
+ // Only change code above this line
+ return answer;
+}
+
+chainToSwitch(7);
+```
+
+# --solutions--
+
+```js
+function chainToSwitch(val) {
+ let answer = "";
+
+ switch (val) {
+ case "bob":
+ answer = "Marley";
+ break;
+ case 42:
+ answer = "The Answer";
+ break;
+ case 1:
+ answer = "There is no #1";
+ break;
+ case 99:
+ answer = "Missed me by this much!";
+ break;
+ case 7:
+ answer = "Ate Nine";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
new file mode 100644
index 00000000000..3d5489debf2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
@@ -0,0 +1,73 @@
+---
+id: 56533eb9ac21ba0edf2244c2
+title: Rückgabe eines Wertes aus einer Funktion mit Return
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87wue'
+forumTopicId: 18271
+dashedName: return-a-value-from-a-function-with-return
+---
+
+# --description--
+
+Mit Argumenten können wir Werte an eine Funktion übergeben. Du kannst eine `return`-Anweisung verwenden, um einen Wert aus einer Funktion zurückzugeben.
+
+**Beispiel**
+
+```js
+function plusThree(num) {
+ return num + 3;
+}
+
+const answer = plusThree(5);
+```
+
+`answer` hat den Wert `8`.
+
+`plusThree` nimmt ein Argument für `num` und gibt einen Wert gleich `num + 3` zurück.
+
+# --instructions--
+
+Erstelle eine Funktion `timesFive`, die ein Argument entgegennimmt, es mit `5` multipliziert und den neuen Wert zurückgibt.
+
+# --hints--
+
+`timesFive` sollte eine Funktion sein
+
+```js
+assert(typeof timesFive === 'function');
+```
+
+`timesFive(5)` sollte `25` zurückgeben
+
+```js
+assert(timesFive(5) === 25);
+```
+
+`timesFive(2)` sollte `10` zurückgeben
+
+```js
+assert(timesFive(2) === 10);
+```
+
+`timesFive(0)` sollte `0` zurückgeben
+
+```js
+assert(timesFive(0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function timesFive(num) {
+ return num * 5;
+}
+timesFive(10);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
new file mode 100644
index 00000000000..17ba23a8f72
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244c4
+title: Muster für die frühe Rückgabe (Return-Early) bei Funktionen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe39Sq'
+forumTopicId: 18272
+dashedName: return-early-pattern-for-functions
+---
+
+# --description--
+
+Wenn eine `return`-Anweisung erreicht wird, stoppt die Ausführung der aktuellen Funktion und die Kontrolle wird an die aufrufende Stelle zurückgegeben.
+
+**Beispiel**
+
+```js
+function myFun() {
+ console.log("Hello");
+ return "World";
+ console.log("byebye")
+}
+myFun();
+```
+
+Das obige Beispiel zeigt den String `Hello` in der Konsole an und gibt den String `World` zurück. Der String `byebye` wird nie in der Konsole angezeigt, weil die Funktion mit der `return`-Anweisung beendet wird.
+
+# --instructions--
+
+Ändere die Funktion `abTest` so, dass die Funktion sofort mit einem Wert von `undefined` beendet wird, wenn `a` oder `b` kleiner als `0` sind.
+
+**Hinweis:**
+Denk daran, dass undefined ein SchlüsselwortVergleich mit dem Gleichheitsoperator daran, dass alle Vergleichsoperatoren einen booleschen `true` oder `false` Wert zurückgeben.
+
+Manchmal wird eine `if/else`-Anweisung verwendet, um einen Vergleich durchzuführen, wie hier:
+
+```js
+function isEqual(a, b) {
+ if (a === b) {
+ return true;
+ } else {
+ return false;
+ }
+}
+```
+
+Aber es gibt einen besseren Weg, das zu tun. Da `===` `true` oder `false` liefert, können wir das Ergebnis des Vergleichs zurückgeben:
+
+```js
+function isEqual(a, b) {
+ return a === b;
+}
+```
+
+# --instructions--
+
+Ändere die Funktion `isLess`, um die `if/else`-Anweisungen zu entfernen.
+
+# --hints--
+
+`isLess(10, 15)` sollte `true` zurückgeben
+
+```js
+assert(isLess(10, 15) === true);
+```
+
+`isLess(15, 10)` sollte `false` zurückgeben
+
+```js
+assert(isLess(15, 10) === false);
+```
+
+Du solltest keine `if` oder `else`-Anweisungen verwenden
+
+```js
+assert(!/if|else/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function isLess(a, b) {
+ // Only change code below this line
+ if (a < b) {
+ return true;
+ } else {
+ return false;
+ }
+ // Only change code above this line
+}
+
+isLess(10, 15);
+```
+
+# --solutions--
+
+```js
+function isLess(a, b) {
+ return a < b;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
new file mode 100644
index 00000000000..61805d6665e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244dd
+title: Auswahl aus vielen Optionen mit switch-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c4mv4fm'
+forumTopicId: 18277
+dashedName: selecting-from-many-options-with-switch-statements
+---
+
+# --description--
+
+Wenn du viele Optionen zur Auswahl hast, verwende eine switch -Anweisung. Eine `switch`-Anweisung testet einen Wert und kann viele case -Anweisungen haben, die verschiedene mögliche Werte definieren. Die Anweisungen werden ab dem ersten übereinstimmenden `case`-Wert ausgeführt, bis ein `break` auftritt.
+
+Hier ist ein Beispiel für eine `switch`-Anweisung:
+
+```js
+switch (lowercaseLetter) {
+ case "a":
+ console.log("A");
+ break;
+ case "b":
+ console.log("B");
+ break;
+}
+```
+
+`case`-Werte werden mit strikter Gleichheit (`===`) getestet. Das `break` sagt JavaScript, dass es die Ausführung von Anweisungen stoppen soll. Wenn der `break` weggelassen wird, wird die nächste Anweisung ausgeführt.
+
+# --instructions--
+
+Schreibe eine switch-Anweisung, die `val` testet und `answer` für die folgenden Bedingungen setzt:
+`1` - `alpha`
+`2` - `beta`
+`3` - `gamma`
+`4` - `delta`
+
+# --hints--
+
+`caseInSwitch(1)` sollte den String `alpha` als Wert haben
+
+```js
+assert(caseInSwitch(1) === 'alpha');
+```
+
+`caseInSwitch(2)` sollte den String `beta` als Wert haben
+
+```js
+assert(caseInSwitch(2) === 'beta');
+```
+
+`caseInSwitch(3)` sollte den String `gamma` als Wert haben
+
+```js
+assert(caseInSwitch(3) === 'gamma');
+```
+
+`caseInSwitch(4)` sollte den String `delta` als Wert haben
+
+```js
+assert(caseInSwitch(4) === 'delta');
+```
+
+Du solltest keine `if` oder `else`-Anweisungen verwenden
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Du solltest mindestens 3 `break`-Anweisungen verwenden
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function caseInSwitch(val) {
+ let answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+caseInSwitch(1);
+```
+
+# --solutions--
+
+```js
+function caseInSwitch(val) {
+ let answer = "";
+
+ switch (val) {
+ case 1:
+ answer = "alpha";
+ break;
+ case 2:
+ answer = "beta";
+ break;
+ case 3:
+ answer = "gamma";
+ break;
+ case 4:
+ answer = "delta";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
new file mode 100644
index 00000000000..516ee22fd21
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
@@ -0,0 +1,97 @@
+---
+id: 56533eb9ac21ba0edf2244bc
+title: Einkaufsliste
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9MEKHZ'
+forumTopicId: 18280
+dashedName: shopping-list
+---
+
+# --description--
+
+Erstelle eine Einkaufsliste in der Variable `myList`. Die Liste sollte ein mehrdimensionales Array sein, das mehrere Subarrays enthält.
+
+Das erste Element in jedem Subarray sollte einen String mit dem Namen des Elements enthalten. Das zweite Element sollte eine Zahl sein, welche die Menge repräsentiert, d.h.
+
+```js
+["Chocolate Bar", 15]
+```
+
+Es sollten mindestens 5 Subarrays in der Liste sein.
+
+# --hints--
+
+`myList` sollte ein Array sein.
+
+```js
+assert(isArray);
+```
+
+Die ersten Elemente in jedem deiner Subarrays sollten alle Strings sein.
+
+```js
+assert(hasString);
+```
+
+Die zweiten Elemente in jedem deiner Subarrays sollten alle Zahlen sein.
+
+```js
+assert(hasNumber);
+```
+
+Du solltest mindestens 5 Elemente in deiner Liste haben.
+
+```js
+assert(count > 4);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var count = 0;
+var isArray = false;
+var hasString = false;
+var hasNumber = false;
+(function(list){
+ if(Array.isArray(myList)) {
+ isArray = true;
+ if(myList.length > 0) {
+ hasString = true;
+ hasNumber = true;
+ for (var elem of myList) {
+ if(!elem || !elem[0] || typeof elem[0] !== 'string') {
+ hasString = false;
+ }
+ if(!elem || typeof elem[1] !== 'number') {
+ hasNumber = false;
+ }
+ }
+ }
+ count = myList.length;
+ return JSON.stringify(myList);
+ } else {
+ return "myList is not an array";
+ }
+
+})(myList);
+```
+
+## --seed-contents--
+
+```js
+const myList = [];
+```
+
+# --solutions--
+
+```js
+const myList = [
+ ["Candy", 10],
+ ["Potatoes", 12],
+ ["Eggs", 12],
+ ["Catfood", 1],
+ ["Toads", 9]
+];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
new file mode 100644
index 00000000000..8611a3ee1f1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
@@ -0,0 +1,118 @@
+---
+id: 56533eb9ac21ba0edf2244c6
+title: In der Schlange stehen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8Q8tP'
+forumTopicId: 18307
+dashedName: stand-in-line
+---
+
+# --description--
+
+In der Informatik ist eine Warteschlange (Queue) eine abstrakte Datenstruktur , in der Elemente in einer Reihenfolge aufbewahrt werden. Neue Elemente können am Ende der Warteschlange hinzugefügt werden und alte Elemente werden vom Anfang der Warteschlange entfernt.
+
+# --instructions--
+
+Schreibe eine Funktion `nextInLine`, die ein Array (`arr`) und eine Zahl (`item`) als Argumente entgegennimmt.
+
+Füge die Zahl an das Ende des Arrays an und entferne dann das erste Element des Arrays.
+
+Die Funktion `nextInLine` sollte dann das Element zurückgeben, das entfernt wurde.
+
+# --hints--
+
+`nextInLine([], 5)` sollte eine Zahl zurückgeben.
+
+```js
+assert.isNumber(nextInLine([], 5));
+```
+
+`nextInLine([], 1)` sollte `1` zurückgeben
+
+```js
+assert(nextInLine([], 1) === 1);
+```
+
+`nextInLine([2], 1)` sollte `2` zurückgeben
+
+```js
+assert(nextInLine([2], 1) === 2);
+```
+
+`nextInLine([5,6,7,8,9], 1)` sollte `5` zurückgeben
+
+```js
+assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
+```
+
+Nach der Ausführung der Funktion `nextInLine(testArr, 10)`, sollte `testArr[4]` gleich `10` sein
+
+```js
+nextInLine(testArr, 10);
+assert(testArr[4] === 10);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = [];
+var originalConsole = console
+function capture() {
+ var nativeLog = console.log;
+ console.log = function (message) {
+ logOutput.push(message);
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+}
+
+function uncapture() {
+ console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+testArr = [1,2,3,4,5];
+(function() { return logOutput.join("\n");})();
+```
+
+## --seed-contents--
+
+```js
+function nextInLine(arr, item) {
+ // Only change code below this line
+
+ return item;
+ // Only change code above this line
+}
+
+// Setup
+const testArr = [1, 2, 3, 4, 5];
+
+// Display code
+console.log("Before: " + JSON.stringify(testArr));
+console.log(nextInLine(testArr, 6));
+console.log("After: " + JSON.stringify(testArr));
+```
+
+# --solutions--
+
+```js
+const testArr = [1, 2, 3, 4, 5];
+
+function nextInLine(arr, item) {
+ arr.push(item);
+ return arr.shift();
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
new file mode 100644
index 00000000000..c038f362cbc
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
@@ -0,0 +1,63 @@
+---
+id: bd7993c9c69feddfaeb8bdef
+title: Speichern mehrerer Werte in einer Variablen mithilfe von JavaScript-Arrays
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQWAm'
+forumTopicId: 18309
+dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
+---
+
+# --description--
+
+Mit JavaScript `array`-Variablen können wir mehrere Daten an einem Ort speichern.
+
+Du beginnst eine Array-Deklaration mit einer öffnenden eckigen Klammer, beendest sie mit einer schließenden eckigen Klammer und setzt ein Komma zwischen jeden Eintrag, etwa so:
+
+```js
+const sandwich = ["peanut butter", "jelly", "bread"];
+```
+
+# --instructions--
+
+Ändere das neue Array `myArray` so, dass es sowohl einen String als auch eine Zahl enthält (in dieser Reihenfolge).
+
+# --hints--
+
+`myArray` sollte ein Array sein.
+
+```js
+assert(typeof myArray == 'object');
+```
+
+Das erste Element in `myArray` sollte ein String sein.
+
+```js
+assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
+```
+
+Das zweite Element in `myArray` sollte eine Zahl sein.
+
+```js
+assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = ["The Answer", 42];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
new file mode 100644
index 00000000000..97f34ba8f44
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244a8
+title: Speichern von Werten mit dem Zuweisungsoperator
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEanysE'
+forumTopicId: 18310
+dashedName: storing-values-with-the-assignment-operator
+---
+
+# --description--
+
+In JavaScript kannst du mit dem Zuweisungsoperator (`=`) einen Wert in einer Variablen speichern.
+
+```js
+myVariable = 5;
+```
+
+Dies weist `myVariable` den `Number`-Wert `5` zu.
+
+Wenn sich rechts vom Operator `=` Berechnungen befinden, werden diese durchgeführt, bevor der Wert der Variablen links vom Operator zugewiesen wird.
+
+```js
+var myVar;
+myVar = 5;
+```
+
+Zunächst wird in diesem Code eine Variable mit dem Namen `myVar` erstellt. Danach weist der Code `5` zu `myVar` hinzu. Wenn nun `myVar` wieder im Code auftaucht, wird das Programm es so behandeln, als wäre es `5`.
+
+# --instructions--
+
+Weise den Wert `7` der Variablen `a` zu.
+
+# --hints--
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(/var a;/.test(code));
+```
+
+`a` sollte einen Wert von 7 haben.
+
+```js
+assert(typeof a === 'number' && a === 7);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+ a = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a){return "a = " + a;})(a);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
new file mode 100644
index 00000000000..263c35d06b5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb4bdef
+title: Eine Zahl von einer anderen mit JavaScript subtrahieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3yQtk'
+forumTopicId: 18314
+dashedName: subtract-one-number-from-another-with-javascript
+---
+
+# --description--
+
+Wir können auch eine Zahl von einer anderen subtrahieren.
+
+JavaScript verwendet das Symbol `-` für die Subtraktion.
+
+**Beispiel**
+
+```js
+const myVar = 12 - 6;
+```
+
+`myVar` würde den Wert `6` haben.
+# --instructions--
+
+Ändere die `0` so, dass die Differenz `12` ist.
+
+# --hints--
+
+Die Variable `difference` sollte den Wert 12 haben.
+
+```js
+assert(difference === 12);
+```
+
+Du solltest nur eine Zahl von 45 abziehen.
+
+```js
+assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'difference = '+z;})(difference);
+```
+
+## --seed-contents--
+
+```js
+const difference = 45 - 0;
+```
+
+# --solutions--
+
+```js
+const difference = 45 - 33;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
new file mode 100644
index 00000000000..797af310ee7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
@@ -0,0 +1,98 @@
+---
+id: 567af2437cbaa8c51670a16c
+title: Objekte auf Eigenschaften prüfen
+challengeType: 1
+forumTopicId: 18324
+dashedName: testing-objects-for-properties
+---
+
+# --description--
+
+Manchmal ist es nützlich zu prüfen, ob die Eigenschaft eines bestimmten Objekts existiert oder nicht. Wir können die Methode `.hasOwnProperty(propname)` von Objekten verwenden, um festzustellen, ob das Objekt den angegebenen Eigenschaftsnamen enthält. `.hasOwnProperty()` gibt `true` oder `false` zurück, wenn die Eigenschaft gefunden wird oder nicht.
+
+**Beispiel**
+
+```js
+const myObj = {
+ top: "hat",
+ bottom: "pants"
+};
+
+myObj.hasOwnProperty("top");
+myObj.hasOwnProperty("middle");
+```
+
+Die erste `hasOwnProperty` gibt `true` zurück, während die zweite `false` zurückgibt.
+
+# --instructions--
+
+Ändere die Funktion `checkObj` so, dass sie prüft, ob ein an die Funktion übergebenes Objekt (`obj`) eine bestimmte Eigenschaft enthält (`checkProp`). Wenn die Eigenschaft gefunden wird, wird der Wert der Eigenschaft zurückgegeben. Wenn nicht, wird `"Not Found"` zurückgegeben.
+
+# --hints--
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` sollte den String `pony` zurückgeben.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'gift') === 'pony'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` sollte den String `kitten` zurückgeben.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'pet') === 'kitten'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` sollte den String `Not Found` zurückgeben.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'house') ===
+ 'Not Found'
+);
+```
+
+`checkObj({city: "Seattle"}, "city")` sollte den String `Seattle` zurückgeben.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
+```
+
+`checkObj({city: "Seattle"}, "district")` sollte den String `Not Found` zurückgeben.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
+```
+
+`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` sollte den String `Not Found` zurückgeben.
+
+```js
+assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkObj(obj, checkProp) {
+ // Only change code below this line
+ return "Change Me!";
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function checkObj(obj, checkProp) {
+ if(obj.hasOwnProperty(checkProp)) {
+ return obj[checkProp];
+ } else {
+ return "Not Found";
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
new file mode 100644
index 00000000000..3381075c6df
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244ba
+title: Die Unveränderlichkeit von Strings verstehen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVaUR'
+forumTopicId: 18331
+dashedName: understand-string-immutability
+---
+
+# --description--
+
+In JavaScript sind `String`-Werte unveränderlich , d.h. sie können nach ihrer Erstellung nicht mehr verändert werden.
+
+Zum Beispiel folgender Code:
+
+```js
+let myStr = "Bob";
+myStr[0] = "J";
+```
+
+kann den Wert von `myStr` nicht in `Job` ändern, da der Inhalt von `myStr` nicht verändert werden kann. Beachte, dass dies *nicht* bedeutet, dass `myStr` nicht geändert werden kann, sondern nur, dass die einzelnen Zeichen eines String-Literal nicht geändert werden können. Die einzige Möglichkeit, `myStr` zu ändern, wäre, ihr einen neuen String zuzuweisen, etwa so:
+
+```js
+let myStr = "Bob";
+myStr = "Job";
+```
+
+# --instructions--
+
+Korrigiere die Zuweisung an `myStr` so, dass sie den String-Wert von `Hello World` enthält, indem du den Ansatz aus dem obigen Beispiel verwendest.
+
+# --hints--
+
+`myStr` sollte einen Wert des Strings `Hello World` haben.
+
+```js
+assert(myStr === 'Hello World');
+```
+
+Du solltest den Code oberhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(/myStr = "Jello World"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return "myStr = " + v;})(myStr);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let myStr = "Jello World";
+
+// Only change code below this line
+myStr[0] = "H"; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+let myStr = "Jello World";
+myStr = "Hello World";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
new file mode 100644
index 00000000000..003644e928f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
@@ -0,0 +1,60 @@
+---
+id: bd7123c9c441eddfaeb5bdef
+title: Boolesche Werte verstehen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9Me8t4'
+forumTopicId: 301176
+dashedName: understanding-boolean-values
+---
+
+# --description--
+
+Ein weiterer Datentyp ist Boolean . Booleans können nur einen von zwei Werten annehmen: `true` oder `false`. Sie sind im Grunde kleine An-Aus-Schalter, bei denen `true` an und `false` aus ist. Diese beiden Zustände schließen sich gegenseitig aus.
+
+**Hinweis:** Boolesche Werte werden nie mit Anführungszeichen geschrieben. Die Strings `"true"` und `"false"` sind nicht boolesch und haben keine besondere Bedeutung in JavaScript.
+
+# --instructions--
+
+Ändere die Funktion `welcomeToBooleans` so, dass sie `true` statt `false` zurückgibt, wenn der Ausführen-Button geklickt wird.
+
+# --hints--
+
+Die Funktion `welcomeToBooleans()` sollte einen booleschen Wert (`true` oder `false`) zurückgeben.
+
+```js
+assert(typeof welcomeToBooleans() === 'boolean');
+```
+
+`welcomeToBooleans()` sollte `true` zurückgeben.
+
+```js
+assert(welcomeToBooleans() === true);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+welcomeToBooleans();
+```
+
+## --seed-contents--
+
+```js
+function welcomeToBooleans() {
+ // Only change code below this line
+
+ return false; // Change this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function welcomeToBooleans() {
+ return true; // Change this line
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
new file mode 100644
index 00000000000..c24e1cad7f1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244ab
+title: Verstehen der Groß-/Kleinschreibungsunterscheidung (Case-sensitivity) in Variablen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd6GDcD'
+forumTopicId: 18334
+dashedName: understanding-case-sensitivity-in-variables
+---
+
+# --description--
+
+In JavaScript wird bei allen Variablen und Funktionsnamen zwischen Groß- und Kleinschreibung unterschieden. Das bedeutet, dass die Großschreibung wichtig ist.
+
+`MYVAR` ist nicht dasselbe wie `MyVar` oder `myvar`. Es ist möglich, mehrere unterschiedliche Variablen mit demselben Namen, aber unterschiedlichen Bezeichnungen zu haben. Aus Gründen der Übersichtlichkeit wird dringend empfohlen, dieses Sprachmerkmal *nicht* zu verwenden.
+
+**Bewährte Praxis**
+
+Schreiben die Variablennamen in JavaScript in camelCase . Bei camelCase wird bei Variablennamen mit mehreren Wörtern das erste Wort kleingeschrieben und der erste Buchstabe jedes folgenden Wortes großgeschrieben.
+
+**Beispiele:**
+
+```js
+var someVariable;
+var anotherVariableName;
+var thisVariableNameIsSoLong;
+```
+
+# --instructions--
+
+Ändere die bestehenden Deklarationen und Zuweisungen so, dass ihre Namen camelCase verwenden.
+
+Erstelle keine neuen Variablen.
+
+# --hints--
+
+`studlyCapVar` sollte definiert sein und einen Wert von `10` haben.
+
+```js
+assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
+```
+
+`properCamelCase` sollte definiert werden und einen Wert des Strings `A String` haben.
+
+```js
+assert(
+ typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
+);
+```
+
+`titleCaseOver` sollte definiert werden und einen Wert von `9000` haben.
+
+```js
+assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
+```
+
+`studlyCapVar` sollte sowohl im Deklarations- als auch im Zuweisungsabschnitt camelCase verwenden.
+
+```js
+assert(code.match(/studlyCapVar/g).length === 2);
+```
+
+`properCamelCase` sollte sowohl im Deklarations- als auch im Zuweisungsabschnitt camelCase verwenden.
+
+```js
+assert(code.match(/properCamelCase/g).length === 2);
+```
+
+`titleCaseOver` sollte sowohl im Deklarations- als auch im Zuweisungsabschnitt camelCase verwenden.
+
+```js
+assert(code.match(/titleCaseOver/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Variable declarations
+var StUdLyCapVaR;
+var properCamelCase;
+var TitleCaseOver;
+
+// Variable assignments
+STUDLYCAPVAR = 10;
+PRoperCAmelCAse = "A String";
+tITLEcASEoVER = 9000;
+```
+
+# --solutions--
+
+```js
+var studlyCapVar;
+var properCamelCase;
+var titleCaseOver;
+
+studlyCapVar = 10;
+properCamelCase = "A String";
+titleCaseOver = 9000;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
new file mode 100644
index 00000000000..61f3759e374
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
@@ -0,0 +1,96 @@
+---
+id: 598e8944f009e646fc236146
+title: Undefinierte Werte, die von einer Funktion zurückgegeben werden, verstehen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2p7cL'
+forumTopicId: 301177
+dashedName: understanding-undefined-value-returned-from-a-function
+---
+
+# --description--
+
+Eine Funktion kann die `return`-Anweisung enthalten, muss sie aber nicht. In dem Fall, dass die Funktion keine `return`-Anweisung hat, wenn du sie aufrufst, verarbeitet die Funktion den inneren Code, aber der zurückgegebene Wert ist `undefined`.
+
+**Beispiel**
+
+```js
+let sum = 0;
+
+function addSum(num) {
+ sum = sum + num;
+}
+
+addSum(3);
+```
+
+`addSum` ist eine Funktion ohne eine `return`-Anweisung. Die Funktion wird die globale `sum` Variable ändern, aber der zurückgegebene Wert der Funktion ist `undefined`.
+
+# --instructions--
+
+Erstelle eine Funktion `addFive` ohne jegliche Argumente. Diese Funktion addiert 5 zur `sum` Variable, aber ihr zurückgegebener Wert ist `undefined`.
+
+# --hints--
+
+`addFive` sollte eine Funktion sein.
+
+```js
+assert(typeof addFive === 'function');
+```
+
+Wenn beide Funktionen ausgeführt wurden, sollte `sum` gleich `8` sein.
+
+```js
+assert(sum === 8);
+```
+
+Der Rückgabewert von `addFive` sollte `undefined` sein.
+
+```js
+assert(addFive() === undefined);
+```
+
+Innerhalb der `addFive` Funktion, solltest du `5` zur `sum` Variable hinzufügen.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(addFive.toString()).match(/sum=sum\+5|sum\+=5/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+// Only change code below this line
+
+
+// Only change code above this line
+
+addThree();
+addFive();
+```
+
+# --solutions--
+
+```js
+let sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+function addFive() {
+ sum = sum + 5;
+}
+
+addThree();
+addFive();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
new file mode 100644
index 00000000000..7a46533812f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -0,0 +1,79 @@
+---
+id: 56533eb9ac21ba0edf2244aa
+title: Nicht initialisierte Variablen verstehen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBa2JAL'
+forumTopicId: 18335
+dashedName: understanding-uninitialized-variables
+---
+
+# --description--
+
+Wenn JavaScript-Variablen deklariert werden, haben sie einen Anfangswert von `undefined`. Wenn du eine mathematische Operation mit `undefined`-Variablen durchführst, ist das Ergebnis `NaN`, was "Not a Number" (keine Zahl) bedeutet. Verkettest du den String einer `undefined`-Variablen, erhältst du den String `undefined`.
+
+# --instructions--
+
+Initialisiere die drei Variablen `a`, `b` und `c` mit `5`, `10` bzw. `"I am a"`, damit sie nicht `undefined` sind.
+
+# --hints--
+
+`a` sollte eine definierte Variable mit einem letztlichen Wert von `6` sein.
+
+```js
+assert(typeof a === 'number' && a === 6);
+```
+
+`b` sollte eine definierte Variable mit einem letztlichen Wert von `15` sein.
+
+```js
+assert(typeof b === 'number' && b === 15);
+```
+
+`c` sollte nicht `undefined` beinhalten und sollte letztlich auf den Wert `I am a String!` gesetzt sein
+
+```js
+assert(!/undefined/.test(c) && c === 'I am a String!');
+```
+
+Du solltest den Code unterhalb des vorgegebenen Kommentars nicht ändern.
+
+```js
+assert(
+ /a = a \+ 1;/.test(code) &&
+ /b = b \+ 5;/.test(code) &&
+ /c = c \+ " String!";/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var a;
+var b;
+var c;
+// Only change code above this line
+
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 10;
+var c = "I am a";
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
new file mode 100644
index 00000000000..f796ae0b6bd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392d1
+title: Objekteigenschaften aktualisieren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yEJT4'
+forumTopicId: 18336
+dashedName: updating-object-properties
+---
+
+# --description--
+
+Nachdem du ein JavaScript-Objekt erstellt hast, kannst du seine Eigenschaften jederzeit aktualisieren, so wie du jede andere Variable aktualisieren würdest. Du kannst entweder die Punkt- oder die Klammerschreibweise zum Aktualisieren verwenden.
+
+Schauen wir uns zum Beispiel `ourDog` an:
+
+```js
+const ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
+
+Da er ein besonders glücklicher Hund ist, ändern wir seinen Namen in den String `Happy Camper`. So aktualisieren wir die Namenseigenschaft seines Objekts: `ourDog.name = "Happy Camper";` oder `ourDog["name"] = "Happy Camper";` Wenn wir nun `ourDog.name` auswerten, erhalten wir statt `Camper` seinen neuen Namen, `Happy Camper`.
+
+# --instructions--
+
+Aktualisiere die Eigenschaft name des Objekts `myDog`. Lass uns ihren Namen von `Coder` in `Happy Coder` ändern. Du kannst entweder die Punkt- oder die Klammerschreibweise verwenden.
+
+# --hints--
+
+Du solltest die Eigenschaft `name` von `myDog` so ändern, dass sie den String `Happy Coder` enthält.
+
+```js
+assert(/happy coder/gi.test(myDog.name));
+```
+
+Du solltest die Definition von `myDog` nicht bearbeiten.
+
+```js
+assert(/"name": "Coder"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+myDog.name = "Happy Coder";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
new file mode 100644
index 00000000000..97d30169e5f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
@@ -0,0 +1,74 @@
+---
+id: bd7123c9c549eddfaeb5bdef
+title: Verwendung der Klammer-Notation, um das erste Zeichen in einem String zu finden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8JwhW'
+forumTopicId: 18341
+dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
+---
+
+# --description--
+
+Die Klammer-Notation ist eine Methode, um ein Zeichen an einem bestimmten Index innerhalb eines Strings zu erhalten.
+
+Die meisten modernen Programmiersprachen, wie z. B. JavaScript, beginnen nicht bei 1 zu zählen, wie es Menschen tun. Sie beginnen bei 0. Dies wird als nullbasierte Indizierung bezeichnet.
+
+Zum Beispiel ist das Zeichen bei Index 0 im Wort `Charles` das `C`. Wenn also `const firstName = "Charles"`, kannst du den Wert des ersten Buchstabens des Strings erhalten, indem du `firstName[0]` verwendest.
+
+Beispiel:
+
+```js
+const firstName = "Charles";
+const firstLetter = firstName[0];
+```
+
+`firstLetter` hätte den Wert `C`.
+
+# --instructions--
+
+Verwende die Klammer-Notation, um das erste Zeichen in der Variablen `lastName` zu finden und weise es `firstLetterOfLastName` zu.
+
+**Hinweis:** Wenn du nicht weiterkommst, schau dir das Beispiel oben an.
+
+# --hints--
+
+Die Variable `firstLetterOfLastName` sollte den Wert von `L` haben.
+
+```js
+assert(firstLetterOfLastName === 'L');
+```
+
+Du solltest die Klammer-Notation verwenden.
+
+```js
+assert(code.match(/firstLetterOfLastName\s*=\s*lastName\s*\[\s*\d\s*\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(firstLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName[0];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
new file mode 100644
index 00000000000..34223b8895c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c451eddfaeb5bdef
+title: Verwendung der Klammer-Notation um das letzte Zeichen in einem String zu finden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQGcv'
+forumTopicId: 18342
+dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
+---
+
+# --description--
+
+Um den letzten Buchstaben eines Strings zu erhalten, kann man einen von der Länge des Strings subtrahieren.
+
+Wenn zum Beispiel `const firstName = "Ada"`, kannst du den Wert des letzten Buchstabens des Strings erhalten, indem du `firstName[firstName.length - 1]` verwendest.
+
+Beispiel:
+
+```js
+const firstName = "Ada";
+const lastLetter = firstName[firstName.length - 1];
+```
+
+`lastLetter` hätte den Wert des Strings `a`.
+
+# --instructions--
+
+Verwende die Klammer-Notation , um das letzte Zeichen in der Variable `lastName` zu finden.
+
+**Hinweis:** Wenn du nicht weiterkommst, schau dir das Beispiel oben an.
+
+# --hints--
+
+`lastLetterOfLastName` sollte der Buchstabe `e` sein.
+
+```js
+assert(lastLetterOfLastName === 'e');
+```
+
+Du solltest `.length` verwenden, um den letzten Buchstaben zu erhalten.
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(lastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const lastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const lastLetterOfLastName = lastName[lastName.length - 1];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
new file mode 100644
index 00000000000..500e457ee0f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c450eddfaeb5bdef
+title: Verwendung der Klammer-Notation, um das n-te Zeichen in einem String zu finden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVJua'
+forumTopicId: 18343
+dashedName: use-bracket-notation-to-find-the-nth-character-in-a-string
+---
+
+# --description--
+
+Du kannst die Klammer-Notation auch verwenden, um das Zeichen an anderen Position innerhalb eines Strings zu erhalten.
+
+Denke daran, dass Computer bei `0` zu zählen beginnen, so dass das erste Zeichen eigentlich das nullte Zeichen ist.
+
+Beispiel:
+
+```js
+const firstName = "Ada";
+const secondLetterOfFirstName = firstName[1];
+```
+
+`secondLetterOfFirstName` würde den Wert des Strings `d` besitzen.
+
+# --instructions--
+
+Versuchen wir, `thirdLetterOfLastName` so zu setzen, dass sie dem dritten Buchstaben der Variablen `lastName` entspricht, indem wir die Klammer-Notation verwenden.
+
+**Hinweis:** Wenn du nicht weiterkommst, schau dir das Beispiel oben an.
+
+# --hints--
+
+Die Variable `thirdLetterOfLastName` sollte den Wert von `v` besitzen.
+
+```js
+assert(thirdLetterOfLastName === 'v');
+```
+
+Du solltest die Klammer-Notation verwenden.
+
+```js
+assert(code.match(/thirdLetterOfLastName\s*=\s*lastName\s*\[\s*\d\s*\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(thirdLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const thirdLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const thirdLetterOfLastName = lastName[2];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
new file mode 100644
index 00000000000..0965c4e7457
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c452eddfaeb5bdef
+title: Verwendung der Klammer-Notation um das n-te bis letzte Zeichen in einem String zu finden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cw4vkh9'
+forumTopicId: 18344
+dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
+---
+
+# --description--
+
+Du kannst das gleiche Prinzip, das wir gerade verwendet haben, um das letzte Zeichen in einer Zeichenkette abzurufen, verwenden, um das n-te bis letzte Zeichen abzurufen.
+
+Zum Beispiel kannst du den Wert des drittletzten Buchstabens des Strings `const firstName = "Augusta"` erhalten, indem du `firstName[firstName.length - 3]` verwendest.
+
+Beispiel:
+
+```js
+const firstName = "Augusta";
+const thirdToLastLetter = firstName[firstName.length - 3];
+```
+
+`thirdToLastLetter` hätte den Wert des Strings `s`.
+
+# --instructions--
+
+Verwende die Klammer-Notation , um das vorletzte Zeichen in dem String `lastName` zu finden.
+
+**Hinweis:** Wenn du nicht weiterkommst, schau dir das Beispiel oben an.
+
+# --hints--
+
+`secondToLastLetterOfLastName` sollte den Buchstaben `c` enthalten.
+
+```js
+assert(secondToLastLetterOfLastName === 'c');
+```
+
+Du solltest `.length` verwenden, um den vorletzten Buchstaben zu erhalten.
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(secondToLastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const secondToLastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const secondToLastLetterOfLastName = lastName[lastName.length - 2];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
new file mode 100644
index 00000000000..c07afa10d31
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
@@ -0,0 +1,98 @@
+---
+id: cf1111c1c12feddfaeb3bdef
+title: Verwende bedingte Logik mit If-Anweisungen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87mf3'
+forumTopicId: 18348
+dashedName: use-conditional-logic-with-if-statements
+---
+
+# --description--
+
+`if`-Anweisungen werden verwendet, um Entscheidungen im Code zu treffen. Das Schlüsselwort `if` weist JavaScript an, den Code in den geschweiften Klammern unter bestimmten Bedingungen auszuführen, die in den Klammern definiert sind. Diese Bedingungen sind als `Boolean`-Bedingungen bekannt und sie können nur `true` oder `false` sein.
+
+Wenn die Bedingung als `true` ausgewertet wird, führt das Programm die Anweisung innerhalb der geschweiften Klammern aus. Wenn die boolesche Bedingung als `false` ausgewertet wird, wird die Anweisung innerhalb der geschweiften Klammern nicht ausgeführt.
+
+**Pseudocode**
+
+if (Bedingung ist wahr ) {Anweisung wird ausgeführt
+
+**Beispiel**
+
+```js
+function test (myCondition) {
+ if (myCondition) {
+ return "It was true";
+ }
+ return "It was false";
+}
+
+test(true);
+test(false);
+```
+
+`test(true)` gibt den String `It was true` zurück, und `test(false)` gibt den String `It was false` zurück.
+
+Wenn `test` mit einem Wert von `true` aufgerufen wird, wertet die `if`-Anweisung `myCondition` aus, um zu sehen, ob sie `true` ist oder nicht. Da es `true` ist, gibt die Funktion `It was true` zurück. Wenn wir `test` mit einem Wert von `false` aufrufen, ist `myCondition` *nicht* `true` und die Anweisung in den geschweiften Klammern wird nicht ausgeführt und die Funktion gibt `It was false` zurück.
+
+# --instructions--
+
+Erstelle eine `if`-Anweisung innerhalb der Funktion, um `Yes, that was true` zurückzugeben, wenn der Parameter `wasThatTrue` gleich `true` ist und ansonsten `No, that was false`.
+
+# --hints--
+
+`trueOrFalse` sollte eine Funktion sein
+
+```js
+assert(typeof trueOrFalse === 'function');
+```
+
+`trueOrFalse(true)` sollte einen String zurückgeben
+
+```js
+assert(typeof trueOrFalse(true) === 'string');
+```
+
+`trueOrFalse(false)` sollte einen String zurückgeben
+
+```js
+assert(typeof trueOrFalse(false) === 'string');
+```
+
+`trueOrFalse(true)` sollte den String `Yes, that was true` zurückgeben
+
+```js
+assert(trueOrFalse(true) === 'Yes, that was true');
+```
+
+`trueOrFalse(false)` sollte den String `No, that was false` zurückgeben
+
+```js
+assert(trueOrFalse(false) === 'No, that was false');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+
+}
+```
+
+# --solutions--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ if (wasThatTrue) {
+ return "Yes, that was true";
+ }
+ return "No, that was false";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
new file mode 100644
index 00000000000..c2a17578b0d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
@@ -0,0 +1,96 @@
+---
+id: 587d7b7e367417b2b2512b21
+title: Verwende mehrere bedingte (ternäre) Operatoren
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJBT4'
+forumTopicId: 301179
+dashedName: use-multiple-conditional-ternary-operators
+---
+
+# --description--
+
+In der vorherigen Aufgabe hast du einen einzelnen bedingten Operator verwendet. Du kannst sie auch miteinander verketten, um mehrere Bedingungen zu prüfen.
+
+Die folgende Funktion verwendet `if`, `else if` und `else`-Anweisungen, um mehrere Bedingungen zu prüfen:
+
+```js
+function findGreaterOrEqual(a, b) {
+ if (a === b) {
+ return "a and b are equal";
+ }
+ else if (a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater";
+ }
+}
+```
+
+Die obige Funktion kann mit mehreren bedingten Operatoren umgeschrieben werden:
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal"
+ : (a > b) ? "a is greater"
+ : "b is greater";
+}
+```
+
+Es gilt als bewährte Praxis, mehrere bedingte Operatoren so zu formatieren, dass jede Bedingung in einer eigenen Zeile steht, wie oben gezeigt. Wenn du mehrere bedingte Operatoren ohne korrekte Einrückung verwendest, kann dein Code schwer zu lesen sein. Zum Beispiel:
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal" : (a > b) ? "a is greater" : "b is greater";
+}
+```
+
+# --instructions--
+
+In der Funktion `checkSign` verwendest du mehrere bedingte Operatoren - in Anlehnung an das empfohlene Format in `findGreaterOrEqual` - um zu prüfen, ob eine Zahl positiv, negativ oder Null ist. Die Funktion sollte `positive`, `negative` oder `zero` zurückgeben.
+
+# --hints--
+
+`checkSign` sollte mehrere bedingte Operatoren verwenden
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));
+```
+
+`checkSign(10)` sollte den String `positive` zurückgeben. Beachte, dass die Großschreibung wichtig ist
+
+```js
+assert(checkSign(10) === 'positive');
+```
+
+`checkSign(-12)` sollte den String `negative` zurückgeben. Beachte, dass die Großschreibung wichtig ist
+
+```js
+assert(checkSign(-12) === 'negative');
+```
+
+`checkSign(0)` sollte den String `zero` zurückgeben. Beachte, dass die Großschreibung wichtig ist
+
+```js
+assert(checkSign(0) === 'zero');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkSign(num) {
+
+}
+
+checkSign(10);
+```
+
+# --solutions--
+
+```js
+function checkSign(num) {
+ return (num > 0) ? 'positive' : (num < 0) ? 'negative' : 'zero';
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
new file mode 100644
index 00000000000..b7ff7187917
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
@@ -0,0 +1,92 @@
+---
+id: 5cd9a70215d3c4e65518328f
+title: Verwende Rekursion, um einen Countdown zu erstellen
+challengeType: 1
+forumTopicId: 305925
+dashedName: use-recursion-to-create-a-countdown
+---
+
+# --description--
+
+In einer vorherigen Aufgabe hast du gelernt, wie man eine `for`-Schleife durch Rekursion ersetzt. Schauen wir uns nun eine komplexere Funktion an, die ein Array von aufeinanderfolgenden ganzen Zahlen (Intergers) zurückgibt, beginnend mit `1` bis zu der an die Funktion übergebenen Zahl.
+
+Wie in der vorhergehenden Aufgabe erwähnt, wird es einen Basisfall geben. Der Basisfall teilt der rekursiven Funktion mit, wann sie sich nicht mehr selbst aufrufen muss. Es handelt sich um einen einfachen Fall, bei dem der Rückgabewert bereits bekannt ist. Es wird auch einen rekursiven Aufruf geben, der die ursprüngliche Funktion mit anderen Argumenten ausführt. Wenn die Funktion richtig geschrieben ist, wird schließlich der Basisfall erreicht.
+
+Angenommen, du willst eine rekursive Funktion schreiben, die ein Array mit den Zahlen `1` bis `n` zurückgibt. Diese Funktion muss ein Argument, `n`, akzeptieren, das die endgültige Zahl darstellt. Dann muss er sich selbst mit immer kleineren Werten von `n` aufrufen, bis er `1` erreicht. Du könntest die Funktion wie folgt schreiben:
+
+```javascript
+function countup(n) {
+ if (n < 1) {
+ return [];
+ } else {
+ const countArray = countup(n - 1);
+ countArray.push(n);
+ return countArray;
+ }
+}
+console.log(countup(5));
+```
+
+Der Wert `[1, 2, 3, 4, 5]` wird in der Konsole angezeigt.
+
+Auf den ersten Blick erscheint dies widersprüchlich, da der Wert von `n` *abnehmend* ist, aber die Werte im endgültigen Array sind *zunehmend*. Das liegt daran, dass der Push zuletzt erfolgt, nachdem der rekursive Aufruf zurückgekehrt ist. An dem Punkt, an dem `n` in das Array geschoben wird, wurde `countup(n - 1)` bereits ausgewertet und liefert `[1, 2, ..., n - 1]`.
+
+# --instructions--
+
+Wir haben eine Funktion namens `countdown` mit einem Parameter (`n`) definiert. Die Funktion sollte eine Rekursion verwenden, um ein Array mit den ganzen Zahlen `n` bis `1` basierend auf dem Parameter `n` zurückzugeben. Wenn die Funktion mit einer Zahl kleiner als 1 aufgerufen wird, sollte die Funktion ein leeres Array zurückgeben. Wenn du diese Funktion zum Beispiel mit `n = 5` aufrufst, wird das Array `[5, 4, 3, 2, 1]` zurückgegeben. Deine Funktion muss eine Rekursion verwenden, indem sie sich selbst aufruft und darf keine Schleifen verwenden.
+
+# --hints--
+
+`countdown(-1)` sollte ein leeres Array zurückgeben.
+
+```js
+assert.isEmpty(countdown(-1));
+```
+
+`countdown(10)` sollte `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]` zurückgeben
+
+```js
+assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+```
+
+`countdown(5)` sollte `[5, 4, 3, 2, 1]` zurückgeben
+
+```js
+assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
+```
+
+Dein Code sollte keine Schleifen enthalten (`for`, `while` oder Funktionen höherer Ordnung wie `forEach`, `map`, `filter` und `reduce`).
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+Um dieses Problem zu lösen, solltest du eine Rekursion verwenden.
+
+```js
+assert(
+ countdown.toString().match(/countdown\s*\(.+\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+function countdown(n){
+ return;
+}
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+function countdown(n){
+ return n < 1 ? [] : [n].concat(countdown(n - 1));
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
new file mode 100644
index 00000000000..07966ec6618
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
@@ -0,0 +1,81 @@
+---
+id: 5cc0bd7a49b71cb96132e54c
+title: Benutze die Rekursion, um eine Reihe von Zahlen zu erstellen
+challengeType: 1
+forumTopicId: 301180
+dashedName: use-recursion-to-create-a-range-of-numbers
+---
+
+# --description--
+
+In Fortsetzung der vorherigen Aufgabe bieten wir dir eine weitere Möglichkeit an, eine rekursive Funktion zu erstellen, um ein Problem zu lösen.
+
+# --instructions--
+
+Wir haben eine Funktion namens `rangeOfNumbers` mit zwei Parametern definiert. Die Funktion sollte ein Array von Ganzzahlen zurückgeben, das mit einer Zahl beginnt, die durch den Parameter `startNum` dargestellt wird, und mit einer Zahl endet, die durch den Parameter `endNum` dargestellt wird. Die Startnummer ist immer kleiner oder gleich der Endnummer. Deine Funktion muss eine Rekursion verwenden, indem sie sich selbst aufruft, und darf keinerlei Schleifen verwenden. Es sollte auch funktionieren, wenn `startNum` und `endNum` gleich sind.
+
+# --hints--
+
+Deine Funktion sollte ein Array zurückgeben.
+
+```js
+assert(Array.isArray(rangeOfNumbers(5, 10)));
+```
+
+Dein Code sollte keine Schleifensyntax verwenden (`for` oder `while` oder Funktionen höherer Ordnung wie `forEach`, `map`, `filter` oder `reduce`).
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+`rangeOfNumbers` sollte die Rekursion nutzen (sich selbst aufrufen), um diese Aufgabe zu lösen.
+
+```js
+assert(
+ rangeOfNumbers.toString().match(/rangeOfNumbers\s*\(.+\)/)
+);
+```
+
+`rangeOfNumbers(1, 5)` sollte `[1, 2, 3, 4, 5]` zurückgeben.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(1, 5), [1, 2, 3, 4, 5]);
+```
+
+`rangeOfNumbers(6, 9)` sollte `[6, 7, 8, 9]` zurückgeben.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(6, 9), [6, 7, 8, 9]);
+```
+
+`rangeOfNumbers(4, 4)` sollte `[4]` zurückgeben.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(4, 4), [4]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ return [];
+};
+```
+
+# --solutions--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ if (endNum - startNum === 0) {
+ return [startNum];
+ } else {
+ const numbers = rangeOfNumbers(startNum, endNum - 1);
+ numbers.push(endNum);
+ return numbers;
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
new file mode 100644
index 00000000000..3712410207b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
@@ -0,0 +1,84 @@
+---
+id: 587d7b7e367417b2b2512b24
+title: Den bedingten (ternären) Operator verwenden
+challengeType: 1
+forumTopicId: 301181
+dashedName: use-the-conditional-ternary-operator
+---
+
+# --description--
+
+Der bedingte Operator , auch Dreifach-Operator genannt, kann als einzeiliger if-else-Ausdruck verwendet werden.
+
+Die Syntax lautet `a ? b : c`, wobei `a` die Bedingung ist, `b` ist der Code, der ausgeführt werden soll, wenn die Bedingung `true` zurückgibt und `c` der Code ist, der ausgeführt werden soll, wenn die Bedingung `false` zurückgibt.
+
+Die folgende Funktion verwendet eine `if/else`-Anweisung, um eine Bedingung zu prüfen:
+
+```js
+function findGreater(a, b) {
+ if(a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater or equal";
+ }
+}
+```
+
+Dies kann mit dem bedingten Operator umgeschrieben werden:
+
+```js
+function findGreater(a, b) {
+ return a > b ? "a is greater" : "b is greater or equal";
+}
+```
+
+# --instructions--
+
+Verwende den bedingten Operator in der Funktion `checkEqual`, um zu prüfen, ob zwei Zahlen gleich sind oder nicht. Die Funktion sollte entweder den String `Equal` oder den String `Not Equal` zurückgeben.
+
+# --hints--
+
+`checkEqual` sollte den bedingten Operator verwenden
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/.test(code));
+```
+
+`checkEqual(1, 2)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(checkEqual(1, 2) === 'Not Equal');
+```
+
+`checkEqual(1, 1)` sollte den String `Equal` zurückgeben
+
+```js
+assert(checkEqual(1, 1) === 'Equal');
+```
+
+`checkEqual(1, -1)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(checkEqual(1, -1) === 'Not Equal');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkEqual(a, b) {
+
+}
+
+checkEqual(1, 2);
+```
+
+# --solutions--
+
+```js
+function checkEqual(a, b) {
+ return a === b ? "Equal" : "Not Equal";
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
new file mode 100644
index 00000000000..7a1ad059b8c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
@@ -0,0 +1,82 @@
+---
+id: 587d7b7e367417b2b2512b22
+title: Benutze die parseInt Funktion mit einem Radix
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6K4Kh3'
+forumTopicId: 301182
+dashedName: use-the-parseint-function-with-a-radix
+---
+
+# --description--
+
+Die Funktion `parseInt()` parst einen String und gibt eine Ganzzahl zurück. Sie nimmt ein zweites Argument für das Radix, das die Basis der Zahl in dem String angibt. Das Radix kann eine ganze Zahl zwischen 2 und 36 sein.
+
+Der Funktionsaufruf sieht wie folgt aus:
+
+```js
+parseInt(string, radix);
+```
+
+Und hier ist ein Beispiel:
+
+```js
+const a = parseInt("11", 2);
+```
+
+Die Radix-Variable sagt, dass `11` im Binärsystem oder zur Basis 2 ist. Dieses Beispiel wandelt den String `11` in eine Ganzzahl `3` um.
+
+# --instructions--
+
+Verwende `parseInt()` in der Funktion `convertToInteger`, damit sie eine Binärzahl in eine Ganzzahl umwandelt und diese zurückgibt.
+
+# --hints--
+
+`convertToInteger` sollte die Funktion `parseInt()` verwenden
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("10011")` sollte eine Zahl zurückgeben
+
+```js
+assert(typeof convertToInteger('10011') === 'number');
+```
+
+`convertToInteger("10011")` sollte 19 zurückgeben
+
+```js
+assert(convertToInteger('10011') === 19);
+```
+
+`convertToInteger("111001")` sollte 57 zurückgeben
+
+```js
+assert(convertToInteger('111001') === 57);
+```
+
+`convertToInteger("JamesBond")` sollte `NaN` zurückgeben
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("10011");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str, 2);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
new file mode 100644
index 00000000000..2444884c292
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b7e367417b2b2512b23
+title: Verwende die Funktion parseInt
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83LSW'
+forumTopicId: 301183
+dashedName: use-the-parseint-function
+---
+
+# --description--
+
+Die Funktion `parseInt()` parst einen String und gibt eine Ganzzahl zurück. Hier ist ein Beispiel:
+
+```js
+const a = parseInt("007");
+```
+
+Die obige Funktion wandelt den String `007` in die Ganzzahl `7` um. Wenn das erste Zeichen in dem String nicht in eine Zahl umgewandelt werden kann, dann wird `NaN` zurückgegeben.
+
+# --instructions--
+
+Verwende `parseInt()` in der Funktion `convertToInteger`, damit sie den Eingabestring `str` in eine Ganzzahl umwandelt und zurückgibt.
+
+# --hints--
+
+`convertToInteger` sollte die Funktion `parseInt()` verwenden
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("56")` sollte eine Zahl zurückgeben
+
+```js
+assert(typeof convertToInteger('56') === 'number');
+```
+
+`convertToInteger("56")` sollte 56 zurückgeben
+
+```js
+assert(convertToInteger('56') === 56);
+```
+
+`convertToInteger("77")` sollte 77 zurückgeben
+
+```js
+assert(convertToInteger('77') === 77);
+```
+
+`convertToInteger("JamesBond")` sollte `NaN` zurückgeben
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("56");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
new file mode 100644
index 00000000000..e72af9f0060
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
@@ -0,0 +1,155 @@
+---
+id: 56533eb9ac21ba0edf2244ca
+title: Objekte für die Suche verwenden
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBk8sM'
+forumTopicId: 18373
+dashedName: using-objects-for-lookups
+---
+
+# --description--
+
+Objekte kann man sich als Schlüssel/Wert-Speicher vorstellen, wie ein Wörterbuch. Wenn du tabellarische Daten hast, kannst du ein Objekt zum Nachschlagen von Werten verwenden, anstatt eine `switch`-Anweisung oder eine `if/else`-Kette. Das ist besonders nützlich, wenn du weißt, dass deine Eingabedaten auf einen bestimmten Bereich beschränkt sind.
+
+Hier ist ein Beispiel für eine einfache Suche nach dem umgekehrten Alphabet:
+
+```js
+const alpha = {
+ 1:"Z",
+ 2:"Y",
+ 3:"X",
+ 4:"W",
+ ...
+ 24:"C",
+ 25:"B",
+ 26:"A"
+};
+
+const thirdLetter = alpha[2];
+const lastLetter = alpha[24];
+
+const value = 2;
+const valueLookup = alpha[value];
+```
+
+`thirdLetter` ist der String `Y`, `lastLetter` ist der String `C` und `valueLookup` ist der String `Y`.
+
+# --instructions--
+
+Wandle die switch-Anweisung in ein Objekt namens `lookup` um. Verwende sie, um `val` nachzuschlagen und den zugehörigen String der Variablen `result` zuzuweisen.
+
+# --hints--
+
+`phoneticLookup("alpha")` sollte gleich dem String `Adams` sein
+
+```js
+assert(phoneticLookup('alpha') === 'Adams');
+```
+
+`phoneticLookup("bravo")` sollte gleich dem String `Boston` sein
+
+```js
+assert(phoneticLookup('bravo') === 'Boston');
+```
+
+`phoneticLookup("charlie")` sollte gleich dem String `Chicago` sein
+
+```js
+assert(phoneticLookup('charlie') === 'Chicago');
+```
+
+`phoneticLookup("delta")` sollte gleich dem String `Denver` sein
+
+```js
+assert(phoneticLookup('delta') === 'Denver');
+```
+
+`phoneticLookup("echo")` sollte gleich dem String `Easy` sein
+
+```js
+assert(phoneticLookup('echo') === 'Easy');
+```
+
+`phoneticLookup("foxtrot")` sollte gleich dem String `Frank` sein
+
+```js
+assert(phoneticLookup('foxtrot') === 'Frank');
+```
+
+`phoneticLookup("")` sollte gleich `undefined` sein
+
+```js
+assert(typeof phoneticLookup('') === 'undefined');
+```
+
+Du solltest die `return`-Anweisung nicht ändern
+
+```js
+assert(code.match(/return\sresult;/));
+```
+
+Du solltest keine `case`-, `switch`- oder `if`-Anweisungen verwenden
+
+```js
+assert(
+ !/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g, ''))
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function phoneticLookup(val) {
+ let result = "";
+
+ // Only change code below this line
+ switch(val) {
+ case "alpha":
+ result = "Adams";
+ break;
+ case "bravo":
+ result = "Boston";
+ break;
+ case "charlie":
+ result = "Chicago";
+ break;
+ case "delta":
+ result = "Denver";
+ break;
+ case "echo":
+ result = "Easy";
+ break;
+ case "foxtrot":
+ result = "Frank";
+ }
+
+ // Only change code above this line
+ return result;
+}
+
+phoneticLookup("charlie");
+```
+
+# --solutions--
+
+```js
+function phoneticLookup(val) {
+ let result = "";
+
+ const lookup = {
+ alpha: "Adams",
+ bravo: "Boston",
+ charlie: "Chicago",
+ delta: "Denver",
+ echo: "Easy",
+ foxtrot: "Frank"
+ };
+
+ result = lookup[val];
+
+ return result;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
new file mode 100644
index 00000000000..abeeefccc66
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
@@ -0,0 +1,105 @@
+---
+id: 56533eb9ac21ba0edf2244bb
+title: Lückentext (Word Blanks)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caqn8zuP'
+forumTopicId: 18377
+dashedName: word-blanks
+---
+
+# --description--
+
+Du erhältst Sätze mit einigen fehlenden Wörtern wie Nomen, Verben, Adjektiven und Adverbien. Anschließend ergänzt du die fehlenden Teile mit Wörtern deiner Wahl und so, dass der vollständige Satz einen Sinn ergibt.
+
+Betrachte diesen Satz – Es war wirklich **\_\_\_\_** und wir **\_\_\_\_** uns selbst **\_\_\_\_**. In diesem Satz fehlen drei Teile – ein Adjektiv, ein Verb und ein Adverb. Wir können Wörter unserer Wahl hinzufügen, um ihn zu vervollständigen. Anschließend können wir den vervollständigten Satz wie folgt einer Variable zuordnen:
+
+```js
+const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
+```
+
+# --instructions--
+
+In dieser Aufgabe stellen wir dir jeweils ein Nomen, ein Verb und ein Adjektiv sowie ein Adverb zur Verfügung. Du musst einen vollständigen Satz mit Wörtern deiner Wahl und den von uns vorgegebenen Wörtern bilden.
+
+Du musst den String-Verkettungsoperator `+` verwenden, um einen neuen String mithilfe der vorgegebenen Variablen `myNoun`, `myAdjective`, `myVerb` und `myAdverb` zu kreieren. Anschließend musst du den so gebildeten String der Variable `wordBlanks` zuweisen. Du solltest die Wörter, die den Variablen zugeordnet sind, nicht ändern.
+
+Berücksichtige zudem Leerzeichen in deinem String – die Wörter deines Satzes müssen von Leerzeichen umgeben sein. Das Ergebnis sollte ein vollständiger Satz sein.
+
+# --hints--
+
+`wordBlanks` sollte ein String sein.
+
+```js
+assert(typeof wordBlanks === 'string');
+```
+
+Du solltest die Werte von `myNoun`, `myVerb`, `myAdjective` oder `myAdverb` nicht verändern.
+
+```js
+assert(
+ myNoun === 'dog' &&
+ myVerb === 'ran' &&
+ myAdjective === 'big' &&
+ myAdverb === 'quickly'
+);
+```
+
+Du solltest nicht ausschließlich die Werte `dog`, `ran`, `big` oder `quickly` zur Erstellung von `wordBlanks` verwenden.
+
+```js
+const newCode = removeAssignments(code);
+assert(
+ !/dog/.test(newCode) &&
+ !/ran/.test(newCode) &&
+ !/big/.test(newCode) &&
+ !/quickly/.test(newCode)
+);
+```
+
+`wordBlanks` sollte alle – durch beliebige Nichtwortzeichen getrennte – Wörter enthalten, die den Variablen `myNoun`, `myVerb`, `myAdjective` und `myAdverb` zugewiesen wurden. Du kannst zudem Wörter deiner Wahl hinzufügen.
+
+```js
+assert(
+ /\bdog\b/.test(wordBlanks) &&
+ /\bbig\b/.test(wordBlanks) &&
+ /\bran\b/.test(wordBlanks) &&
+ /\bquickly\b/.test(wordBlanks)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const removeAssignments = str => str
+ .replace(/myNoun\s*=\s*["']dog["']/g, '')
+ .replace(/myAdjective\s*=\s*["']big["']/g, '')
+ .replace(/myVerb\s*=\s*["']ran["']/g, '')
+ .replace(/myAdverb\s*=\s*["']quickly["']/g, '');
+```
+
+## --seed-contents--
+
+```js
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
+
+// Only change code below this line
+const wordBlanks = ""; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
+
+let wordBlanks = "Once there was a " + myNoun + " which was very " + myAdjective + ". ";
+wordBlanks += "It " + myVerb + " " + myAdverb + " around the yard.";
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
new file mode 100644
index 00000000000..684b37bb730
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
@@ -0,0 +1,101 @@
+---
+id: 56bbb991ad1ed5201cd392cf
+title: Schreibe wiederverwendbares JavaScript mit Funktionen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cL6dqfy'
+forumTopicId: 18378
+dashedName: write-reusable-javascript-with-functions
+---
+
+# --description--
+
+In JavaScript können wir unseren Code in wiederverwendbare Teile aufteilen, die Funktionen genannt werden.
+
+Hier ist ein Beispiel für eine Funktion:
+
+```js
+function functionName() {
+ console.log("Hello World");
+}
+```
+
+Du kannst diese Funktion aufrufen (call) oder aufrufen (invoke) , indem du ihren Namen gefolgt von Klammern benutzt, wie hier: `functionName();` Jedes Mal, wenn die Funktion aufgerufen wird, wird sie die Nachricht `Hello World` auf der Konsole ausgeben. Der gesamte Code zwischen den geschweiften Klammern wird jedes Mal ausgeführt, wenn die Funktion aufgerufen wird.
+
+# --instructions--
+
+
+
+ Erstelle eine Funktion namens reusableFunction, die den String Hi World auf der Konsole ausgibt.
+
+
+ Rufe die Funktion auf.
+
+
+
+# --hints--
+
+`reusableFunction` sollte eine Funktion sein.
+
+```js
+assert(typeof reusableFunction === 'function');
+```
+
+Wenn `reusableFunction` aufgerufen wird, sollte sie den String `Hi World` auf der Konsole ausgeben.
+
+```js
+assert(testConsole());
+```
+
+Du solltest `reusableFunction` aufrufen, sobald sie definiert ist.
+
+```js
+const functionStr = reusableFunction && __helpers.removeWhiteSpace(reusableFunction.toString());
+const codeWithoutFunction = __helpers.removeWhiteSpace(code).replace(/reusableFunction\(\)\{/g, '');
+assert(/reusableFunction\(\)/.test(codeWithoutFunction));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+
+function testConsole() {
+ var logOutput = "";
+ var originalConsole = console;
+ var nativeLog = console.log;
+ var hiWorldWasLogged = false;
+ console.log = function (message) {
+ if(message === 'Hi World') {
+ console.warn(message)
+ hiWorldWasLogged = true;
+ }
+ if(message && message.trim) logOutput = message.trim();
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+ reusableFunction();
+ console.log = nativeLog;
+ return hiWorldWasLogged;
+}
+
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function reusableFunction() {
+ console.log("Hi World");
+}
+reusableFunction();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md
new file mode 100644
index 00000000000..ff010b37726
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md
@@ -0,0 +1,57 @@
+---
+id: 587d7b85367417b2b2512b3a
+title: Fange Argumente ab, die beim Aufruf einer Funktion in der falschen Reihenfolge übergeben wurden
+challengeType: 1
+forumTopicId: 301184
+dashedName: catch-arguments-passed-in-the-wrong-order-when-calling-a-function
+---
+
+# --description--
+
+Wenn man die Diskussion über aufrufende Funktionen fortsetzt, ist der nächste Fehler, auf den man achten sollte, die Angabe der Argumente einer Funktion in der falschen Reihenfolge. Wenn die Argumente von unterschiedlichem Typ sind, z. B. eine Funktion, die ein Array und eine ganze Zahl (Integer) erwartet, wird dies wahrscheinlich einen Laufzeitfehler auslösen. Wenn die Argumente vom gleichen Typ sind (zum Beispiel alle Integer), dann ergibt die Logik des Codes keinen Sinn. Stelle sicher, dass alle erforderlichen Argumente in der richtigen Reihenfolge angegeben sind, um diese Probleme zu vermeiden.
+
+# --instructions--
+
+Die Funktion `raiseToPower` erhöht eine Basis um einen Exponenten. Leider wird sie nicht richtig aufgerufen - korrigiere den Code, damit der Wert von `power` die erwartete 8 ergibt.
+
+# --hints--
+
+Dein Code sollte die Variable `power` so ändern, dass sie 2³ entspricht und nicht 3².
+
+```js
+assert(power == 8);
+```
+
+Dein Code sollte die richtige Reihenfolge der Argumente für den Funktionsaufruf von `raiseToPower` verwenden.
+
+```js
+assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(exp, base);
+console.log(power);
+```
+
+# --solutions--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(base, exp);
+console.log(power);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md
new file mode 100644
index 00000000000..c38d1226ccb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md
@@ -0,0 +1,69 @@
+---
+id: 587d7b85367417b2b2512b39
+title: Fehlende offene und schließende Klammern nach einem Funktionsaufruf abfangen
+challengeType: 1
+forumTopicId: 301185
+dashedName: catch-missing-open-and-closing-parenthesis-after-a-function-call
+---
+
+# --description--
+
+Wenn eine Funktion oder Methode keine Argumente annimmt, kann es sein, dass Du beim Aufruf vergisst, die (leeren) öffnenden und schließenden Klammern zu setzen. Oft wird das Ergebnis eines Funktionsaufrufs in einer Variablen gespeichert, die du dann in deinem Code weiterverwenden kannst. Dieser Fehler kann erkannt werden, indem Variablenwerte (oder ihre Typen) auf der Konsole protokolliert werden und festgestellt wird, dass eine Variable auf eine Funktionsreferenz gesetzt ist, anstatt auf den erwarteten Wert, den die Funktion zurückgibt.
+
+Die Variablen im folgenden Beispiel sind unterschiedlich:
+
+```js
+function myFunction() {
+ return "You rock!";
+}
+let varOne = myFunction;
+let varTwo = myFunction();
+```
+
+Hier ist `varOne` die Funktion `myFunction` und `varTwo` ist der String `You rock!`.
+
+# --instructions--
+
+Korrigiere den Code so, dass die Variable `result` auf den Wert gesetzt wird, der beim Aufruf der Funktion `getNine` zurückgegeben wird.
+
+# --hints--
+
+Dein Code sollte die Variable `result` so verändern, dass sie auf die Zahl gesetzt wird, die die Funktion `getNine` zurückgibt.
+
+```js
+assert(result == 9);
+```
+
+Dein Code sollte die Funktion `getNine` aufrufen.
+
+```js
+assert(code.match(/getNine\(\)/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine;
+console.log(result);
+```
+
+# --solutions--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine();
+console.log(result);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md
new file mode 100644
index 00000000000..40559a7f7e2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md
@@ -0,0 +1,69 @@
+---
+id: 587d7b84367417b2b2512b35
+title: Falsch geschriebene Variablen- und Funktionsnamen abfangen
+challengeType: 1
+forumTopicId: 301186
+dashedName: catch-misspelled-variable-and-function-names
+---
+
+# --description--
+
+Die Methoden `console.log()` und `typeof` sind die beiden wichtigsten Methoden, um Zwischenwerte und Typen von Programmausgaben zu überprüfen. Jetzt ist es an der Zeit, sich mit den häufigsten Formen von Bugs zu beschäftigen. Ein Problem auf der Ebene der Syntax, mit dem schnelle Tipper mitfühlen können, ist der einfache Rechtschreibfehler.
+
+Vertauschte, fehlende oder falsch großgeschriebene Zeichen in einem Variablen- oder Funktionsnamen führen dazu, dass der Browser nach einem Objekt sucht, das nicht existiert - und sich in Form eines Referenzfehlers beschwert. Bei JavaScript-Variablen- und Funktionsnamen wird zwischen Groß- und Kleinschreibung unterschieden.
+
+# --instructions--
+
+Korrigiere die beiden Rechtschreibfehler im Code, damit die Berechnung des `netWorkingCapital` funktioniert.
+
+# --hints--
+
+Überprüfe die Schreibweise der beiden Variablen, die in der Berechnung des NetWorkingCapitals verwendet werden. Die Konsolenausgabe sollte Folgendes anzeigen: " Net working capital is: 2".
+
+```js
+assert(netWorkingCapital === 2);
+```
+
+Es sollten keine falsch geschriebenen Variablen im Code vorkommen.
+
+```js
+assert(!code.match(/recievables/g));
+```
+
+Die Variable `receivables` sollte im Code richtig deklariert und verwendet werden.
+
+```js
+assert(code.match(/receivables/g).length == 2);
+```
+
+Es sollten keine falsch geschriebenen Variablen im Code vorkommen.
+
+```js
+assert(!code.match(/payable;/g));
+```
+
+Die Variable `payables` sollte im Code richtig deklariert und verwendet werden.
+
+```js
+assert(code.match(/payables/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = recievables - payable;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
+
+# --solutions--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = receivables - payables;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md
new file mode 100644
index 00000000000..937cc3d48c1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b84367417b2b2512b37
+title: Gemischte Verwendung von einfachen und doppelten Anführungszeichen abfangen
+challengeType: 1
+forumTopicId: 301188
+dashedName: catch-mixed-usage-of-single-and-double-quotes
+---
+
+# --description--
+
+JavaScript erlaubt die Verwendung von einfachen (`'`) und doppelten (`"`) Anführungszeichen zur Deklaration eines Strings. Die Entscheidung für eine der beiden Varianten ist in der Regel eine Frage der persönlichen Vorliebe, es gibt aber auch Ausnahmen.
+
+Zwei Möglichkeiten zu haben ist toll, wenn ein String Kontraktionen oder einen anderen Textteil enthält, der in Anführungszeichen steht. Achte nur darauf, dass du den String nicht zu früh schließt, denn das führt zu einem Syntaxfehler.
+
+Hier sind einige Beispiele für gemischte Anführungszeichen:
+
+```js
+const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
+const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
+const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
+```
+
+Die ersten Beiden sind richtig, aber das Dritte ist falsch.
+
+Natürlich ist es in Ordnung, nur eine Art von Anführungszeichen zu verwenden. Du kannst die Anführungszeichen innerhalb des Strings mit dem Escape-Zeichen Backslash (`\`) umgehen:
+
+```js
+const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
+```
+
+# --instructions--
+
+Korrigiere den String so, dass er entweder andere Anführungszeichen für den Wert `href` verwendet oder die vorhandenen escaped werden. Behalte die doppelten Anführungszeichen um den gesamten String herum bei.
+
+# --hints--
+
+Dein Code sollte die Anführungszeichen um den Wert `href` `#Home` korrigieren, indem du sie entweder änderst oder umgehst (escaping).
+
+```js
+assert(code.match(//g));
+```
+
+Dein Code sollte die doppelten Anführungszeichen um den gesamten String herum beibehalten.
+
+```js
+assert(code.match(/".*?<\/p>";/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let innerHtml = "
Click here to return home
";
+console.log(innerHtml);
+```
+
+# --solutions--
+
+```js
+let innerHtml = "Click here to return home
";
+console.log(innerHtml);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
new file mode 100644
index 00000000000..905e2dbbf77
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: Abfangen von Fehlern bei der Indizierung um eins
+challengeType: 1
+forumTopicId: 301189
+dashedName: catch-off-by-one-errors-when-using-indexing
+---
+
+# --description--
+
+Off-by-one-Fehler (manchmal auch OBOE genannt) treten auf, wenn du versuchst, einen bestimmten Index eines Strings oder Arrays anzusteuern (um ein Segment zu zerteilen oder darauf zuzugreifen), oder wenn du eine Schleife über die Indizes der Strings durchläufst. Die Indizierung in JavaScript beginnt bei Null, nicht bei Eins, was bedeutet, dass der letzte Index immer um Eins kleiner ist als die Länge des Elements. Wenn du versuchst, auf einen Index zuzugreifen, der gleich der Länge ist, kann das Programm einen Referenzfehler "index out of range" oder `undefined` ausgeben.
+
+Wenn du String- oder Array-Methoden verwendest, die Indexbereiche als Argumente annehmen, ist es hilfreich, die Dokumentation zu lesen und zu wissen, ob sie inklusiv sind (das Element am angegebenen Index ist Teil des Rückgabewerts) oder nicht. Hier sind einige Beispiele von Fehlern, die sich um eins unterscheiden:
+
+```js
+let alphabet = "abcdefghijklmnopqrstuvwxyz";
+let len = alphabet.length;
+for (let i = 0; i <= len; i++) {
+ console.log(alphabet[i]);
+}
+for (let j = 1; j < len; j++) {
+ console.log(alphabet[j]);
+}
+for (let k = 0; k < len; k++) {
+ console.log(alphabet[k]);
+}
+```
+
+Das erste Beispiel macht eine Schleife zu viel und das zweite eine Schleife zu wenig (es fehlt der erste Index, 0). Das dritte Beispiel ist korrekt.
+
+# --instructions--
+
+Behebe die beiden Indizierungsfehler in der folgenden Funktion, damit alle Zahlen 1 bis 5 auf der Konsole ausgegeben werden.
+
+# --hints--
+
+Dein Code sollte die Anfangsbedingung der Schleife so setzen, dass sie beim ersten Index beginnt.
+
+```js
+assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
+```
+
+Dein Code sollte die Anfangsbedingung der Schleife so festlegen, dass der Index bei 0 beginnt.
+
+```js
+assert(!code.match(/i\s?=\s*?1\s*?;/g));
+```
+
+Dein Code sollte die Endbedingung der Schleife so setzen, dass sie beim letzten Index anhält.
+
+```js
+assert(code.match(/i\s*<\s*len\s*;|i\s*<=\s*len\s*-\s*1\s*;/g).length == 1);
+```
+
+Dein Code sollte die Endbedingung der Schleife so festlegen, dass sie bei 1 vor der Länge aufhört.
+
+```js
+assert(!code.match(/i\s*?<=\s*?len;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 1; i <= len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
+
+# --solutions--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 0; i < len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
new file mode 100644
index 00000000000..40d073766d7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
@@ -0,0 +1,49 @@
+---
+id: 587d7b84367417b2b2512b36
+title: 'Nicht geschlossene Klammern, geschweifte Klammern und Anführungszeichen abfangen'
+challengeType: 1
+forumTopicId: 301190
+dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
+---
+
+# --description--
+
+Ein weiterer Syntaxfehler, auf den du achten solltest, ist, dass alle öffnenden Klammern, geschweifte Klammern und Anführungszeichen ein schließendes Paar besitzen. Das Vergessen eines Teils passiert oft, wenn du bestehenden Code bearbeitest und Elemente mit einem der Paartypen einfügst. Sei außerdem vorsichtig, wenn du Codeblöcke in andere verschachtelst, z. B. wenn du eine Rückruffunktion (Callback-Funktion) als Argument zu einer Methode hinzufügst.
+
+Eine Möglichkeit, diesen Fehler zu vermeiden, besteht darin, dass du, sobald du das erste Zeichen getippt hast, sofort das letzte Zeichen einfügst, dann den Cursor wieder dazwischen setzt und mit der Programmierung fortfährst. Zum Glück erzeugen die meisten modernen Code-Editoren die zweite Hälfte des Paares automatisch.
+
+# --instructions--
+
+Behebe die beiden Paarfehler im Code.
+
+# --hints--
+
+Dein Code sollte das fehlende Stück des Arrays reparieren.
+
+```js
+assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
+```
+
+Dein Code sollte den fehlenden Teil der Methode `.reduce()` beheben. Die Konsolenausgabe sollte Folgendes anzeigen: `Sum of array values is: 6`.
+
+```js
+assert(arraySum === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+# --solutions--
+
+```js
+let myArray = [1, 2, 3];
+let arraySum = myArray.reduce((previous, current) => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
new file mode 100644
index 00000000000..3b828b01ced
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
@@ -0,0 +1,81 @@
+---
+id: 587d7b85367417b2b2512b38
+title: Verwendung des Zuweisungsoperators anstelle des Gleichheitsoperators abfangen
+challengeType: 1
+forumTopicId: 301191
+dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
+---
+
+# --description--
+
+Verzweigende Programme, d.h. solche, die verschiedene Dinge tun, wenn bestimmte Bedingungen erfüllt sind, basieren auf `if`, `else if` und `else` Anweisungen in JavaScript. Die Bedingung hat manchmal die Form einer Prüfung, ob ein Ergebnis gleich einem Wert ist.
+
+Diese Logik kann (zumindest im Englischen und Deutschen) als "wenn x gleich y ist, dann ..." ausgedrückt werden, was buchstäblich mit dem `=` oder Zuweisungsoperator in Code übersetzt werden kann. Das führt zu einem unerwarteten Kontrollfluss in deinem Programm.
+
+Wie in den vorherigen Aufgaben behandelt, ordnet der Zuweisungsoperator (`=`) in JavaScript einem Variablennamen einen Wert zu. Und die Operatoren `==` und `===` prüfen auf Gleichheit (das Tripel `===` prüft auf strikte Gleichheit, d. h. Wert und Typ sind gleich).
+
+Der folgende Code weist `x` den Wert 2 zu, was als `true` ausgewertet wird. Fast jeder Wert in JavaScript wird als `true` ausgewertet, außer den sogenannten "falsy" Werten: `false`, `0`, `""` (ein leerer String), `NaN`, `undefined` und `null`.
+
+```js
+let x = 1;
+let y = 2;
+if (x = y) {
+
+} else {
+
+}
+```
+
+In diesem Beispiel wird der Codeblock innerhalb der `if`-Anweisung für jeden beliebigen Wert von `y` ausgeführt, es sei denn, `y` ist falsy. Der `else`-Block, von dem wir erwarten, dass er hier ausgeführt wird, wird nicht wirklich ausgeführt.
+
+# --instructions--
+
+Korrigiere die Bedingung, damit das Programm die richtige Verzweigung ausführt und `result` der richtige Wert zugewiesen wird.
+
+# --hints--
+
+Dein Code sollte die Bedingung so ändern, dass er auf Gleichheit prüft, anstatt eine Zuweisung zu verwenden.
+
+```js
+assert(result == 'Not equal!');
+```
+
+Die Bedingung sollte entweder `==` oder `===` verwenden, um auf Gleichheit zu testen.
+
+```js
+assert(code.match(/x\s*?===?\s*?y/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
+
+# --solutions--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x === y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
new file mode 100644
index 00000000000..5920717e4b7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: Verhindere Endlosschleifen mit einer gültigen Abschlussbedingung
+challengeType: 1
+forumTopicId: 301192
+dashedName: prevent-infinite-loops-with-a-valid-terminal-condition
+---
+
+# --description--
+
+Das letzte Thema ist die gefürchtete Endlosschleife. Schleifen sind großartige Werkzeuge, wenn dein Programm einen Codeblock eine bestimmte Anzahl von Malen ausführen soll oder bis eine Bedingung erfüllt ist, aber sie brauchen eine Abschlussbedingung, die die Schleife beendet. Endlosschleifen können dazu führen, dass der Browser einfriert oder abstürzt und die Programmausführung allgemein beeinträchtigt wird, was niemand will.
+
+In der Einleitung zu diesem Abschnitt gab es ein Beispiel für eine Endlosschleife - sie hatte keine Abschlussbedingung, um aus der `while`-Schleife innerhalb von `loopy()` heraus zu kommen. Rufe diese Funktion NICHT auf!
+
+```js
+function loopy() {
+ while(true) {
+ console.log("Hello, world!");
+ }
+}
+```
+
+Es ist die Aufgabe des Programmierers, dafür zu sorgen, dass die Abschlussbedingung, die dem Programm sagt, wann es aus dem Schleifencode herauskommen soll, schließlich erreicht wird. Ein Fehler ist das Inkrementieren (Erhöhen) oder Dekrementieren (Verringern) einer Zählervariablen in der falschen Richtung vom Endzustand aus. Eine andere Möglichkeit ist das versehentliche Zurücksetzen eines Zählers oder einer Indexvariablen innerhalb des Schleifencodes, anstatt sie zu inkrementieren oder zu dekrementieren.
+
+# --instructions--
+
+Die Funktion `myFunc()` enthält eine Endlosschleife, weil die Abschlussbedingung `i != 4` niemals `false` ergibt (und die Schleife unterbricht) - `i` wird bei jedem Durchlauf um 2 erhöht und springt direkt über 4, da `i` zu Beginn ungerade ist. Korrigiere den Vergleichsoperator in der Abschlussbedingung, damit die Schleife nur für `i` kleiner oder gleich 4 läuft.
+
+# --hints--
+
+Dein Code sollte den Vergleichsoperator in der Abschlussbedingung (dem mittleren Teil) der `for`-Schleife ändern.
+
+```js
+assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
+```
+
+Dein Code sollte den Vergleichsoperator in der Abschlussbedingung der Schleife korrigieren.
+
+```js
+assert(!code.match(/i\s*?!=\s*?4;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myFunc() {
+ for (let i = 1; i != 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
+
+# --solutions--
+
+```js
+function myFunc() {
+ for (let i = 1; i <= 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
new file mode 100644
index 00000000000..11d4c2a14da
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
@@ -0,0 +1,65 @@
+---
+id: 587d7b83367417b2b2512b37
+title: Die Unterschiede zwischen der freeCodeCamp- und der Browser-Konsole verstehen
+challengeType: 1
+forumTopicId: 301193
+dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
+---
+
+# --description--
+
+Du hast vielleicht bemerkt, dass einige Aufgaben im freeCodeCamp eine eigene Konsole enthalten. Diese Konsole verhält sich ein wenig anders als die Browser-Konsole.
+
+Es gibt viele Methoden, um mit `console` Nachrichten auszugeben. `log`, `warn`, und `clear`, um nur einige zu nennen. Die freeCodeCamp-Konsole gibt nur `log`-Meldungen aus, während die Browser-Konsole alle Meldungen ausgibt. Wenn du Änderungen an deinem Code vornimmst, wird er automatisch ausgeführt und die Protokolle werden angezeigt. Die freeCodeCamp-Konsole wird dann jedes Mal geleert, wenn dein Code ausgeführt wird.
+
+# --instructions--
+
+Öffne zunächst deine Browserkonsole, damit du die Logs sehen kannst. Um das zu tun, kannst du in den meisten Browsern mit der rechten Maustaste auf die freeCodeCamp-Navigationsleiste oben klicken und `inspect` (Untersuchen) anklicken. Dann suche in dem Fenster, das sich öffnet, den Reiter `console` (Konsole).
+
+Verwende danach `console.log`, um die Variable `output` zu protokollieren. Sieh dir die beiden Konsolen an, um das Protokoll zu sehen. Verwende schließlich `console.clear` nach deinem Log, um die Browserkonsole zu löschen. Sieh dir den Unterschied zwischen den beiden Konsolen an.
+
+# --hints--
+
+Du solltest `console.log()` verwenden, um die Variable `output` auszugeben.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));
+```
+
+Du solltest `console.clear()` verwenden, um die Browserkonsole zu löschen.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/console.clear\(\)/)
+);
+```
+
+Du solltest die Konsole nach deinem Log löschen.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/console\.log\(output\)[\s\S]*console.clear\(\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+```
+
+# --solutions--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+console.log(output);
+console.clear();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
new file mode 100644
index 00000000000..fe7ea5c0457
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: Sei vorsichtig, wenn du Variablen innerhalb einer Schleife reinitialisierst
+challengeType: 1
+forumTopicId: 301194
+dashedName: use-caution-when-reinitializing-variables-inside-a-loop
+---
+
+# --description--
+
+Manchmal ist es notwendig, innerhalb einer Schleife Informationen zu speichern, Zähler zu erhöhen oder Variablen neu zu setzen. Ein mögliches Problem ist, wenn Variablen reinitialisiert werden sollten, es aber nicht geschehen ist, oder andersherum. Das ist besonders gefährlich, wenn du die Variable, die für die Endbedingung verwendet wird, versehentlich zurücksetzt und damit eine Endlosschleife auslöst.
+
+Wenn du die Variablenwerte bei jedem Zyklus deiner Schleife mit `console.log()` ausdruckst, kannst du ein fehlerhaftes Verhalten aufdecken, das mit dem Zurücksetzen oder dem Nichtzurücksetzen einer Variablen zusammenhängt.
+
+# --instructions--
+
+Die folgende Funktion soll ein zweidimensionales Array mit `m` Zeilen und `n` Spalten aus Nullen erstellen. Leider bringt es nicht die erwartete Ausgabe, weil die Variable `row` in der äußeren Schleife nicht neu initialisiert (auf ein leeres Array zurückgesetzt) wird. Korrigiere den Code so, dass er ein korrektes 3x2-Array mit Nullen zurückgibt, das wie folgt aussieht: `[[0, 0], [0, 0], [0, 0]]`.
+
+# --hints--
+
+Dein Code sollte die Variable `matrix` auf ein Array setzen, das aus 3 Zeilen und 2 Spalten besteht, die jeweils Nullen enthalten.
+
+```js
+assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
+```
+
+Die Variable `matrix` sollte 3 Zeilen enthalten.
+
+```js
+assert(matrix.length == 3);
+```
+
+Die Variable `matrix` sollte 2 Spalten in jeder Zeile besitzen.
+
+```js
+assert(
+ matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2
+);
+```
+
+`zeroArray(4,3)` sollte ein Array mit 4 Zeilen und 3 Spalten bestehend aus Nullen zurückgeben.
+
+```js
+assert(JSON.stringify(zeroArray(4,3)) == '[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ let row = [];
+ for (let i = 0; i < m; i++) {
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```
+
+# --solutions--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ for (let i = 0; i < m; i++) {
+ let row = [];
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
new file mode 100644
index 00000000000..593a15904f0
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
@@ -0,0 +1,54 @@
+---
+id: 587d7b83367417b2b2512b33
+title: Verwende die JavaScript-Konsole, um den Wert einer Variable zu überprüfen
+challengeType: 1
+forumTopicId: 18372
+dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
+---
+
+# --description--
+
+Sowohl Chrome als auch Firefox haben hervorragende JavaScript-Konsolen, auch DevTools genannt, um dein JavaScript zu debuggen.
+
+Du findest die Entwicklertools im Menü von Chrome oder die Webkonsole im Menü von Firefox. Wenn du einen anderen Browser oder ein Mobiltelefon verwendest, empfehlen wir dir dringend, auf den Desktop-Browser Firefox oder Chrome umzusteigen.
+
+Die Methode `console.log()`, die die Ausgabe dessen, was in den Klammern steht, auf der Konsole ausgibt, ist wahrscheinlich das hilfreichste Debugging-Tool. Wenn du sie an strategischen Punkten in deinem Code platzierst, kannst du dir die Zwischenwerte von Variablen anzeigen lassen. Es ist gut, eine Vorstellung davon zu haben, wie die Ausgabe aussehen soll, bevor du dir ansiehst, was sie ist. Kontrollpunkte, an denen du den Status deiner Berechnungen in deinem Code überprüfen kannst, helfen dabei, das Problem einzugrenzen.
+
+Hier ist ein Beispiel, mit dem du den String `Hello world!` auf der Konsole ausgibst:
+
+```js
+console.log('Hello world!');
+```
+
+# --instructions--
+
+Verwende die Methode `console.log()`, um den Wert der Variable `a` an den Stellen im Code auszugeben.
+
+# --hints--
+
+Dein Code sollte `console.log()` verwenden, um den Wert der Variable `a` zu überprüfen.
+
+```js
+assert(code.match(/console\.log\(a\)/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Only change code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+# --solutions--
+
+```js
+var a = 5; console.log(a);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
new file mode 100644
index 00000000000..943611ac160
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
@@ -0,0 +1,66 @@
+---
+id: 587d7b84367417b2b2512b34
+title: Verwende typeof, um den Typ einer Variable zu prüfen
+challengeType: 1
+forumTopicId: 18374
+dashedName: use-typeof-to-check-the-type-of-a-variable
+---
+
+# --description--
+
+Du kannst `typeof` verwenden, um die Datenstruktur oder den Typ einer Variablen zu überprüfen. Dies ist bei der Fehlersuche nützlich, wenn du mit mehreren Datentypen arbeitest. Wenn du denkst, dass du zwei Zahlen addierst, aber eine davon in Wirklichkeit ein String ist, kann das Ergebnis unerwartet sein. Typfehler können sich in Berechnungen oder Funktionsaufrufen verstecken. Sei besonders vorsichtig, wenn du auf externe Daten in Form eines JSON-Objekts (JavaScript Object Notation) zugreifst und mit ihnen arbeitest.
+
+Hier sind einige Beispiele mit `typeof`:
+
+```js
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
+```
+
+In der Reihenfolge zeigt die Konsole die Strings `string`, `number`, `object`, und `object` an.
+
+JavaScript kennt sieben primitive (unveränderliche) Datentypen: `Boolean`, `Null`, `Undefined`, `Number`, `String`, `Symbol` (neu mit ES6) und `BigInt` (neu mit ES2020), und einen Typ für veränderbare Elemente: `Object`. Beachte, dass Arrays in JavaScript technisch gesehen eine Art von Objekt sind.
+
+# --instructions--
+
+Füge zwei `console.log()` Anweisungen hinzu, um den Typ (`typeof`) jeder der beiden Variablen `seven` und `three` im Code zu überprüfen.
+
+# --hints--
+
+Dein Code sollte `typeof` in zwei `console.log()` Anweisungen verwenden, um den Typ der Variablen zu überprüfen.
+
+```js
+assert(code.match(/console\.log\s*\(typeof[\( ].*\)?\)/g).length == 2);
+```
+
+Dein Code sollte `typeof` verwenden, um den Typ der Variablen `seven` zu überprüfen.
+
+```js
+assert(code.match(/typeof[\( ]seven\)?/g));
+```
+
+Dein Code sollte `typeof` verwenden, um den Typ der Variablen `three` zu überprüfen.
+
+```js
+assert(code.match(/typeof[\( ]three\)?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
new file mode 100644
index 00000000000..3ad528ecaa1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
@@ -0,0 +1,134 @@
+---
+id: 587d7b87367417b2b2512b40
+title: Vergleich der Geltungsbereiche der Schlüsselwörter var und let
+challengeType: 1
+forumTopicId: 301195
+dashedName: compare-scopes-of-the-var-and-let-keywords
+---
+
+# --description--
+
+Wenn du mit `let` nicht vertraut bist, schau dir diese Aufgabe über den Unterschied von let und var an .
+
+Wenn du eine Variable mit dem Schlüsselwort `var` deklarierst, wird sie global deklariert oder lokal, wenn sie innerhalb einer Funktion deklariert wird.
+
+Das Schlüsselwort `let` verhält sich ähnlich, aber mit einigen zusätzlichen Funktionen. Wenn du eine Variable mit dem Schlüsselwort `let` innerhalb eines Blocks, einer Anweisung oder eines Ausdrucks deklarierst, ist ihr Geltungsbereich auf diesen Block, diese Anwendung oder diesen Ausdruck beschränkt.
+
+Zum Beispiel:
+
+```js
+var numArray = [];
+for (var i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+Hier wird die Konsole die Werte `[0, 1, 2]` und `3` anzeigen.
+
+Durch das Schlüsselwort `var` ist `i` global deklariert. Wenn also `i++` ausgeführt wird, aktualisiert das die globale Variable. Dieser Code ist ähnlich wie der Nachfolgende:
+
+```js
+var numArray = [];
+var i;
+for (i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+Hier wird die Konsole die Werte `[0, 1, 2]` und `3` anzeigen.
+
+Dieses Verhalten wird Probleme verursachen, wenn du eine Funktion erstellst und sie zur späteren Verwendung innerhalb einer `for`-Schleife speicherst, die die Variable `i` verwendet. Das liegt daran, dass sich die gespeicherte Funktion immer auf den Wert der aktualisierten globalen Variable `i` bezieht.
+
+```js
+var printNumTwo;
+for (var i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+```
+
+Hier wird in der Konsole der Wert `3` angezeigt.
+
+Wie du sehen kannst, gibt `printNumTwo()` 3 und nicht 2 aus. Das liegt daran, dass der Wert `i` zugewiesen wurde, aktualisiert wurde und `printNumTwo()` das globale `i` zurückgibt und nicht den Wert, den `i` hatte, als die Funktion in der for-Schleife erstellt wurde. Das Schlüsselwort `let` verhält sich nicht so:
+
+```js
+let printNumTwo;
+for (let i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+console.log(i);
+```
+
+Hier zeigt die Konsole den Wert `2` an und die Fehlermeldung `i is not defined`.
+
+`i` ist nicht definiert, weil es nicht im globalen Geltungsbereich deklariert wurde. Sie wird nur innerhalb der `for`-Schleifenanweisung deklariert. `printNumTwo()` gab den richtigen Wert zurück, weil drei verschiedene `i`-Variablen mit eindeutigen Werten (0, 1 und 2) durch das Schlüsselwort `let` innerhalb der Schleifenanweisung erstellt wurden.
+
+# --instructions--
+
+Ändere den Code so, dass `i`, das in der `if`-Anweisung deklariert wird, eine andere Variable ist als `i`, das in der ersten Zeile der Funktion deklariert wird. Achte darauf, dass du das Schlüsselwort `var` nirgendwo in deinem Code verwendest.
+
+Diese Übung soll den Unterschied zwischen den Schlüsselwörtern `var` und `let` verdeutlichen, die der deklarierten Variable den Geltungsbereich zuweisen. Wenn du eine Funktion programmierst, die der in dieser Übung verwendeten ähnelt, ist es oft besser, verschiedene Variablennamen zu verwenden, um Verwechslungen zu vermeiden.
+
+# --hints--
+
+`var` sollte nicht im Code vorhanden sein.
+
+```js
+assert(!code.match(/var/g));
+```
+
+Die Variable `i`, die in der `if`-Anweisung deklariert wird, sollte gleich dem String `block scope` sein.
+
+```js
+assert(code.match(/(i\s*=\s*).*\s*.*\s*.*\1('|")block\s*scope\2/g));
+```
+
+`checkScope()` sollte den String `function scope` zurückgeben.
+
+```js
+assert(checkScope() === 'function scope');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkScope() {
+ var i = 'function scope';
+ if (true) {
+ i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
+
+# --solutions--
+
+```js
+function checkScope() {
+ let i = 'function scope';
+ if (true) {
+ let i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
new file mode 100644
index 00000000000..539e5e44181
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
@@ -0,0 +1,77 @@
+---
+id: 5cdafbc32913098997531680
+title: Vervollständige ein Promise mit resolve und reject
+challengeType: 1
+forumTopicId: 301196
+dashedName: complete-a-promise-with-resolve-and-reject
+---
+
+# --description--
+
+Ein Promise hat drei Zustände: `pending`, `fulfilled` und `rejected`. Das Promise, das du in der letzten Aufgabe erstellt hast, bleibt für immer im Zustand `pending` stecken, weil du keine Möglichkeit hinzugefügt hast, das Promise zu beenden. Dazu werden die Parameter `resolve` und `reject` verwendet, die dem Promise-Argument übergeben werden. `resolve` wird verwendet, wenn du willst, dass dein Promise erfolgreich ist, und `reject` wird verwendet, wenn es fehlschlagen soll. Das sind Methoden, die ein Argument benötigen, wie unten zu sehen.
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+ if(condition here) {
+ resolve("Promise was fulfilled");
+ } else {
+ reject("Promise was rejected");
+ }
+});
+```
+
+Das obige Beispiel verwendet Strings als Argument für diese Funktionen, aber es kann wirklich alles sein. Oft handelt es sich dabei um ein Objekt, dessen Daten du auf deiner Website oder an anderer Stelle verwendest.
+
+# --instructions--
+
+Sorge dafür, dass das Promise mit Erfolg und Misserfolg umgeht. Wenn `responseFromServer` wahr (`true`) ist, rufe die Methode `resolve` auf, um das Promise erfolgreich abzuschließen. Übergib `resolve` einen String mit dem Wert `We got the data`. Wenn `responseFromServer` falsch (`false`) ist, verwende stattdessen die Methode `reject` und übergebe ihr den String: `Data not received`.
+
+# --hints--
+
+`resolve` sollte mit dem erwarteten String aufgerufen werden, wenn die `if`-Bedingung `true` ist.
+
+```js
+assert(
+ code.match(/if\s*\(\s*responseFromServer\s*\)\s*{\s*resolve\s*\(\s*('|"|`)We got the data\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+`reject` sollte mit dem erwarteten String aufgerufen werden, wenn die `if`-Bedingung `false` ist.
+
+```js
+assert(
+ code.match(/}\s*else\s*{\s*reject\s*\(\s*('|"|`)Data not received\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ // Change this line
+ } else {
+ // Change this line
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
new file mode 100644
index 00000000000..7ac8b9409ce
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
@@ -0,0 +1,55 @@
+---
+id: 5cdafbb0291309899753167f
+title: Erstelle eine JavaScript Promise
+challengeType: 1
+forumTopicId: 301197
+dashedName: create-a-javascript-promise
+---
+
+# --description--
+
+Ein Promise (engl. Versprechen) in JavaScript entspricht genau dem, was es aussagt - du verwendest es um ein Versprechen zu machen - in der Regel etwas asynchron - zu tun. Wenn die Aufgabe abgeschlossen ist, erfüllst du entweder das Versprechen oder du versagst dabei. `Promise` ist eine Konstruktorfunktion, deshalb braucht es das `new` Schlüsselwort um eines zu erstellen. Es benötigt eine Funktion, sowie ein Argument mit zwei Parametern - `resolve` und `reject`. Das sind die Mehtoden, die genutzt werden um das Ergebnis des Promise zu bestimmen. Die Syntax sieht folgendermaßen aus:
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+
+});
+```
+
+# --instructions--
+
+Erstelle ein neues Promise namens `makeServerRequest`. Übergebe eine Funktion mit den Parametern `resolve` und `reject` an den Konstruktor.
+
+# --hints--
+
+Du solltest ein Promise einer deklarierten Variable namens `makeServerRequest` zuweisen.
+
+```js
+assert(makeServerRequest instanceof Promise);
+```
+
+Dein Promise sollte eine Funktion mit `resolve` und `reject` als Parameter erhalten.
+
+```js
+assert(
+ code.match(
+ /Promise\s*\(\s*(function\s*\(\s*resolve\s*,\s*reject\s*\)\s*{|\(\s*resolve\s*,\s*reject\s*\)\s*=>\s*{)[^}]*}/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
new file mode 100644
index 00000000000..ff5e2c5cc66
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
@@ -0,0 +1,73 @@
+---
+id: 5cddbfd622f1a59093ec611d
+title: Erstelle ein Modul-Skript
+challengeType: 6
+forumTopicId: 301198
+dashedName: create-a-module-script
+---
+
+# --description--
+
+JavaScript spielte zunächst eine kleine Rolle im ansonsten auf HTML basierenden Web. Heute ist es riesig, und einige Websites werden fast ausschließlich mit JavaScript erstellt. Um JavaScript modularer, sauberer und wartungsfähiger zu machen; hat ES6 einen Weg eingeführt, Code leicht unter JavaScript-Dateien zu teilen. Dabei werden Teile einer Datei exportiert, um sie in einer oder mehreren anderen Dateien zu verwenden, und die Teile, die du brauchst, werden importiert, wo du sie brauchst. Um diese Funktion nutzen zu können, musst du in deinem HTML-Dokument ein Skript mit dem Typ (`type`) Modul (`module`) erstellen. Hier ist ein Beispiel:
+
+```html
+
+```
+
+Ein Skript, das den Typ Modul (`module`)verwendet, kann jetzt die Funktionen `import` und `export` nutzen, die du in den kommenden Aufgaben kennenlernen wirst.
+
+# --instructions--
+
+Füge dem HTML-Dokument ein Skript vom Typ Modul (`module`) hinzu und gib ihm die Quelldatei `index.js`
+
+# --hints--
+
+Du solltest ein `script`-Tag erstellen.
+
+```js
+assert(code.match(/<\s*script[^>]*>\s*<\/\s*script\s*>/g));
+```
+
+Dein `script`-Tag sollte das Attribut `type` mit dem Wert `module` besitzen.
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^t]*type\s*=\s*('|")module\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+Dein `script`-Tag sollte die Quelle (`src`) von `index.js` haben.
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^s]*src\s*=\s*('|")index\.js\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
+
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
new file mode 100644
index 00000000000..df6eccdbea7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b8c367417b2b2512b58
+title: Erstelle einen Export-Fallback mit export default
+challengeType: 1
+forumTopicId: 301199
+dashedName: create-an-export-fallback-with-export-default
+---
+
+# --description--
+
+In der `export` Lektion hast du die Syntax des benannten Exports kennengelernt. Dadurch konntest du mehrere Funktionen und Variablen für die Verwendung in anderen Dateien zur Verfügung stellen.
+
+Es gibt noch eine weitere `export`-Syntax, die du kennen musst: export default (Standard-Export). Normalerweise verwendest du diese Syntax, wenn nur ein Wert aus einer Datei exportiert wird. Es wird auch verwendet, um einen Fallback-Wert für eine Datei oder ein Modul zu erstellen.
+
+Im Folgenden findest du Beispiele mit `export default`:
+
+```js
+export default function add(x, y) {
+ return x + y;
+}
+
+export default function(x, y) {
+ return x + y;
+}
+```
+
+Die erste ist eine benannte Funktion, die zweite eine anonyme Funktion.
+
+Da `export default` verwendet wird, um einen Fallback-Wert für ein Modul oder eine Datei zu deklarieren, kannst du nur einen Wert als Standard-Export in jedem Modul oder jeder Datei haben. Außerdem kannst du `export default` nicht mit `var`, `let` oder `const` verwenden
+
+# --instructions--
+
+Die folgende Funktion sollte der Fallbackwert für das Modul sein. Bitte füge den dafür notwendigen Code hinzu.
+
+# --hints--
+
+Dein Code sollte einen `export` Fallback verwenden.
+
+```js
+assert(
+ code.match(
+ /export\s+default\s+function(\s+subtract\s*|\s*)\(\s*x,\s*y\s*\)\s*{/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function subtract(x, y) {
+ return x - y;
+}
+```
+
+# --solutions--
+
+```js
+export default function subtract(x, y) {
+ return x - y;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
new file mode 100644
index 00000000000..8a6745bb3c5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
@@ -0,0 +1,116 @@
+---
+id: 587d7b8a367417b2b2512b4e
+title: Strings mit Template-Literalen erstellen
+challengeType: 1
+forumTopicId: 301200
+dashedName: create-strings-using-template-literals
+---
+
+# --description--
+
+Eine neue Funktion von ES6 ist das Template-Literal . Dies ist eine besondere Art von String, die das Erstellen komplexer Strings erleichtert.
+
+Mit Template-Literalen kannst du mehrzeilige Strings erstellen und String-Interpolationsfunktionen verwenden, um Strings zu erstellen.
+
+Schau dir den folgenden Code an:
+
+```js
+const person = {
+ name: "Zodiac Hasbro",
+ age: 56
+};
+
+const greeting = `Hello, my name is ${person.name}!
+I am ${person.age} years old.`;
+
+console.log(greeting);
+```
+
+Die Konsole zeigt die Strings `Hello, my name is Zodiac Hasbro!` und `I am 56 years old.` an.
+
+Dort sind eine Menge Dinge passiert. Erstens verwendet das Beispiel Backticks (`` ` ``) und keine Anführungszeichen (`'` oder `"`), um den String einzuschließen. Zweitens: Beachte, dass der String mehrzeilig ist, sowohl im Code als auch in der Ausgabe. Das erspart das Einfügen von `\n` innerhalb von Strings. Die oben verwendete Syntax `${variable}` ist ein Platzhalter. Im Grunde musst du die Verkettung mit dem Operator `+` nicht mehr verwenden. Um Variablen zu Strings hinzuzufügen, fügst du die Variable einfach in einen Template-String ein und umschließt sie mit `${` und `}`. Du kannst auch andere Ausdrücke in dein Stringliteral einfügen, zum Beispiel `${a + b}`. Diese neue Art, Strings zu erstellen, gibt dir mehr Flexibilität, um robuste Strings zu erstellen.
+
+# --instructions--
+
+Verwende die Template-Literal-Syntax mit Backticks, um ein Array aus Listenelementen (`li`) zu erstellen. Der Text jedes Listenelements sollte eines der Array-Elemente aus der `failure`-Eigenschaft des Objekts `result` sein und ein `class`-Attribut mit dem Wert `text-warning` haben. Die Funktion `makeList` sollte das Array mit den Strings der Listenelemente zurückgeben.
+
+Verwende eine Iterationsmethode (jede Art von Schleife), um die gewünschte Ausgabe zu erhalten (siehe unten).
+
+```js
+[
+ 'no-var ',
+ 'var-on-top ',
+ 'linebreak '
+]
+```
+
+# --hints--
+
+`failuresList` sollte ein Array sein, das `result failure` Meldungen enthält.
+
+```js
+assert(
+ typeof makeList(result.failure) === 'object' && failuresList.length === 3
+);
+```
+
+`failuresList` sollte gleich der angegebenen Ausgabe sein.
+
+```js
+assert(
+ makeList(result.failure).every(
+ (v, i) =>
+ v === `${result.failure[i]} ` ||
+ v === `${result.failure[i]} `
+ )
+);
+```
+
+Es sollten Template-Strings und die Interpolation von Ausdrücken verwendet werden.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(`.*\${.*}.*`)/));
+```
+
+Es sollte ein Iterator verwendet werden.
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/for|map|reduce|forEach|while/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ // Only change code below this line
+ const failureItems = [];
+ // Only change code above this line
+
+ return failureItems;
+}
+
+const failuresList = makeList(result.failure);
+```
+
+# --solutions--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ return arr.map(val => `${val} `);
+}
+
+const failuresList = makeList(result.failure);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
new file mode 100644
index 00000000000..9a94b69687e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
@@ -0,0 +1,92 @@
+---
+id: 5cdafbd72913098997531681
+title: Ein erfülltes Promise mit then bearbeiten
+challengeType: 1
+forumTopicId: 301203
+dashedName: handle-a-fulfilled-promise-with-then
+---
+
+# --description--
+
+Promises sind besonders nützlich, wenn du einen Prozess in deinem Code hast, der eine unbekannte Zeitspanne in Anspruch nimmt (d.h. etwas asynchrones), oft eine Serveranfrage. Wenn du eine Serveranfrage stellst, dauert es eine gewisse Zeit, und nachdem sie abgeschlossen ist, willst du normalerweise etwas mit der Antwort des Servers machen. Das kannst du mit der Methode `then` erreichen. Die Methode `then` wird sofort ausgeführt, nachdem dein Promise mit `resolve` erfüllt wurde. Hier ist ein Beispiel:
+
+```js
+myPromise.then(result => {
+
+});
+```
+
+`result` ergibt sich aus dem Argument, das der Methode `resolve` übergeben wird.
+
+# --instructions--
+
+Füge die Methode `then` zu deinem Promise hinzu. Verwende `result` als Parameter der Callback-Funktion und logge `result` auf der Konsole.
+
+# --hints--
+
+Du solltest die Methode `then` für das Versprechen aufrufen.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.then\(/g)
+);
+```
+
+Deine Methode `then` sollte eine Callback-Funktion mit `result` als Parameter besitzen.
+
+```js
+assert(resultIsParameter);
+```
+
+Du solltest `result` auf der Konsole loggen.
+
+```js
+assert(
+ resultIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.then\(.*?result.*?console.log\(result\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const resultIsParameter = /\.then\((function\(result\){|result|\(result\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
new file mode 100644
index 00000000000..e292c513643
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
@@ -0,0 +1,100 @@
+---
+id: 5cdafbe72913098997531682
+title: Abgelehntes Promise mit catch behandeln
+challengeType: 1
+forumTopicId: 301204
+dashedName: handle-a-rejected-promise-with-catch
+---
+
+# --description--
+
+`catch` ist die Methode, die verwendet wird, wenn dein Promise abgelehnt wurde. Sie wird sofort nach dem Aufruf der Methode `reject` eines Promise ausgeführt. Hier ist die Syntax:
+
+```js
+myPromise.catch(error => {
+
+});
+```
+
+`error` ist das Argument, das an die Methode `reject` übergeben wird.
+
+# --instructions--
+
+Füge die Methode `catch` zu deinem Promise hinzu. Verwende `error` als Parameter der Callback-Funktion und logge `error` auf der Konsole.
+
+# --hints--
+
+Du solltest die Methode `catch` für das Promise aufrufen.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.catch\(/g)
+);
+```
+
+Deine Methode `catch` sollte eine Callback-Funktion mit `error` als Parameter haben.
+
+```js
+assert(errorIsParameter);
+```
+
+Du solltest `error` auf der Konsole loggen.
+
+```js
+assert(
+ errorIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.catch\(.*?error.*?console.log\(error\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const errorIsParameter = /\.catch\((function\(error\){|error|\(error\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+
+makeServerRequest.catch(error => {
+ console.log(error);
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
new file mode 100644
index 00000000000..c89821c5116
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
@@ -0,0 +1,48 @@
+---
+id: 587d7b8d367417b2b2512b59
+title: Einen Standard-Export importieren
+challengeType: 1
+forumTopicId: 301205
+dashedName: import-a-default-export
+---
+
+# --description--
+
+In der letzten Aufgabe hast du etwas über `export default` und seine Verwendung gelernt. Um einen Standard-Export zu importieren, musst du eine andere `import`-Syntax verwenden. Im folgenden Beispiel ist `add` der Standard-Export der Datei `math_functions.js`. Hier erfährst du, wie du ihn importieren kannst:
+
+```js
+import add from "./math_functions.js";
+```
+
+Die Syntax unterscheidet sich an einer wichtigen Stelle. Der importierte Wert, `add`, ist nicht von geschweiften Klammern (`{}`) umgeben. `add` ist hier einfach ein Variablenname für den Standard-Export der Datei `math_functions.js`. Du kannst jeden Namen verwenden, wenn du etwas importierst, das als Standard exportiert wurde.
+
+# --instructions--
+
+Im folgenden Code importierst du den Standard-Export aus der Datei `math_functions.js`, die sich im selben Verzeichnis wie diese Datei befindet. Gib dem Import den Namen `subtract`.
+
+# --hints--
+
+Du solltest `subtract` aus `math_functions.js` korrekt importieren.
+
+```js
+assert(code.match(/import\s+subtract\s+from\s+('|")\.\/math_functions\.js\1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+subtract(7,4);
+```
+
+# --solutions--
+
+```js
+import subtract from "./math_functions.js";
+
+subtract(7,4);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
new file mode 100644
index 00000000000..2b1307c23ec
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b42
+title: Ein mit const deklariertes Array modifizieren
+challengeType: 1
+forumTopicId: 301206
+dashedName: mutate-an-array-declared-with-const
+---
+
+# --description--
+
+Wenn du mit `const` nicht vertraut bist, schau dir diese Aufgabe über das const-Schlüsselwort an.
+
+Die `const`-Deklaration hat viele Anwendungsfälle in modernem JavaScript.
+
+Manche Entwickler ziehen es vor, alle ihre Variablen standardmäßig mit `const` zuzuweisen, es sei denn, sie wissen, dass sie den Wert neu zuweisen müssen. Nur in diesem Fall verwenden sie `let`.
+
+Es ist jedoch wichtig zu verstehen, dass Objekte (einschließlich Arrays und Funktionen), die einer Variablen mit `const` zugewiesen werden, weiterhin veränderbar sind. Die Verwendung der `const`-Deklaration verhindert nur die Neuzuweisung des Variablennamens.
+
+```js
+const s = [5, 6, 7];
+s = [1, 2, 3];
+s[2] = 45;
+console.log(s);
+```
+
+`s = [1, 2, 3]` wird zu einem Fehler führen. Die `console.log` wird den Wert `[5, 6, 45]` anzeigen.
+
+Wie du siehst, kannst du das Objekt `[5, 6, 7]` selbst verändern und die Variable `s` wird immer noch auf das veränderte Array `[5, 6, 45]` zeigen. Wie alle Arrays sind die Arrayelemente in `s` veränderbar, aber weil `const` verwendet wurde, kannst du den Variablennamen `s` nicht verwenden, um mit dem Zuweisungsoperator auf ein anderes Array zu zeigen.
+
+# --instructions--
+
+Ein Array wird als `const s = [5, 7, 2]` deklariert. Ändere das Array zu `[2, 5, 7]` mit Hilfe verschiedener Elementzuweisungen.
+
+# --hints--
+
+Du solltest das Schlüsselwort `const` nicht ersetzen.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`s` sollte eine konstante Variable sein (indem du `const` verwendest).
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+s/g));
+```
+
+Du solltest die ursprüngliche Array-Deklaration nicht ändern.
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g
+ )
+ );
+```
+
+`s` sollte gleich `[2, 5, 7]` sein.
+
+```js
+assert.deepEqual(s, [2, 5, 7]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ // Only change code below this line
+
+ // Using s = [2, 5, 7] would be invalid
+
+ // Only change code above this line
+}
+editInPlace();
+```
+
+# --solutions--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ s[0] = 2;
+ s[1] = 5;
+ s[2] = 7;
+}
+editInPlace();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
new file mode 100644
index 00000000000..71bd856d0c0
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
@@ -0,0 +1,104 @@
+---
+id: 598f48a36c8c40764b4e52b3
+title: Objektmodifikationen (Mutationen) verhindern
+challengeType: 1
+forumTopicId: 301207
+dashedName: prevent-object-mutation
+---
+
+# --description--
+
+Wie wir in der vorherigen Aufgabe gesehen haben, schützt die `const`-Deklaration allein deine Daten nicht wirklich vor Modifikation. Um sicherzustellen, dass sich deine Daten nicht ändern, bietet JavaScript die Funktion `Object.freeze`, um Datenveränderungen zu verhindern.
+
+Jeder Versuch, das Objekt zu ändern, wird zurückgewiesen und ein Fehler wird ausgegeben, wenn das Skript im strikten Modus läuft.
+
+```js
+let obj = {
+ name:"FreeCodeCamp",
+ review:"Awesome"
+};
+Object.freeze(obj);
+obj.review = "bad";
+obj.newProp = "Test";
+console.log(obj);
+```
+
+Die Zuweisungen `obj.review` und `obj.newProp` führen zu Fehlern, weil unser Editor standardmäßig im strikten Modus läuft und die Konsole den Wert `{ name: "FreeCodeCamp", review: "Awesome" }` ausgibt.
+
+# --instructions--
+
+In dieser Aufgabe wirst du `Object.freeze` verwenden, um zu verhindern, dass sich mathematische Konstanten ändern. Du musst das `MATH_CONSTANTS` Objekt fixieren, damit niemand den Wert von `PI` ändern, Eigenschaften hinzufügen oder löschen kann.
+
+# --hints--
+
+Du solltest das Schlüsselwort `const` nicht ersetzen.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`MATH_CONSTANTS` sollte eine konstante Variable sein (indem du `const` verwendest).
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/const\s+MATH_CONSTANTS/g));
+```
+
+Du solltest die ursprüngliche Deklaration von `MATH_CONSTANTS` nicht ändern.
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+MATH_CONSTANTS\s+=\s+{\s+PI:\s+3.14\s+};/g
+ )
+ );
+```
+
+`PI` sollte gleich `3.14` sein.
+
+```js
+assert(PI === 3.14);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ // Only change code below this line
+
+
+ // Only change code above this line
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
+
+# --solutions--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ Object.freeze(MATH_CONSTANTS);
+
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
new file mode 100644
index 00000000000..ae3ed436ee2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
@@ -0,0 +1,70 @@
+---
+id: 587d7b8c367417b2b2512b55
+title: Verwende JavaScript-Code mit import wieder
+challengeType: 1
+forumTopicId: 301208
+dashedName: reuse-javascript-code-using-import
+---
+
+# --description--
+
+Mit `import` kannst du auswählen, welche Teile einer Datei oder eines Moduls du laden möchtest. In der vorherigen Aufgabe haben die Beispiele `add` aus der Datei `math_functions.js` exportiert. Hier erfährst du, wie du sie importieren und in einer anderen Datei verwenden kannst:
+
+```js
+import { add } from './math_functions.js';
+```
+
+`import` findet `add` in `math_functions.js`, und importiert nur diese Funktion, damit du sie verwenden kannst, und ignoriert den Rest. Das `./` sagt dem Import, dass er nach der Datei `math_functions.js` im gleichen Ordner wie die aktuelle Datei suchen soll. Der relative Dateipfad (`./`) und die Dateierweiterung (`.js`) sind erforderlich, wenn du auf diese Weise importierst.
+
+Du kannst mehr als ein Element aus der Datei importieren, indem du sie in der Anweisung `import` wie folgt hinzufügst:
+
+```js
+import { add, subtract } from './math_functions.js';
+```
+
+# --instructions--
+
+Füge die entsprechende Anweisung `import` hinzu, die es der aktuellen Datei ermöglicht, die Funktionen `uppercaseString` und `lowercaseString` zu verwenden, die du in der vorherigen Lektion exportiert hast. Diese Funktionen befinden sich in einer Datei namens `string_functions.js`, die sich im gleichen Verzeichnis wie die aktuelle Datei befindet.
+
+# --hints--
+
+Du solltest `uppercaseString` korrekt importieren.
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(uppercaseString[^}]*|[^,]*,\s*uppercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+Du solltest `lowercaseString` korrekt importieren.
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(lowercaseString[^}]*|[^,]*,\s*lowercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import { uppercaseString, lowercaseString } from './string_functions.js';
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
new file mode 100644
index 00000000000..38e1d678c5e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
@@ -0,0 +1,64 @@
+---
+id: 587d7b88367417b2b2512b46
+title: Standardparameter für Ihre Funktionen festlegen
+challengeType: 1
+forumTopicId: 301209
+dashedName: set-default-parameters-for-your-functions
+---
+
+# --description--
+
+Um uns zu helfen, flexiblere Funktionen zu erstellen, führt ES6 Standardparameter für Funktionen ein.
+
+Schau dir diesen Code an:
+
+```js
+const greeting = (name = "Anonymous") => "Hello " + name;
+
+console.log(greeting("John"));
+console.log(greeting());
+```
+
+Die Konsole zeigt die Strings `Hello John` und `Hello Anonymous` an.
+
+Der Standardparameter tritt in Kraft, wenn das Argument nicht angegeben wird (es ist undefiniert). Wie du im obigen Beispiel sehen kannst, erhält der Parameter `name` den Standardwert `Anonymous`, wenn du keinen Wert für den Parameter angibst. Du kannst Standardwerte für so viele Parameter hinzufügen, wie du willst.
+
+# --instructions--
+
+Ändere die Funktion `increment`, indem du Standardparameter hinzufügst, so dass sie 1 zu `number` addiert, wenn `value` nicht festgelegt ist.
+
+# --hints--
+
+Das Ergebnis von `increment(5, 2)` sollte `7` sein.
+
+```js
+assert(increment(5, 2) === 7);
+```
+
+Das Ergebnis von `increment(5)` sollte `6` sein.
+
+```js
+assert(increment(5) === 6);
+```
+
+Für `value` sollte ein Standardparameterwert von `1` verwendet werden.
+
+```js
+assert(code.match(/value\s*=\s*1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const increment = (number, value) => number + value;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const increment = (number, value = 1) => number + value;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
new file mode 100644
index 00000000000..37118bee113
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
@@ -0,0 +1,60 @@
+---
+id: 587d7b8c367417b2b2512b57
+title: Verwende *, um alles aus einer Datei zu importieren
+challengeType: 1
+forumTopicId: 301210
+dashedName: use--to-import-everything-from-a-file
+---
+
+# --description--
+
+Angenommen, du hast eine Datei und möchtest deren gesamten Inhalt in die aktuelle Datei importieren. Dies kann mit der `import * as` Syntax erledigt werden. Hier ist ein Beispiel, bei dem der Inhalt einer Datei namens `math_functions.js` in eine Datei im selben Verzeichnis importiert wird:
+
+```js
+import * as myMathModule from "./math_functions.js";
+```
+
+Die obige Anweisung `import` erzeugt ein Objekt mit dem Namen `myMathModule`. Dies ist nur ein Variablenname, du kannst es beliebig benennen. Das Objekt enthält alle Exporte aus `math_functions.js`, sodass du auf die Funktionen wie auf jede andere Objekteigenschaft zugreifen kannst. Hier erfährst du, wie du die importierten Funktionen `add` und `subtract` verwenden kannst:
+
+```js
+myMathModule.add(2,3);
+myMathModule.subtract(5,3);
+```
+
+# --instructions--
+
+Der Code in dieser Datei benötigt den Inhalt der Datei: `string_functions.js`, die sich in demselben Verzeichnis wie die aktuelle Datei befindet. Verwende die Syntax `import * as`, um alles aus der Datei in ein Objekt namens `stringFunctions` zu importieren.
+
+# --hints--
+
+Dein Code sollte die Syntax `import * as` korrekt verwenden.
+
+```js
+assert(
+ code.match(
+ /import\s*\*\s*as\s+stringFunctions\s+from\s*('|")\.\/string_functions\.js\1/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import * as stringFunctions from "./string_functions.js";
+
+// add code above this line
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
new file mode 100644
index 00000000000..fb6bea066bb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b43
+title: Verwende Pfeilfunktionen, um präzise anonyme Funktionen zu schreiben
+challengeType: 1
+forumTopicId: 301211
+dashedName: use-arrow-functions-to-write-concise-anonymous-functions
+---
+
+# --description--
+
+In JavaScript brauchen wir unsere Funktionen oft nicht zu benennen, vor allem wenn wir eine Funktion als Argument an eine andere Funktion übergeben. Stattdessen erstellen wir Inline-Funktionen. Wir brauchen diese Funktionen nicht zu benennen, weil wir sie nirgendwo anders wiederverwenden.
+
+Um dies zu erreichen, verwenden wir oft die folgende Syntax:
+
+```js
+const myFunc = function() {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+ES6 bietet uns den syntaktischen Zucker, um anonyme Funktionen nicht auf diese Weise schreiben zu müssen. Stattdessen kannst du die **Pfeilfunktionssyntax** verwenden:
+
+```js
+const myFunc = () => {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+Wenn es keinen Funktionsrumpf gibt, sondern nur einen Rückgabewert, kannst du mit der Pfeilfunktionssyntax das Schlüsselwort `return` sowie die Klammern, die den Code umgeben, weglassen. Dies hilft, kleinere Funktionen in einzeilige Anweisungen zu vereinfachen:
+
+```js
+const myFunc = () => "value";
+```
+
+Dieser Code gibt standardmäßig immer noch den String `value` zurück.
+
+# --instructions--
+
+Schreibe die Funktion, die der Variablen `magic` zugewiesen ist und ein `new Date()` zurückgibt, so um, dass sie die Syntax der Pfeilfunktion verwendet. Stelle außerdem sicher, dass nichts mit dem Schlüsselwort `var` definiert ist.
+
+# --hints--
+
+Du solltest das Schlüsselwort `var` ersetzen.
+
+```js
+assert.notMatch(code, /var/g)
+```
+
+`magic` sollte eine konstante Variable sein (indem du `const` benutzt).
+
+```js
+assert.match(code, /const\s+magic/g)
+```
+
+`magic` sollte eine Funktion (`function`) sein.
+
+```js
+assert(typeof magic === 'function');
+```
+
+`magic()` sollte das richtige Datum zurückgeben.
+
+```js
+assert(magic().setHours(0, 0, 0, 0) === new Date().setHours(0, 0, 0, 0));
+```
+
+Das Schlüsselwort `function` sollte nicht verwendet werden.
+
+```js
+assert.notMatch(code, /function/g)
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var magic = function() {
+ return new Date();
+};
+```
+
+# --solutions--
+
+```js
+const magic = () => {
+ return new Date();
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
new file mode 100644
index 00000000000..0856331c12b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
@@ -0,0 +1,100 @@
+---
+id: 587d7b8b367417b2b2512b53
+title: Verwende die Klassensyntax, um eine Konstruktorfunktion zu definieren
+challengeType: 1
+forumTopicId: 301212
+dashedName: use-class-syntax-to-define-a-constructor-function
+---
+
+# --description--
+
+ES6 bietet eine neue Syntax zum Erstellen von Objekten, die das Schlüsselwort class verwendet.
+
+Es ist zu beachten, dass die Syntax `class` nur eine Syntax ist und keine vollwertige klassenbasierte Implementierung eines objektorientierten Paradigmas, anders als in Sprachen wie Java, Python, Ruby usw.
+
+In ES5 definieren wir normalerweise eine Funktion `constructor` und verwenden das Schlüsselwort `new`, um ein Objekt zu instanziieren.
+
+```js
+var SpaceShuttle = function(targetPlanet){
+ this.targetPlanet = targetPlanet;
+}
+var zeus = new SpaceShuttle('Jupiter');
+```
+
+Die Syntax `class` ersetzt einfach die Erstellung der Funktion `constructor`:
+
+```js
+class SpaceShuttle {
+ constructor(targetPlanet) {
+ this.targetPlanet = targetPlanet;
+ }
+}
+const zeus = new SpaceShuttle('Jupiter');
+```
+
+Es ist zu beachten, dass das Schlüsselwort `class` eine neue Funktion deklariert, zu der ein Konstruktor hinzugefügt wird. Dieser Konstruktor wird aufgerufen, wenn `new` aufgerufen wird, um ein neues Objekt zu erstellen.
+
+**Beachte:** Für ES6-Klassennamen sollte per Konvention Großbuchstaben verwendet werden, wie in `SpaceShuttle` oben verwendet.
+
+Die Methode `constructor` ist eine spezielle Methode zur Erstellung und Initialisierung eines Objekts, das mit einer Klasse erstellt wurde. Mehr darüber erfährst du im Abschnitt Objektorientierte Programmierung der Zertifizierung JavaScript Algorithmen und Datenstrukturen.
+
+# --instructions--
+
+Verwende das Schlüsselwort `class` und schreibe einen `constructor`, um die Klasse `Vegetable` zu erstellen.
+
+Mit der Klasse `Vegetable` kannst du ein Gemüseobjekt mit einer Eigenschaft `name` erstellen, die an den `constructor` übergeben wird.
+
+# --hints--
+
+`Vegetable` sollte eine `class` mit einer definierten Methode `constructor` sein.
+
+```js
+assert(
+ typeof Vegetable === 'function' && typeof Vegetable.constructor === 'function'
+);
+```
+
+Das Schlüsselwort `class` sollte verwendet werden.
+
+```js
+assert(code.match(/class/g));
+```
+
+`Vegetable` sollte instanziiert werden können.
+
+```js
+assert(() => {
+ const a = new Vegetable('apple');
+ return typeof a === 'object';
+});
+```
+
+`carrot.name` sollte `carrot` zurückgeben.
+
+```js
+assert(carrot.name == 'carrot');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+// Only change code above this line
+
+const carrot = new Vegetable('carrot');
+console.log(carrot.name); // Should display 'carrot'
+```
+
+# --solutions--
+
+```js
+class Vegetable {
+ constructor(name) {
+ this.name = name;
+ }
+}
+const carrot = new Vegetable('carrot');
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
new file mode 100644
index 00000000000..464252d3680
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
@@ -0,0 +1,71 @@
+---
+id: 587d7b89367417b2b2512b4b
+title: Verwende die Destrukturierungszuweisung, um Variablen aus Arrays zuzuweisen
+challengeType: 1
+forumTopicId: 301213
+dashedName: use-destructuring-assignment-to-assign-variables-from-arrays
+---
+
+# --description--
+
+ES6 macht die Destrukturierung von Arrays so einfach wie die Destrukturierung von Objekten.
+
+Ein wesentlicher Unterschied zwischen dem Spread-Operator und der Array-Destrukturierung ist, dass der Spread-Operator alle Inhalte eines Arrays in eine kommagetrennte Liste auspackt. Du kannst also nicht auswählen, welche Elemente du den Variablen zuweisen möchtest.
+
+Mit der Destrukturierung eines Arrays können wir genau das tun:
+
+```js
+const [a, b] = [1, 2, 3, 4, 5, 6];
+console.log(a, b);
+```
+
+Die Konsole wird die Werte von `a` und `b` als `1, 2` anzeigen.
+
+Der Variablen `a` wird der erste Wert des Arrays zugewiesen und `b` wird der zweite Wert des Arrays zugewiesen. Wir können auch auf den Wert an einem beliebigen Index in einem Array mit Destrukturierung zugreifen, indem wir Kommas verwenden, um den gewünschten Index zu erreichen:
+
+```js
+const [a, b,,, c] = [1, 2, 3, 4, 5, 6];
+console.log(a, b, c);
+```
+
+Die Konsole wird die Werte von `a`, `b` und `c` als `1, 2, 5` anzeigen.
+
+# --instructions--
+
+Verwende die Destrukturierungszuweisung, um die Werte von `a` und `b` zu vertauschen, so dass `a` den in `b` gespeicherten Wert erhält und `b` den in `a` gespeicherten Wert erhält.
+
+# --hints--
+
+Der Wert von `a` sollte nach dem Austausch `6` sein.
+
+```js
+assert(a === 6);
+```
+
+Der Wert von `b` sollte nach dem Austausch `8` sein.
+
+```js
+assert(b === 8);
+```
+
+Du solltest die Array-Destrukturierung verwenden, um `a` und `b` zu tauschen.
+
+```js
+assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 8, b = 6;
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let a = 8, b = 6;
+[a, b] = [b, a];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
new file mode 100644
index 00000000000..58eaa792f0d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
@@ -0,0 +1,106 @@
+---
+id: 587d7b89367417b2b2512b4a
+title: Verwende die Destrukturierungszuweisung, um Variablen aus verschachtelten Objekten zuzuweisen
+challengeType: 1
+forumTopicId: 301214
+dashedName: use-destructuring-assignment-to-assign-variables-from-nested-objects
+---
+
+# --description--
+
+Du kannst die gleichen Prinzipien wie in den beiden vorangegangenen Lektionen anwenden, um Werte aus verschachtelten Objekten zu destrukturieren.
+
+Verwende ein ähnliches Objekt wie in den vorherigen Beispielen:
+
+```js
+const user = {
+ johnDoe: {
+ age: 34,
+ email: 'johnDoe@freeCodeCamp.com'
+ }
+};
+```
+
+Hier erfährst du, wie du die Werte von Objekteigenschaften extrahierst und sie Variablen mit demselben Namen zuweist:
+
+```js
+const { johnDoe: { age, email }} = user;
+```
+
+Und hier siehst du, wie du die Werte einer Objekteigenschaft Variablen mit unterschiedlichen Namen zuweisen kannst:
+
+```js
+const { johnDoe: { age: userAge, email: userEmail }} = user;
+```
+
+# --instructions--
+
+Ersetze die beiden Zuweisungen durch eine gleichwertige Destrukturierungszuweisung. Es sollte den Variablen `lowToday` und `highToday` trotzdem die Werte von `today.low` und `today.high` aus dem Objekt `LOCAL_FORECAST` zugewiesen werden.
+
+# --hints--
+
+Du solltest die ES5-Zuweisungssyntax entfernen.
+
+```js
+assert(
+ !code.match(/lowToday = LOCAL_FORECAST\.today\.low/g) &&
+ !code.match(/highToday = LOCAL_FORECAST\.today.high/g)
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `lowToday` zu erstellen.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(low\s*:\s*lowToday[^}]*|[^,]*,\s*low\s*:\s*lowToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `highToday` zu erstellen.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(high\s*:\s*highToday[^}]*|[^,]*,\s*high\s*:\s*highToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+`lowToday` sollte gleich `64` sein und `highToday` sollte gleich `77` sein.
+
+```js
+assert(lowToday === 64 && highToday === 77);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+// Only change code below this line
+
+const lowToday = LOCAL_FORECAST.today.low;
+const highToday = LOCAL_FORECAST.today.high;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+const { today: { low: lowToday, high: highToday }} = LOCAL_FORECAST;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
new file mode 100644
index 00000000000..adbde5b4cd1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b89367417b2b2512b49
+title: Verwende die Destrukturierungszuweisung, um Variablen von Objekten zuzuweisen
+challengeType: 1
+forumTopicId: 301215
+dashedName: use-destructuring-assignment-to-assign-variables-from-objects
+---
+
+# --description--
+
+Die Destrukturierung ermöglicht es dir, beim Extrahieren von Werten einen neuen Variablennamen zu vergeben. Du kannst dies tun, indem du den neuen Namen bei der Zuweisung des Wertes nach einem Doppelpunkt setzt.
+
+Verwende das gleiche Objekt wie im letzten Beispiel:
+
+```js
+const user = { name: 'John Doe', age: 34 };
+```
+
+So kannst du neue Variablennamen in der Zuweisung vergeben:
+
+```js
+const { name: userName, age: userAge } = user;
+```
+
+Du kannst es so lesen: "Hole den Wert von `user.name` und weise ihn einer neuen Variablen namens `userName` zu" und so weiter. Der Wert von `userName` wäre der String `John Doe`, und der Wert von `userAge` wäre die Zahl `34`.
+
+# --instructions--
+
+Ersetze die beiden Zuweisungen durch eine gleichwertige Destrukturierungszuweisung. Es sollte den Variablen `highToday` und `highTomorrow` noch die Werte von `today` und `tomorrow` aus dem Objekt `HIGH_TEMPERATURES` zugewiesen werden.
+
+# --hints--
+
+Du solltest die ES5-Zuweisungssyntax entfernen.
+
+```js
+assert(
+ !code.match(/highToday = HIGH_TEMPERATURES\.today/g) &&
+ !code.match(/highTomorrow = HIGH_TEMPERATURES\.tomorrow/g)
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `highToday` zu erstellen.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(today\s*:\s*highToday[^}]*|[^,]*,\s*today\s*:\s*highToday\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `highTomorrow` zu erstellen.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(tomorrow\s*:\s*highTomorrow[^}]*|[^,]*,\s*tomorrow\s*:\s*highTomorrow\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+`highToday` sollte gleich `77` sein und `highTomorrow` sollte gleich `80` sein.
+
+```js
+assert(highToday === 77 && highTomorrow === 80);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+// Only change code below this line
+
+const highToday = HIGH_TEMPERATURES.today;
+const highTomorrow = HIGH_TEMPERATURES.tomorrow;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+const { today: highToday, tomorrow: highTomorrow } = HIGH_TEMPERATURES;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
new file mode 100644
index 00000000000..3731296e58c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
@@ -0,0 +1,101 @@
+---
+id: 5cfa550e84205a357704ccb6
+title: Verwende die Destrukturierungszuweisung, um Werte aus Objekten zu extrahieren
+challengeType: 1
+forumTopicId: 301216
+dashedName: use-destructuring-assignment-to-extract-values-from-objects
+---
+
+# --description--
+
+Destrukturierungszuweisung ist eine spezielle Syntax, die in ES6 eingeführt wurde, um Werte, die direkt von einem Objekt übernommen werden, sauber zuzuweisen.
+
+Betrachte den folgenden ES5-Code:
+
+```js
+const user = { name: 'John Doe', age: 34 };
+
+const name = user.name;
+const age = user.age;
+```
+
+`name` hätte den Wert des Strings `John Doe` und `age` wäre die Zahl `34`.
+
+Hier ist eine entsprechende Zuweisungsanweisung mit der ES6-Destrukturierungssyntax:
+
+```js
+const { name, age } = user;
+```
+
+Auch hier hätte `name` den Wert des Strings `John Doe` und `age` wäre die Zahl `34`.
+
+Hier werden die Variablen `name` und `age` erstellt und mit den entsprechenden Werten aus dem Objekt `user` belegt. Du kannst sehen, wie viel sauberer das ist.
+
+Du kannst so viele oder so wenige Werte aus dem Objekt extrahieren, wie du willst.
+
+# --instructions--
+
+Ersetze die beiden Zuweisungen durch eine gleichwertige Destrukturierungszuweisung. Es sollte den Variablen `today` und `tomorrow` trotzdem die Werte von `today` und `tomorrow` aus dem Objekt `HIGH_TEMPERATURES` zugewiesen werden.
+
+# --hints--
+
+Du solltest die ES5-Zuweisungssyntax entfernen.
+
+```js
+assert(
+ !code.match(/today\s*=\s*HIGH_TEMPERATURES\.(today|tomorrow)/g)
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `today` zu erstellen.
+
+```js
+assert(
+ code.match(/(var|let|const)\s*{\s*(today[^}]*|[^,]*,\s*today)\s*}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g)
+);
+```
+
+Du solltest die Destrukturierung verwenden, um die Variable `tomorrow` zu erstellen.
+
+```js
+assert(
+ code.match(/(var|let|const)\s*{\s*(tomorrow[^}]*|[^,]*,\s*tomorrow)\s*}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g)
+);
+```
+
+`today` sollte gleich `77` sein und `tomorrow` sollte gleich `80` sein.
+
+```js
+assert(today === 77 && tomorrow === 80);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+// Only change code below this line
+
+const today = HIGH_TEMPERATURES.today;
+const tomorrow = HIGH_TEMPERATURES.tomorrow;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+const { today, tomorrow } = HIGH_TEMPERATURES;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md
new file mode 100644
index 00000000000..05b66a8d10d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md
@@ -0,0 +1,94 @@
+---
+id: 587d7b8a367417b2b2512b4d
+title: Verwende die Destrukturierungszuweisung, um ein Objekt als Parameter einer Funktion zu übergeben
+challengeType: 1
+forumTopicId: 301217
+dashedName: use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters
+---
+
+# --description--
+
+In manchen Fällen kannst du das Objekt in einem Funktionsargument selbst destrukturieren.
+
+Schau dir den folgenden Code an:
+
+```js
+const profileUpdate = (profileData) => {
+ const { name, age, nationality, location } = profileData;
+
+}
+```
+
+Dadurch wird das Objekt, das an die Funktion gesendet wird, effektiv destrukturiert. Dies kann auch an Ort und Stelle geschehen:
+
+```js
+const profileUpdate = ({ name, age, nationality, location }) => {
+
+}
+```
+
+Wenn `profileData` an die obige Funktion übergeben wird, werden die Werte aus dem Funktionsparameter für die Verwendung innerhalb der Funktion destrukturiert.
+
+# --instructions--
+
+Verwende die Destrukturierungszuweisung innerhalb des Arguments der Funktion `half`, um nur `max` und `min` innerhalb der Funktion zu senden.
+
+# --hints--
+
+`stats` sollte ein `object` sein.
+
+```js
+assert(typeof stats === 'object');
+```
+
+`half(stats)` sollte `28.015` sein
+
+```js
+assert(half(stats) === 28.015);
+```
+
+Es sollte eine Destrukturierung vorgenommen werden.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/half=\({\w+,\w+}\)/));
+```
+
+Es sollten destrukturierte Parameter verwendet werden.
+
+```js
+assert(!code.match(/stats\.max|stats\.min/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const stats = {
+ max: 56.78,
+ standard_deviation: 4.34,
+ median: 34.54,
+ mode: 23.87,
+ min: -0.75,
+ average: 35.85
+};
+
+// Only change code below this line
+const half = (stats) => (stats.max + stats.min) / 2.0;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const stats = {
+ max: 56.78,
+ standard_deviation: 4.34,
+ median: 34.54,
+ mode: 23.87,
+ min: -0.75,
+ average: 35.85
+};
+
+const half = ( {max, min} ) => (max + min) / 2.0;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md
new file mode 100644
index 00000000000..1064a0063dd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md
@@ -0,0 +1,85 @@
+---
+id: 587d7b8a367417b2b2512b4c
+title: >-
+ Verwende die Destrukturierungszuweisung mit dem Rest-Parameter, um Array-Elemente neu zuzuweisen
+challengeType: 1
+forumTopicId: 301218
+dashedName: >-
+ use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements
+---
+
+# --description--
+
+In manchen Situationen, in denen es um die Destrukturierung von Arrays geht, möchten wir vielleicht die restlichen Elemente in einem separaten Array sammeln.
+
+Das Ergebnis ist ähnlich wie bei `Array.prototype.slice()`, wie unten gezeigt:
+
+```js
+const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];
+console.log(a, b);
+console.log(arr);
+```
+
+Die Konsole würde die Werte `1, 2` und `[3, 4, 5, 7]` anzeigen.
+
+Die Variablen `a` und `b` entnehmen den ersten und zweiten Wert aus dem Array. Danach erhält `arr` die restlichen Werte in Form eines Arrays, da der Rest-Parameter vorhanden ist. Das Rest-Element funktioniert nur als letzte Variable in der Liste richtig. Das heißt, du kannst den Rest-Parameter nicht verwenden, um ein Subarray zu erfassen, das das letzte Element des ursprünglichen Arrays auslässt.
+
+# --instructions--
+
+Verwende die Destrukturierungszuweisung mit dem Rest-Parameter, um ein effektives `Array.prototype.slice()` durchzuführen, so dass `arr` ein Unterarray des ursprünglichen Arrays `source` ist, bei dem die ersten beiden Elemente weggelassen werden.
+
+# --hints--
+
+`arr` sollte `[3,4,5,6,7,8,9,10]` sein
+
+```js
+assert(arr.every((v, i) => v === i + 3) && arr.length === 8);
+```
+
+`source` sollte `[1,2,3,4,5,6,7,8,9,10]` sein
+
+```js
+assert(source.every((v, i) => v === i + 1) && source.length === 10);
+```
+
+`Array.slice()` sollte nicht verwendet werden.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/slice/g));
+```
+
+Die Destrukturierung auf `list` sollte verwendet werden.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\[(([_$a-z]\w*)?,){1,}\.\.\.arr\]=list/i)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const source = [1,2,3,4,5,6,7,8,9,10];
+function removeFirstTwo(list) {
+ // Only change code below this line
+ const arr = list; // Change this line
+ // Only change code above this line
+ return arr;
+}
+const arr = removeFirstTwo(source);
+```
+
+# --solutions--
+
+```js
+const source = [1,2,3,4,5,6,7,8,9,10];
+function removeFirstTwo(list) {
+ const [, , ...arr] = list;
+ return arr;
+}
+const arr = removeFirstTwo(source);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md
new file mode 100644
index 00000000000..ae6cee42382
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md
@@ -0,0 +1,85 @@
+---
+id: 587d7b8c367417b2b2512b56
+title: Verwende Export um einen Codeblock zu teilen
+challengeType: 1
+forumTopicId: 301219
+dashedName: use-export-to-share-a-code-block
+---
+
+# --description--
+
+Stell dir eine Datei namens `math_functions.js` vor, die verschiedene Funktionen für mathematische Operationen enthält. Eine davon wird in einer Variablen, `add`, gespeichert, die zwei Zahlen aufnimmt und ihre Summe zurückgibt. Du willst diese Funktion in mehreren verschiedenen JavaScript-Dateien verwenden. Um sie mit diesen anderen Dateien zu teilen, musst du sie zuerst exportieren (`export`).
+
+```js
+export const add = (x, y) => {
+ return x + y;
+}
+```
+
+Dies ist eine gängige Methode, um eine einzelne Funktion zu exportieren, aber du kannst das Gleiche auch auf diese Weise erreichen:
+
+```js
+const add = (x, y) => {
+ return x + y;
+}
+
+export { add };
+```
+
+Wenn du eine Variable oder Funktion exportierst, kannst du sie in eine andere Datei importieren und verwenden, ohne den Code neu schreiben zu müssen. Du kannst mehrere Dinge exportieren, indem du das erste Beispiel für jedes Ding wiederholst, das du exportieren willst, oder indem du sie alle in die Exportanweisung des zweiten Beispiels einfügst, so wie hier:
+
+```js
+export { add, subtract };
+```
+
+# --instructions--
+
+Im Editor gibt es zwei Funktionen, die sich auf Strings beziehen. Exportiere beide mit der Methode deiner Wahl.
+
+# --hints--
+
+Du solltest `uppercaseString` richtig exportieren.
+
+```js
+assert(
+ code.match(
+ /(export\s+const\s+uppercaseString|export\s*{\s*(uppercaseString[^}]*|[^,]*,\s*uppercaseString\s*)})/g
+ )
+);
+```
+
+Du solltest `lowercaseString` richtig exportieren.
+
+```js
+assert(
+ code.match(
+ /(export\s+const\s+lowercaseString|export\s*{\s*(lowercaseString[^}]*|[^,]*,\s*lowercaseString\s*)})/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const uppercaseString = (string) => {
+ return string.toUpperCase();
+}
+
+const lowercaseString = (string) => {
+ return string.toLowerCase()
+}
+```
+
+# --solutions--
+
+```js
+export const uppercaseString = (string) => {
+ return string.toUpperCase();
+}
+
+export const lowercaseString = (string) => {
+ return string.toLowerCase()
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md
new file mode 100644
index 00000000000..eac1a50eefb
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md
@@ -0,0 +1,174 @@
+---
+id: 587d7b8c367417b2b2512b54
+title: Verwende Getter und Setter, um den Zugriff auf ein Objekt zu kontrollieren
+challengeType: 1
+forumTopicId: 301220
+dashedName: use-getters-and-setters-to-control-access-to-an-object
+---
+
+# --description--
+
+Du kannst Werte von einem Objekt erhalten und den Wert einer Eigenschaft innerhalb eines Objekts festlegen.
+
+Diese werden klassischerweise Getter und Setter genannt.
+
+Getter-Funktionen dienen dazu, den Wert einer privaten Variablen eines Objekts an den Benutzer zurückzugeben (zu holen), ohne dass der Benutzer direkt auf die private Variable zugreift.
+
+Setter-Funktionen dienen dazu, den Wert der privaten Variablen eines Objekts auf der Grundlage des Wertes zu ändern (zu setzen), der der Setter-Funktion übergeben wurde. Diese Änderung kann Berechnungen beinhalten oder sogar den vorherigen Wert komplett überschreiben.
+
+```js
+class Book {
+ constructor(author) {
+ this._author = author;
+ }
+ // getter
+ get writer() {
+ return this._author;
+ }
+ // setter
+ set writer(updatedAuthor) {
+ this._author = updatedAuthor;
+ }
+}
+const novel = new Book('anonymous');
+console.log(novel.writer);
+novel.writer = 'newAuthor';
+console.log(novel.writer);
+```
+
+Die Konsole würde die Strings `anonymous` und `newAuthor` anzeigen.
+
+Beachte die Syntax, mit der die Getter und Setter aufgerufen werden. Sie sehen nicht einmal wie Funktionen aus. Getter und Setter sind wichtig, weil sie interne Implementierungsdetails verbergen.
+
+**Beachte:** Es ist Konvention, dem Namen einer privaten Variable einen Unterstrich (`_`) voranzustellen. Diese Praxis allein macht eine Variable jedoch nicht privat.
+
+# --instructions--
+
+Verwende das Schlüsselwort `class`, um eine Klasse `Thermostat` zu erstellen. Der `constructor` akzeptiert eine Fahrenheit-Temperatur.
+
+Erstelle in der Klasse einen `getter`, um die Temperatur in Celsius zu erhalten und einen `setter`, um die Temperatur in Celsius zu setzen.
+
+Denke daran, dass `C = 5/9 * (F - 32)` und `F = C * 9.0 / 5 + 32`, wobei `F` der Wert der Temperatur in Fahrenheit und `C` der Wert der gleichen Temperatur in Celsius ist.
+
+**Beachte:** Wenn du dies implementierst, verfolgst du die Temperatur innerhalb der Klasse in einer Skala, entweder Fahrenheit oder Celsius.
+
+Das ist die Macht eines Getters und eines Setters. Du erstellst eine API für einen anderen Nutzer, der das richtige Ergebnis erhalten kann, unabhängig davon, welches du verfolgst.
+
+Mit anderen Worten: Du abstrahierst die Implementierungsdetails vom Benutzer.
+
+# --hints--
+
+`Thermostat` sollte eine `class` mit einer definierten `constructor`-Methode sein.
+
+```js
+assert(
+ typeof Thermostat === 'function' &&
+ typeof Thermostat.constructor === 'function'
+);
+```
+
+Das Schlüsselwort `class` sollte verwendet werden.
+
+```js
+assert(code.match(/class/g));
+```
+
+`Thermostat` sollte instanziiert werden können.
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(122);
+ return typeof t === 'object';
+ })()
+);
+```
+
+Wenn du mit einem Fahrenheit-Wert instanziiert wirst, sollte `Thermostat` die richtige Temperatur (`temperature`) einstellen.
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(122);
+ return t.temperature === 50;
+ })()
+);
+```
+
+Es sollte ein `getter` definiert werden.
+
+```js
+assert(
+ (() => {
+ const desc = Object.getOwnPropertyDescriptor(
+ Thermostat.prototype,
+ 'temperature'
+ );
+ return !!desc && typeof desc.get === 'function';
+ })()
+);
+```
+
+Es sollte ein `setter` definiert werden.
+
+```js
+assert(
+ (() => {
+ const desc = Object.getOwnPropertyDescriptor(
+ Thermostat.prototype,
+ 'temperature'
+ );
+ return !!desc && typeof desc.set === 'function';
+ })()
+);
+```
+
+Der Aufruf des `setter` mit einem Celsius-Wert sollte die Temperatur (`temperature`) einstellen.
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(32);
+ t.temperature = 26;
+ const u = new Thermostat(32);
+ u.temperature = 50;
+ return t.temperature === 26 && u.temperature === 50;
+ })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+// Only change code above this line
+
+const thermos = new Thermostat(76); // Setting in Fahrenheit scale
+let temp = thermos.temperature; // 24.44 in Celsius
+thermos.temperature = 26;
+temp = thermos.temperature; // 26 in Celsius
+```
+
+# --solutions--
+
+```js
+class Thermostat {
+ constructor(fahrenheit) {
+ this._tempInCelsius = 5/9 * (fahrenheit - 32);
+ }
+ get temperature(){
+ return this._tempInCelsius;
+ }
+ set temperature(newTemp){
+ this._tempInCelsius = newTemp;
+ }
+}
+
+const thermos = new Thermostat(76); // Setting in Fahrenheit scale
+let temp = thermos.temperature; // 24.44 in Celsius
+thermos.temperature = 26;
+temp = thermos.temperature; // 26 in Celsius
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md
new file mode 100644
index 00000000000..a7e70ebd017
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md
@@ -0,0 +1,80 @@
+---
+id: 587d7b88367417b2b2512b47
+title: Verwende den Restparameter mit Funktionsparametern
+challengeType: 1
+forumTopicId: 301221
+dashedName: use-the-rest-parameter-with-function-parameters
+---
+
+# --description--
+
+Um uns zu helfen, flexiblere Funktionen zu erstellen, führt ES6 den Restparameter für Funktionsparameter ein. Mit dem Restparameter kannst du Funktionen erstellen, die eine variable Anzahl von Argumenten annehmen. Diese Argumente werden in einem Array gespeichert, auf das später innerhalb der Funktion zugegriffen werden kann.
+
+Schau dir diesen Code an:
+
+```js
+function howMany(...args) {
+ return "You have passed " + args.length + " arguments.";
+}
+console.log(howMany(0, 1, 2));
+console.log(howMany("string", null, [1, 2, 3], { }));
+```
+
+Die Konsole würde die Strings `You have passed 3 arguments.` und `You have passed 4 arguments.` anzeigen.
+
+Der Restparameter macht die Überprüfung des `args`-Arrays überflüssig und ermöglicht es uns, `map()`, `filter()` und `reduce()` auf das Parameter-Array anzuwenden.
+
+# --instructions--
+
+Ändere die Funktion `sum` mit dem Restparameter so ab, dass die Funktion `sum` eine beliebige Anzahl von Argumenten annehmen und deren Summe zurückgeben kann.
+
+# --hints--
+
+Das Ergebnis von `sum(0,1,2)` sollte 3 sein
+
+```js
+assert(sum(0, 1, 2) === 3);
+```
+
+Das Ergebnis von `sum(1,2,3,4)` sollte 10 sein
+
+```js
+assert(sum(1, 2, 3, 4) === 10);
+```
+
+Das Ergebnis von `sum(5)` sollte 5 sein
+
+```js
+assert(sum(5) === 5);
+```
+
+Das Ergebnis von `sum()` sollte 0 sein
+
+```js
+assert(sum() === 0);
+```
+
+`sum` sollte eine Pfeilfunktion sein, die die Restparametersyntax (`...`) für den `args`-Parameter verwendet.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/sum=\(\.\.\.args\)=>/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const sum = (x, y, z) => {
+ const args = [x, y, z];
+ return args.reduce((a, b) => a + b, 0);
+}
+```
+
+# --solutions--
+
+```js
+const sum = (...args) => {
+ return args.reduce((a, b) => a + b, 0);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md
new file mode 100644
index 00000000000..38cb9e52d26
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md
@@ -0,0 +1,84 @@
+---
+id: 587d7b89367417b2b2512b48
+title: Verwende den Spread-Operator, um Arrays an Ort und Stelle auszuwerten
+challengeType: 1
+forumTopicId: 301222
+dashedName: use-the-spread-operator-to-evaluate-arrays-in-place
+---
+
+# --description--
+
+ES6 führt den Spread-Operator ein, mit dem wir Arrays und andere Ausdrücke an Stellen erweitern können, an denen mehrere Parameter oder Elemente erwartet werden.
+
+Der folgende ES5-Code verwendet `apply()`, um den maximalen Wert in einem Array zu berechnen:
+
+```js
+var arr = [6, 89, 3, 45];
+var maximus = Math.max.apply(null, arr);
+```
+
+`maximus` hätte dann einen Wert von `89`.
+
+Wir mussten `Math.max.apply(null, arr)` verwenden, weil `Math.max(arr)` `NaN` zurückgibt. `Math.max()` erwartet kommagetrennte Argumente, aber kein Array. Durch den Spread-Operator lässt sich diese Syntax viel besser lesen und pflegen.
+
+```js
+const arr = [6, 89, 3, 45];
+const maximus = Math.max(...arr);
+```
+
+`maximus` hätte dann einen Wert von `89`.
+
+`...arr` gibt ein ungepacktes Array zurück. Mit anderen Worten, es *spreizt* das Feld. Der Spread-Operator funktioniert jedoch nur an Ort und Stelle, z. B. in einem Argument einer Funktion oder in einem Array-Literal. Der folgende Code wird nicht funktionieren:
+
+```js
+const spreaded = ...arr;
+```
+
+# --instructions--
+
+Kopiere alle Inhalte von `arr1` in ein anderes Array `arr2`, indem du den Spread-Operator benutzt.
+
+# --hints--
+
+`arr2` sollte eine korrekte Kopie von `arr1` sein.
+
+```js
+assert(arr2.every((v, i) => v === arr1[i]) && arr2.length);
+```
+
+Der `...` Spread-Operator sollte verwendet werden, um `arr1` zu duplizieren.
+
+```js
+assert(code.match(/Array\(\s*\.\.\.arr1\s*\)|\[\s*\.\.\.arr1\s*\]/));
+```
+
+`arr2` sollte unverändert bleiben, wenn `arr1` geändert wird.
+
+```js
+assert((arr1, arr2) => {
+ arr1.push('JUN');
+ return arr2.length < arr1.length;
+});
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr1 = ['JAN', 'FEB', 'MAR', 'APR', 'MAY'];
+let arr2;
+
+arr2 = []; // Change this line
+
+console.log(arr2);
+```
+
+# --solutions--
+
+```js
+const arr1 = ['JAN', 'FEB', 'MAR', 'APR', 'MAY'];
+let arr2;
+
+arr2 = [...arr1];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md
new file mode 100644
index 00000000000..eafccf47413
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md
@@ -0,0 +1,94 @@
+---
+id: 587d7b88367417b2b2512b44
+title: Pfeilfunktionen mit Parametern schreiben
+challengeType: 1
+forumTopicId: 301223
+dashedName: write-arrow-functions-with-parameters
+---
+
+# --description--
+
+Genau wie bei einer normalen Funktion kannst du einer Pfeilfunktion Argumente übergeben.
+
+```js
+const doubler = (item) => item * 2;
+doubler(4);
+```
+
+`doubler(4)` würde den Wert `8` zurückgeben.
+
+Wenn eine Pfeilfunktion einen einzigen Parameter hat, können die Klammern, die den Parameter einschließen, weggelassen werden.
+
+```js
+const doubler = item => item * 2;
+```
+
+Es ist möglich, mehr als ein Argument an eine Pfeilfunktion zu übergeben.
+
+```js
+const multiplier = (item, multi) => item * multi;
+multiplier(4, 2);
+```
+
+`multiplier(4, 2)` würde den Wert `8` zurückgeben.
+
+# --instructions--
+
+Schreibe die Funktion `myConcat`, die den Inhalt von `arr2` an `arr1` anhängt, so um, dass die Funktion die Syntax der Pfeilfunktion verwendet.
+
+# --hints--
+
+Du solltest das Schlüsselwort `var` ersetzen.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`myConcat` sollte eine konstante Variable sein (durch Verwendung von `const`).
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+myConcat/g));
+```
+
+`myConcat` sollte eine Pfeilfunktion mit zwei Parametern sein
+
+```js
+assert(
+ /myConcat=\(\w+,\w+\)=>/.test(code.replace(/\s/g, '')) &&
+ typeof myConcat === 'function'
+);
+```
+
+`myConcat()` sollte `[1, 2, 3, 4, 5]` zurückgeben.
+
+```js
+assert.deepEqual(myConcat([1, 2], [3, 4, 5]), [1, 2, 3, 4, 5]);
+```
+
+Das Schlüsselwort `function` sollte nicht verwendet werden.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/function/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var myConcat = function(arr1, arr2) {
+ return arr1.concat(arr2);
+};
+
+console.log(myConcat([1, 2], [3, 4, 5]));
+```
+
+# --solutions--
+
+```js
+const myConcat = (arr1, arr2) => {
+ return arr1.concat(arr2);
+};
+
+console.log(myConcat([1, 2], [3, 4, 5]));
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md
new file mode 100644
index 00000000000..a2f3e30f0e3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b8b367417b2b2512b50
+title: Prägnante deklarative Funktionen mit ES6 schreiben
+challengeType: 1
+forumTopicId: 301224
+dashedName: write-concise-declarative-functions-with-es6
+---
+
+# --description--
+
+Wenn wir in ES5 Funktionen innerhalb von Objekten definieren, müssen wir das Schlüsselwort `function` wie folgt verwenden:
+
+```js
+const person = {
+ name: "Taylor",
+ sayHello: function() {
+ return `Hello! My name is ${this.name}.`;
+ }
+};
+```
+
+Mit ES6 kannst du das Schlüsselwort `function` und den Doppelpunkt ganz entfernen, wenn du Funktionen in Objekten definierst. Hier ist ein Beispiel für diese Syntax:
+
+```js
+const person = {
+ name: "Taylor",
+ sayHello() {
+ return `Hello! My name is ${this.name}.`;
+ }
+};
+```
+
+# --instructions--
+
+Refaktoriere die Funktion `setGear` innerhalb des Objekts `bicycle`, um die oben beschriebene Kurzsyntax zu verwenden.
+
+# --hints--
+
+Der traditionelle Funktionsausdruck sollte nicht verwendet werden.
+
+```js
+(getUserInput) => assert(!code.match(/function/));
+```
+
+`setGear` sollte eine deklarative Funktion sein.
+
+```js
+assert(
+ typeof bicycle.setGear === 'function' && code.match(/setGear\s*\(.+\)\s*\{/)
+);
+```
+
+`bicycle.setGear(48)` sollte den Wert von `gear` auf 48 ändern.
+
+```js
+assert(new bicycle.setGear(48).gear === 48);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const bicycle = {
+ gear: 2,
+ setGear: function(newGear) {
+ this.gear = newGear;
+ }
+};
+// Only change code above this line
+bicycle.setGear(3);
+console.log(bicycle.gear);
+```
+
+# --solutions--
+
+```js
+const bicycle = {
+ gear: 2,
+ setGear(newGear) {
+ this.gear = newGear;
+ }
+};
+bicycle.setGear(3);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md
new file mode 100644
index 00000000000..7b3ad8b0bcd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md
@@ -0,0 +1,75 @@
+---
+id: 587d7b8a367417b2b2512b4f
+title: Prägnante Objektliteraldeklarationen mit der Kurzform für Objekteigenschaften schreiben
+challengeType: 1
+forumTopicId: 301225
+dashedName: write-concise-object-literal-declarations-using-object-property-shorthand
+---
+
+# --description--
+
+ES6 bietet eine gute Unterstützung für die einfache Definition von Objektliteralen.
+
+Schau dir den folgenden Code an:
+
+```js
+const getMousePosition = (x, y) => ({
+ x: x,
+ y: y
+});
+```
+
+`getMousePosition` ist eine einfache Funktion, die ein Objekt mit zwei Eigenschaften zurückgibt. ES6 bietet den syntaktischen Zucker, um die Redundanz zu beseitigen, die das Schreiben von `x: x` mit sich bringt. Du kannst einfach einmal `x` schreiben, und es wird unter der Haube in `x: x` (oder etwas Gleichwertiges) umgewandelt. Hier ist die gleiche Funktion von oben, die umgeschrieben wurde, um die neue Syntax zu verwenden:
+
+```js
+const getMousePosition = (x, y) => ({ x, y });
+```
+
+# --instructions--
+
+Verwende die Kurzform für Objekteigenschaften mit Objektliteralen, um ein Objekt mit den Eigenschaften `name`, `age` und `gender` zu erstellen und zurückzugeben.
+
+# --hints--
+
+`createPerson("Zodiac Hasbro", 56, "male")` sollte `{name: "Zodiac Hasbro", age: 56, gender: "male"}` zurückgeben.
+
+```js
+assert.deepEqual(
+ { name: 'Zodiac Hasbro', age: 56, gender: 'male' },
+ createPerson('Zodiac Hasbro', 56, 'male')
+);
+```
+
+Dein Code sollte nicht `key:value` verwenden.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/:/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const createPerson = (name, age, gender) => {
+ // Only change code below this line
+ return {
+ name: name,
+ age: age,
+ gender: gender
+ };
+ // Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+const createPerson = (name, age, gender) => {
+ return {
+ name,
+ age,
+ gender
+ };
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
new file mode 100644
index 00000000000..3dc0be78952
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
@@ -0,0 +1,88 @@
+---
+id: 587d7da9367417b2b2512b67
+title: Füge Elemente dem Ende eines Arrays mit Concat statt Push hinzu
+challengeType: 1
+forumTopicId: 301226
+dashedName: add-elements-to-the-end-of-an-array-using-concat-instead-of-push
+---
+
+# --description--
+
+Bei funktionalem Programmieren geht es um das Erstellen und Benutzen von nicht mutierenden Funktionen.
+
+In der letzten Aufgabe wurde die `concat`-Methode vorgestellt, mit der man Arrays miteinander kombinieren kann, ohne die ursprünglichen Arrays zu verändern. Vergleiche die `concat`- mit der `push`-Methode. `push` fügt ein Element am Ende desselben Arrays hinzu, für das es aufgerufen wird, was das Array verändert. Hier ist ein Beispiel:
+
+```js
+const arr = [1, 2, 3];
+arr.push([4, 5, 6]);
+```
+
+`arr` hätte nun den modifizierten Wert `[1, 2, 3, [4, 5, 6]]`, was nicht dem praktischen Programmierweg entspricht.
+
+`concat` bietet eine Möglichkeit, neue Elemente an das Ende eines Arrays anzuhängen, ohne dass es zu veränderlichen Auswirkungen kommt.
+
+# --instructions--
+
+Ändere die `nonMutatingPush`-Funktion so, dass sie `concat` anstelle von `push` verwendet, um `newItem` dem Ende von `original` hinzuzufügen. Die Funktion sollte ein Array zurückgeben.
+
+# --hints--
+
+Dein Code sollte die `concat` Methode verwenden.
+
+```js
+assert(code.match(/\.concat/g));
+```
+
+Dein Code sollte nicht die `push` Methode verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?push/g));
+```
+
+Das `first` Array sollte sich nicht ändern.
+
+```js
+assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
+```
+
+Das `second` Array sollte sich nicht ändern.
+
+```js
+assert(JSON.stringify(second) === JSON.stringify([4, 5]));
+```
+
+`nonMutatingPush([1, 2, 3], [4, 5])` sollte `[1, 2, 3, 4, 5]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(nonMutatingPush([1, 2, 3], [4, 5])) ===
+ JSON.stringify([1, 2, 3, 4, 5])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingPush(original, newItem) {
+ // Only change code below this line
+ return original.push(newItem);
+
+ // Only change code above this line
+}
+
+const first = [1, 2, 3];
+const second = [4, 5];
+nonMutatingPush(first, second);
+```
+
+# --solutions--
+
+```js
+function nonMutatingPush(original, newItem) {
+ return original.concat(newItem);
+}
+const first = [1, 2, 3];
+const second = [4, 5];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md
new file mode 100644
index 00000000000..10ee4df94a3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md
@@ -0,0 +1,84 @@
+---
+id: 587d7dab367417b2b2512b6d
+title: Verwende funktionale Programmierung, um Strings in URL-Slugs umzuwandeln
+challengeType: 1
+forumTopicId: 301227
+dashedName: apply-functional-programming-to-convert-strings-to-url-slugs
+---
+
+# --description--
+
+Die letzten verschiedenen Herausforderungen haben eine Reihe nützlicher Array- und String-Methoden vorgestellt, die funktionalen Programmiergrundsätzen folgen. Wir haben auch über `reduce` gelernt, eine leistungsstarke Methode, um Probleme auf einfachere Formen zu reduzieren. Von der Berechnung von Durchschnittswerten bis zur Sortierung kann jede Array-Operation damit durchgeführt werden. Denke daran, dass `map` und `filter` Sonderfälle von `reduce` sind.
+
+Lass uns zusammenfassen, was wir gelernt haben, um ein praktisches Problem zu lösen.
+
+Bei vielen Content-Management-Sites (CMS) wird der Titel eines Beitrags zu einem Teil der URL hinzugefügt, um ein einfaches Bookmarking zu ermöglichen. Wenn du zum Beispiel einen Medium-Beitrag mit dem Titel `Stop Using Reduce` schreibst, ist es wahrscheinlich, dass die URL eine gewisse Form des Titel-Strings enthält (`.../stop-using-reduce`). Du hast das vielleicht schon auf der FreeCodeCamp-Seite bemerkt.
+
+# --instructions--
+
+Fülle die Funktion `urlSlug` so aus, dass sie einen String `title` umwandelt und die Version mit Bindestrich für die URL zurückgibt. Du kannst jede der Methoden verwenden, die in diesem Abschnitt behandelt werden und musst nicht `replace` verwenden. Hier sind die Anforderungen:
+
+Die Eingabe ist ein String mit Leerzeichen und Wörtern in Großbuchstaben
+
+Die Ausgabe ist ein String, bei der die Leerzeichen zwischen den Wörtern durch einen Bindestrich (`-`) ersetzt werden.
+
+Die Ausgabe sollte nur Kleinbuchstaben enthalten
+
+Die Ausgabe sollte keine Leerzeichen haben
+
+# --hints--
+
+Dein Code sollte nicht die `replace` Methode für diese Challenge verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?replace/g));
+```
+
+`urlSlug("Winter Is Coming")` sollte den String `winter-is-coming` zurückgeben.
+
+```js
+assert(urlSlug('Winter Is Coming') === 'winter-is-coming');
+```
+
+`urlSlug(" Winter Is Coming")` sollte den String `winter-is-coming` zurückgeben.
+
+```js
+assert(urlSlug(' Winter Is Coming') === 'winter-is-coming');
+```
+
+`urlSlug("A Mind Needs Books Like A Sword Needs A Whetstone")` sollte den String `a-mind-needs-books-like-a-sword-needs-a-whetstone` zurückgeben.
+
+```js
+assert(
+ urlSlug('A Mind Needs Books Like A Sword Needs A Whetstone') ===
+ 'a-mind-needs-books-like-a-sword-needs-a-whetstone'
+);
+```
+
+`urlSlug("Hold The Door")` sollte den String `hold-the-door` zurückgeben.
+
+```js
+assert(urlSlug('Hold The Door') === 'hold-the-door');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+function urlSlug(title) {
+
+
+}
+// Only change code above this line
+urlSlug("A Mind Needs Books Like A Sword Needs A Whetstone");
+```
+
+# --solutions--
+
+```js
+function urlSlug(title) {
+ return title.trim().split(/\s+/).join("-").toLowerCase();
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md
new file mode 100644
index 00000000000..70a90df72e3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md
@@ -0,0 +1,78 @@
+---
+id: 587d7b8e367417b2b2512b5e
+title: Vermeide Veränderungen und Nebeneffekte durch die Verwendung von funktionaler Programmierung
+challengeType: 1
+forumTopicId: 301228
+dashedName: avoid-mutations-and-side-effects-using-functional-programming
+---
+
+# --description--
+
+Falls du es noch nicht herausgefunden hast: Das Problem in der letzten Aufgabe lag beim `splice`-Aufruf in der `tabClose()`-Funktion. Leider ändert `splice` das ursprüngliche Array, auf dem es aufgerufen wird so, dass der zweite Aufruf dazu ein modifiziertes Array verwendet und unerwartete Ergebnisse lieferte.
+
+Dies ist ein kleines Beispiel für ein viel größeres Muster - du rufst eine Funktion für eine Variable, ein Array oder ein Objekt auf und die Funktion ändert die Variable oder etwas im Objekt.
+
+Eines der Kernprinzipien der funktionalen Programmierung ist, die Dinge nicht zu ändern. Änderungen führen zu Bugs. Es ist einfacher, Fehler zu vermeiden, wenn du weißt, dass deine Funktionen nichts verändern, einschließlich der Funktionsargumente oder einer globalen Variable.
+
+Das vorherige Beispiel hatte keine komplizierten Aktionen, aber die `splice` Methode veränderte das ursprüngliche Array und führte zu einem Fehler.
+
+Denk daran, dass in der funktionalen Programmierung das Ändern oder Verändern von Dingen Mutation genannt wird und das Ergebnis wird Nebenwirkung genannt. Eine Funktion sollte idealerweise eine pure function sein, das heißt, sie verursacht keine Nebenwirkungen.
+
+Lass uns versuchen, diese Disziplin zu meistern und keine Variablen oder Objekte in unserem Code zu verändern.
+
+# --instructions--
+
+Fülle den Code für die Funktion `incrementer` so aus, dass sie den Wert der globalen Variablen `fixedValue` plus eins zurückgibt.
+
+# --hints--
+
+Deine Funktion `incrementer` sollte den Wert von `fixedValue` (d.h. `4`) nicht ändern.
+
+```js
+incrementer();
+assert(fixedValue === 4);
+```
+
+Deine `incrementer` Funktion sollte einen Wert zurückgeben, der größer ist als der Wert von `fixedValue`.
+
+```js
+const __newValue = incrementer();
+assert(__newValue === 5);
+```
+
+Deine `incrementer` Funktion sollte einen Wert basierend auf dem globalen `fixedValue` Variablenwert zurückgeben.
+
+```js
+(function () {
+ fixedValue = 10;
+ const newValue = incrementer();
+ assert(fixedValue === 10 && newValue === 11);
+ fixedValue = 4;
+})();
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+let fixedValue = 4;
+
+function incrementer() {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+let fixedValue = 4
+
+function incrementer() {
+ return fixedValue + 1
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md
new file mode 100644
index 00000000000..2668d689d24
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md
@@ -0,0 +1,89 @@
+---
+id: 587d7daa367417b2b2512b6c
+title: Ein Array mit der join-Methode zu einem String kombinieren
+challengeType: 1
+forumTopicId: 18221
+dashedName: combine-an-array-into-a-string-using-the-join-method
+---
+
+# --description--
+
+Die Methode `join` wird verwendet, um die Elemente eines Arrays miteinander zu verbinden und einen String zu erstellen. Es wird ein Argument für das Trennzeichen benötigt, das verwendet wird, um die Array-Elemente im String zu trennen.
+
+Hier ist ein Beispiel:
+
+```js
+const arr = ["Hello", "World"];
+const str = arr.join(" ");
+```
+
+`str` sollte einen Wert des Strings `Hello World` haben.
+# --instructions--
+
+Benutze (unter anderem) die `join` Methode innerhalb der `sentensify` Funktion, um aus den Wörtern im String `str` einen Satz zu bilden. Die Funktion sollte einen String zurückgeben. Zum Beispiel würde `I-like-Star-Wars` in `I like Star Wars` konvertiert werden. Verwende bei dieser Herausforderung nicht die `replace` Methode.
+
+# --hints--
+
+Dein Code sollte die `join` Methode verwenden.
+
+```js
+assert(code.match(/\.join/g));
+```
+
+Dein Code sollte nicht die `replace` Methode verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?replace/g));
+```
+
+`sentensify("May-the-force-be-with-you")` sollte einen String zurückgeben.
+
+```js
+assert(typeof sentensify('May-the-force-be-with-you') === 'string');
+```
+
+`sentensify("May-the-force-be-with-you")` sollte den String `May the force be with you` zurückgeben.
+
+```js
+assert(sentensify('May-the-force-be-with-you') === 'May the force be with you');
+```
+
+`sentensify("The.force.is.strong.with.this.one")` sollte den String `The force is strong with this one` zurückgeben.
+
+```js
+assert(
+ sentensify('The.force.is.strong.with.this.one') ===
+ 'The force is strong with this one'
+);
+```
+
+`sentensify("There,has,been,an,awakening")` sollte den String `There has been an awakening` zurückgegeben.
+
+```js
+assert(
+ sentensify('There,has,been,an,awakening') === 'There has been an awakening'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sentensify(str) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+sentensify("May-the-force-be-with-you");
+```
+
+# --solutions--
+
+```js
+function sentensify(str) {
+ return str.split(/\W/).join(' ');
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
new file mode 100644
index 00000000000..dea38ef4c98
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
@@ -0,0 +1,77 @@
+---
+id: 587d7da9367417b2b2512b66
+title: Kombiniere zwei Arrays mit der concat-Methode
+challengeType: 1
+forumTopicId: 301229
+dashedName: combine-two-arrays-using-the-concat-method
+---
+
+# --description--
+
+Concatenation bedeutet, dass man Elemente miteinander verbindet. JavaScript bietet die `concat` Methode für Strings und Arrays, die auf die gleiche Weise funktionieren. Bei Arrays wird diese Methode mit einem aufgerufen, dann wird ein weiteres Array als Argument an `concat` übergeben, das an das Ende des ersten Arrays angehängt wird. Sie gibt ein neues Array zurück und verändert keines der ursprünglichen Arrays. Hier ist ein Beispiel:
+
+```js
+[1, 2, 3].concat([4, 5, 6]);
+```
+
+Das zurückgegebene Array wäre `[1, 2, 3, 4, 5, 6]`.
+
+# --instructions--
+
+Verwende die `concat` Methode in der `nonMutatingConcat` Funktion, um `attach` an das Ende von `original` zu verknüpfen. Die Funktion sollte das verkettete Array zurückgeben.
+
+# --hints--
+
+Dein Code sollte die `concat` Methode verwenden.
+
+```js
+assert(code.match(/\.concat/g));
+```
+
+Das `first` Array sollte sich nicht ändern.
+
+```js
+assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
+```
+
+Das `second` Array sollte sich nicht ändern.
+
+```js
+assert(JSON.stringify(second) === JSON.stringify([4, 5]));
+```
+
+`nonMutatingConcat([1, 2, 3], [4, 5])` sollte `[1, 2, 3, 4, 5]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(nonMutatingConcat([1, 2, 3], [4, 5])) ===
+ JSON.stringify([1, 2, 3, 4, 5])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingConcat(original, attach) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+const first = [1, 2, 3];
+const second = [4, 5];
+nonMutatingConcat(first, second);
+```
+
+# --solutions--
+
+```js
+function nonMutatingConcat(original, attach) {
+ return original.concat(attach);
+}
+const first = [1, 2, 3];
+const second = [4, 5];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md
new file mode 100644
index 00000000000..f54b946b509
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md
@@ -0,0 +1,72 @@
+---
+id: 587d7b8f367417b2b2512b62
+title: Eine map auf einem Prototypen implementieren
+challengeType: 1
+forumTopicId: 301230
+dashedName: implement-map-on-a-prototype
+---
+
+# --description--
+
+Wie du bei der Anwendung von `Array.prototype.map()` oder kurz `map()` gesehen hast, gibt die Methode `map` ein Array mit der gleichen Länge zurück wie das Array, mit dem es aufgerufen wurde. Außerdem verändert sie das ursprüngliche Array nicht, solange es die Callback-Funktion nicht tut.
+
+Anders ausgedrückt: `map` ist eine reine Funktion und ihre Ausgabe hängt ausschließlich von ihren Eingaben ab. Außerdem nimmt es eine andere Funktion als Argument.
+
+Du kannst viel über die `map`-Methode lernen, wenn du deine eigene Version implementierst. Es wird empfohlen, eine `for` Schleife oder `Array.prototype.forEach()` zu verwenden.
+
+# --instructions--
+
+Schreibe dein eigenes `Array.prototype.myMap()`, welches sich genau wie `Array.prototype.map()` verhält. Du solltest nicht die eingebaute `map` Methode verwenden. Die `Array` Instanz kann in der `myMap` Methode mit `this` aufgerufen werden.
+
+# --hints--
+
+`new_s` sollte `[46, 130, 196, 10]` entsprechen.
+
+```js
+assert(JSON.stringify(new_s) === JSON.stringify([46, 130, 196, 10]));
+```
+
+Dein Code sollte nicht die `map` Methode verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?map/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const s = [23, 65, 98, 5];
+
+Array.prototype.myMap = function(callback) {
+ const newArray = [];
+ // Only change code below this line
+
+ // Only change code above this line
+ return newArray;
+};
+
+const new_s = s.myMap(function(item) {
+ return item * 2;
+});
+```
+
+# --solutions--
+
+```js
+const s = [23, 65, 98, 5];
+
+Array.prototype.myMap = function(callback) {
+ const newArray = [];
+ for (const elem of this) {
+ newArray.push(callback(elem));
+ }
+ return newArray;
+};
+
+const new_s = s.myMap(function(item) {
+ return item * 2;
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md
new file mode 100644
index 00000000000..a9085a8e98b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md
@@ -0,0 +1,67 @@
+---
+id: 587d7b8f367417b2b2512b64
+title: Implementierung der Filter-Methode auf einen Prototypen
+challengeType: 1
+forumTopicId: 301231
+dashedName: implement-the-filter-method-on-a-prototype
+---
+
+# --description--
+
+Du kannst viel über die `filter`-Methode lernen, wenn du deine eigene Version implementierst. Es wird empfohlen, eine `for`-Schleife oder `Array.prototype.forEach()` zu verwenden.
+
+# --instructions--
+
+Schreibe deinen eigenen `Array.prototype.myFilter()`, der sich genau wie `Array.prototype.filter()` verhält. Du solltest die eingebaute `filter`-Methode nicht verwenden. Die `Array`-Instanz kann in der `myFilter`-Methode mit `this` aufgerufen werden.
+
+# --hints--
+
+`new_s` sollte `[23, 65, 5, ]` entsprechen.
+
+```js
+assert(JSON.stringify(new_s) === JSON.stringify([23, 65, 5]));
+```
+
+Dein Code sollte nicht die `filter` Methode verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?filter/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const s = [23, 65, 98, 5];
+
+Array.prototype.myFilter = function(callback) {
+ // Only change code below this line
+ const newArray = [];
+ // Only change code above this line
+ return newArray;
+};
+
+const new_s = s.myFilter(function(item) {
+ return item % 2 === 1;
+});
+```
+
+# --solutions--
+
+```js
+const s = [23, 65, 98, 5];
+
+Array.prototype.myFilter = function(callback) {
+ const newArray = [];
+ for (let i = 0; i < this.length; i++) {
+ if (callback(this[i])) newArray.push(this[i]);
+ }
+ return newArray;
+};
+
+const new_s = s.myFilter(function(item) {
+ return item % 2 === 1;
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md
new file mode 100644
index 00000000000..ca7d6875b27
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md
@@ -0,0 +1,102 @@
+---
+id: 587d7dab367417b2b2512b70
+title: Einführung in Currying und partielle Anwendung
+challengeType: 1
+forumTopicId: 301232
+dashedName: introduction-to-currying-and-partial-application
+---
+
+# --description--
+
+Die Anzahl der Argumente, die eine Funktion benötigt, nennt man die Natur der Funktion. Das Currying einer Funktion bedeutet, dass eine Funktion der Ordnung N in N Funktionen der Ordnung 1 transformiert wird.
+
+Mit anderen Worten: Eine Funktion wird so umstrukturiert, dass sie ein Argument annimmt und dann eine andere Funktion zurückgibt, die das nächste Argument annimmt, und so weiter.
+
+Hier ist ein Beispiel:
+
+```js
+function unCurried(x, y) {
+ return x + y;
+}
+
+function curried(x) {
+ return function(y) {
+ return x + y;
+ }
+}
+
+const curried = x => y => x + y
+
+curried(1)(2)
+```
+
+`curried(1)(2)` würde `3` zurückgeben.
+
+Das ist in deinem Programm nützlich, wenn du nicht alle Argumente für eine Funktion auf einmal angeben kannst. Du kannst jeden Funktionsaufruf in einer Variablen speichern, die die zurückgegebene Funktionsreferenz enthält, die das nächste Argument übernimmt, wenn es verfügbar ist. Hier ist ein Beispiel, in dem die Curried-Funktion aus dem obigen Beispiel verwendet wird:
+
+```js
+const funcForY = curried(1);
+console.log(funcForY(2)); // 3
+```
+
+In ähnlicher Weise kann partielle Anwendung als Anwendung einiger Argumente auf eine Funktion und die Rückgabe einer anderen Funktion, die auf weitere Argumente angewendet wird, beschrieben werden. Hier ist ein Beispiel:
+
+```js
+function impartial(x, y, z) {
+ return x + y + z;
+}
+
+const partialFn = impartial.bind(this, 1, 2);
+partialFn(10); // 13
+```
+
+# --instructions--
+
+Fülle den Körper der Funktion `add` so aus, dass sie Currying verwendet, um die Parameter `x`, `y` und `z` hinzuzufügen.
+
+# --hints--
+
+`add(10)(20)(30)` sollte `60` zurückgeben.
+
+```js
+assert(add(10)(20)(30) === 60);
+```
+
+`add(1)(2)(3)` sollte `6` zurückgeben.
+
+```js
+assert(add(1)(2)(3) === 6);
+```
+
+`add(11)(22)(33)` sollte `66` zurückgeben.
+
+```js
+assert(add(11)(22)(33) === 66);
+```
+
+Dein Code sollte eine abschließende Anweisung enthalten, die `x + y + z` zurückgibt.
+
+```js
+assert(code.match(/[xyz]\s*?\+\s*?[xyz]\s*?\+\s*?[xyz]/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function add(x) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+add(10)(20)(30);
+```
+
+# --solutions--
+
+```js
+const add = x => y => z => x + y + z
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
new file mode 100644
index 00000000000..9d5fc6afbe4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b8d367417b2b2512b5b
+title: Lerne mehr über funktionale Programmierung
+challengeType: 1
+forumTopicId: 301233
+dashedName: learn-about-functional-programming
+---
+
+# --description--
+
+Funktionale Programmierung ist ein Programmierstil, bei dem die Lösungen einfache, isolierte Funktionen sind, ohne jegliche Nebeneffekte außerhalb des Funktionsumfangs: Eingabe -> Prozess ->Ausgabe ( `INPUT -> PROCESS -> OUTPUT`)
+
+Bei der funktionalen Programmierung geht es um:
+
+1) Isolierte Funktionen - es gibt keine Abhängigkeit vom Status des Programms, das globale Variablen enthält, die geändert werden können
+
+2) Reine Funktionen - die gleiche Eingabe gibt immer die gleiche Ausgabe
+
+3) Funktionen mit begrenzten Nebeneffekten - alle Änderungen oder Mutationen des Programmzustands außerhalb der Funktion werden sorgfältig kontrolliert
+
+# --instructions--
+
+Die Mitglieder von FreeCodeCamp lieben Tee.
+
+Im Code-Editor sind die Funktionen `prepareTea` und `getTea` bereits für dich definiert. Rufe die `getTea` Funktion auf, um 40 Tassen Tee für das Team zu erhalten, und speichere sie in der `tea4TeamFCC` Variable.
+
+# --hints--
+
+Die Variable `tea4TeamFCC` sollte 40 Tassen Tee für das Team enthalten.
+
+```js
+assert(tea4TeamFCC.length === 40);
+```
+
+Die Variable `tea4TeamFCC` sollte Tassen mit grünem Tee enthalten.
+
+```js
+assert(tea4TeamFCC[0] === 'greenTea');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Function that returns a string representing a cup of green tea
+const prepareTea = () => 'greenTea';
+
+/*
+Given a function (representing the tea type) and number of cups needed, the
+following function returns an array of strings (each representing a cup of
+a specific type of tea).
+*/
+const getTea = (numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+// Only change code below this line
+const tea4TeamFCC = null;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const prepareTea = () => 'greenTea';
+
+const getTea = (numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+
+ return teaCups;
+};
+
+const tea4TeamFCC = getTea(40);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
new file mode 100644
index 00000000000..437f64182f6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b8e367417b2b2512b5f
+title: Übergabe von Argumenten zur Vermeidung externer Abhängigkeiten in einer Funktion
+challengeType: 1
+forumTopicId: 301234
+dashedName: pass-arguments-to-avoid-external-dependence-in-a-function
+---
+
+# --description--
+
+Die letzte Aufgabe hat uns den Prinzipien der funktionalen Programmierung einen Schritt näher gebracht, aber es fehlt noch etwas.
+
+Wir haben den Wert der globalen Variable nicht verändert, aber die Funktion `incrementer` würde nicht funktionieren, wenn die globale Variable `fixedValue` nicht vorhanden wäre.
+
+Ein weiterer Grundsatz der funktionalen Programmierung ist, dass du deine Abhängigkeiten immer explizit deklarierst. Das heißt, wenn eine Funktion vom Vorhandensein einer Variablen oder eines Objekts abhängt, übergibst du diese Variable oder dieses Objekt direkt als Argument an die Funktion.
+
+Aus diesem Prinzip ergeben sich mehrere gute Konsequenzen. Die Funktion ist einfacher zu testen, du weißt genau, welche Eingaben sie benötigt und sie hängt nicht von anderen Teilen deines Programms ab.
+
+Das kann dir mehr Sicherheit geben, wenn du den Code änderst, entfernst oder neu hinzufügst. Du würdest wissen, was du ändern kannst und was nicht, und du könntest sehen, wo die möglichen Fallstricke sind.
+
+Schließlich würde die Funktion immer die gleiche Ausgabe für die gleiche Menge an Eingaben produzieren, egal welcher Teil des Codes sie ausführt.
+
+# --instructions--
+
+Aktualisieren wir die Funktion `incrementer`, um ihre Abhängigkeiten klar zu deklarieren.
+
+Schreibe die Funktion `incrementer` so, dass sie ein Argument annimmt und dann ein Ergebnis zurückgibt, nachdem sie den Wert um eins erhöht hat.
+
+# --hints--
+
+Deine Funktion `incrementer` sollte den Wert von `fixedValue` (der `4` ist) nicht verändern.
+
+```js
+assert(fixedValue === 4);
+```
+
+Deine Funktion `incrementer` sollte ein Argument benötigen.
+
+```js
+assert(incrementer.length === 1);
+```
+
+Deine Funktion `incrementer` sollte einen Wert zurückgeben, der um eins größer ist als der Wert von `fixedValue`.
+
+```js
+const __newValue = incrementer(fixedValue);
+assert(__newValue === 5);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+let fixedValue = 4;
+
+// Only change code below this line
+function incrementer() {
+
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+let fixedValue = 4;
+
+function incrementer(fixedValue) {
+ return fixedValue + 1;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md
new file mode 100644
index 00000000000..b166822ec2c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md
@@ -0,0 +1,133 @@
+---
+id: 587d7b8f367417b2b2512b60
+title: Refaktoriere globale Variablen außerhalb von Funktionen
+challengeType: 1
+forumTopicId: 301235
+dashedName: refactor-global-variables-out-of-functions
+---
+
+# --description--
+
+Bisher haben wir zwei unterschiedliche Prinzipien der funktionalen Programmierung kennengelernt:
+
+1) Verändere keine Variablen oder Objekte - erstelle neue Variablen und Objekte und gib sie bei Bedarf aus einer Funktion zurück. Tipp: Wenn du etwas wie `const newArr = arrVar` verwendest, wobei `arrVar` ein Array ist, wird einfach ein Verweis auf die bestehende Variable erstellt und keine Kopie. Wenn du also einen Wert in `newArr` änderst, ändert sich der Wert in `arrVar`.
+
+2) Deklariere Funktionsparameter - jede Berechnung innerhalb einer Funktion hängt nur von den Argumenten ab, die der Funktion übergeben werden, und nicht von einem globalen Objekt oder einer Variablen.
+
+Das Addieren von eins zu einer Zahl ist nicht sehr aufregend, aber wir können diese Prinzipien anwenden, wenn wir mit Arrays oder komplexeren Objekten arbeiten.
+
+# --instructions--
+
+Schreibe den Code so um, dass das globale Array `bookList` in keiner der Funktionen verändert wird. Die Funktion `add` soll den angegebenen Buchtitel `bookName` an das Ende des übergebenen Arrays anfügen und ein neues Array (Liste) zurückgeben. Die Funktion `remove` soll den angegebenen `bookName` aus dem Array entfernen, das ihr übergeben wurde.
+
+**Hinweis:** Beide Funktionen sollten ein Array zurückgeben, und alle neuen Parameter sollten vor dem Parameter `bookName` hinzugefügt werden.
+
+# --hints--
+
+`bookList` sollte sich nicht ändern und immer noch `["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]` entsprechen.
+
+```js
+add(bookList, "Test");
+remove(bookList, "The Hound of the Baskervilles");
+assert(
+ JSON.stringify(bookList) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'On The Electrodynamics of Moving Bodies',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae'
+ ])
+);
+```
+
+`add(bookList, "A Brief History of Time")` sollte `["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(add(bookList, "A Brief History of Time")) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'On The Electrodynamics of Moving Bodies',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae',
+ 'A Brief History of Time'
+ ])
+);
+```
+
+`remove(bookList, "On The Electrodynamics of Moving Bodies")` sollte `["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(remove(bookList, 'On The Electrodynamics of Moving Bodies')) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae'
+ ])
+);
+```
+
+`remove(add(bookList, "A Brief History of Time"), "On The Electrodynamics of Moving Bodies");` sollte gleich `["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]` sein.
+
+```js
+assert(
+ JSON.stringify(remove(add(bookList, 'A Brief History of Time'), 'On The Electrodynamics of Moving Bodies')) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae',
+ 'A Brief History of Time'
+ ])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const bookList = ["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"];
+
+// Change code below this line
+function add(bookName) {
+
+ bookList.push(bookName);
+ return bookList;
+
+ // Change code above this line
+}
+
+// Change code below this line
+function remove(bookName) {
+ const book_index = bookList.indexOf(bookName);
+ if (book_index >= 0) {
+
+ bookList.splice(book_index, 1);
+ return bookList;
+
+ // Change code above this line
+ }
+}
+```
+
+# --solutions--
+
+```js
+// The global variable
+const bookList = ["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"];
+
+function add(bookList, bookName) {
+ return [...bookList, bookName];
+}
+
+function remove(bookList, bookName) {
+ const bookListCopy = [...bookList];
+ const bookNameIndex = bookList.indexOf(bookName);
+ if (bookNameIndex >= 0) {
+ bookListCopy.splice(bookNameIndex, 1);
+ }
+ return bookListCopy;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
new file mode 100644
index 00000000000..8253a382a0f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
@@ -0,0 +1,84 @@
+---
+id: 9d7123c8c441eeafaeb5bdef
+title: Entfernen von Elementen aus einem Array mit slice statt splice
+challengeType: 1
+forumTopicId: 301236
+dashedName: remove-elements-from-an-array-using-slice-instead-of-splice
+---
+
+# --description--
+
+Ein häufiges Muster bei der Arbeit mit Arrays ist, dass du Elemente entfernen und den Rest des Arrays behalten willst. JavaScript bietet dafür die Methode `splice`, die Argumente für den Index, wo mit dem Entfernen von Elementen begonnen werden soll, und dann die Anzahl der zu entfernenden Elemente entgegennimmt. Wenn das zweite Argument nicht angegeben wird, werden standardmäßig die Einträge bis zum Ende entfernt. Allerdings verändert die Methode `splice` das ursprüngliche Array, auf das sie angewendet wird. Hier ist ein Beispiel:
+
+```js
+const cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+cities.splice(3, 1);
+```
+
+Hier gibt `splice` den String `London` zurück und löscht ihn aus dem Array cities. `cities` wird den Wert `["Chicago", "Delhi", "Islamabad", "Berlin"]` haben.
+
+Wie wir in der letzten Aufgabe gesehen haben, verändert die Methode `slice` das ursprüngliche Array nicht, sondern gibt ein neues Array zurück, das in einer Variablen gespeichert werden kann. Du erinnerst dich, dass die Methode `slice` zwei Argumente für die Indizes für den Anfang und das Ende des Slice benötigt (das Ende ist nicht eingeschlossen) und diese Elemente in einem neuen Array zurückgibt. Wenn du die Methode `slice` anstelle von `splice` verwendest, vermeidest du alle Array-mutierenden Nebeneffekte.
+
+# --instructions--
+
+Schreibe die Funktion `nonMutatingSplice` um, indem du `slice` anstelle von `splice` verwendest. Sie sollte das übergebene Array `cities` auf eine Länge von 3 begrenzen und ein neues Array mit nur den ersten drei Elementen zurückgeben.
+
+Verändere das ursprüngliche Array, das der Funktion übergeben wird, nicht.
+
+# --hints--
+
+Dein Code sollte die Methode `slice` verwenden.
+
+```js
+assert(code.match(/\.slice/g));
+```
+
+Dein Code sollte nicht die Methode `splice` verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?splice/g));
+```
+
+Das Array `inputCities` sollte sich nicht ändern.
+
+```js
+assert(
+ JSON.stringify(inputCities) ===
+ JSON.stringify(['Chicago', 'Delhi', 'Islamabad', 'London', 'Berlin'])
+);
+```
+
+`nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])` sollte `["Chicago", "Delhi", "Islamabad"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(
+ nonMutatingSplice(['Chicago', 'Delhi', 'Islamabad', 'London', 'Berlin'])
+ ) === JSON.stringify(['Chicago', 'Delhi', 'Islamabad'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingSplice(cities) {
+ // Only change code below this line
+ return cities.splice(3);
+
+ // Only change code above this line
+}
+
+const inputCities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+nonMutatingSplice(inputCities);
+```
+
+# --solutions--
+
+```js
+function nonMutatingSplice(cities) {
+ return cities.slice(0,3);
+}
+const inputCities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md
new file mode 100644
index 00000000000..b36ec57f74b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md
@@ -0,0 +1,90 @@
+---
+id: 587d7da9367417b2b2512b6a
+title: Ein sortiertes Array zurückgeben, ohne das ursprüngliche Array zu verändern
+challengeType: 1
+forumTopicId: 301237
+dashedName: return-a-sorted-array-without-changing-the-original-array
+---
+
+# --description--
+
+Ein Nebeneffekt der Methode `sort` ist, dass sie die Reihenfolge der Elemente im ursprünglichen Array ändert. Mit anderen Worten: Sie verändert das Array an Ort und Stelle. Eine Möglichkeit, dies zu vermeiden, ist, zuerst ein leeres Array mit dem zu sortierenden Array zu verketten (denk daran, dass `slice` und `concat` ein neues Array zurückgeben) und dann die Methode `sort` auszuführen.
+
+# --instructions--
+
+Verwende die Methode `sort` in der Funktion `nonMutatingSort`, um die Elemente eines Arrays in aufsteigender Reihenfolge zu sortieren. Die Funktion sollte ein neues Array zurückgeben und die Variable `globalArray` nicht verändern.
+
+# --hints--
+
+Dein Code sollte die Methode `sort` verwenden.
+
+```js
+assert(nonMutatingSort.toString().match(/\.sort/g));
+```
+
+Die Variable `globalArray` sollte sich nicht ändern.
+
+```js
+assert(JSON.stringify(globalArray) === JSON.stringify([5, 6, 3, 2, 9]));
+```
+
+`nonMutatingSort(globalArray)` sollte `[2, 3, 5, 6, 9]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(nonMutatingSort(globalArray)) ===
+ JSON.stringify([2, 3, 5, 6, 9])
+);
+```
+
+`nonMutatingSort(globalArray)` sollte nicht hart kodiert sein.
+
+```js
+assert(!nonMutatingSort.toString().match(/\[.*?[23569].*?\]/gs));
+```
+
+Die Funktion sollte ein neues Array zurückgeben, nicht das Array, das ihr übergeben wurde.
+
+```js
+assert(nonMutatingSort(globalArray) !== globalArray);
+```
+
+`nonMutatingSort([1, 30, 4, 21, 100000])` sollte `[1, 4, 21, 30, 100000]` zurückgeben.
+
+```js
+assert(JSON.stringify(nonMutatingSort([1, 30, 4, 21, 100000])) ===
+ JSON.stringify([1, 4, 21, 30, 100000]))
+```
+
+`nonMutatingSort([140000, 104, 99])` sollte `[99, 104, 140000]` zurückgeben.
+
+```js
+assert(JSON.stringify(nonMutatingSort([140000, 104, 99])) ===
+ JSON.stringify([99, 104, 140000]))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const globalArray = [5, 6, 3, 2, 9];
+
+function nonMutatingSort(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+nonMutatingSort(globalArray);
+```
+
+# --solutions--
+
+```js
+const globalArray = [5, 6, 3, 2, 9];
+function nonMutatingSort(arr) {
+ return [].concat(arr).sort((a,b) => a-b);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md
new file mode 100644
index 00000000000..8d0819f54a9
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b90367417b2b2512b65
+title: Teil eines Arrays mit der slice-Methode zurückgeben
+challengeType: 1
+forumTopicId: 301239
+dashedName: return-part-of-an-array-using-the-slice-method
+---
+
+# --description--
+
+Die Methode `slice` gibt eine Kopie bestimmter Elemente eines Arrays zurück. Sie kann zwei Argumente annehmen: Das erste gibt den Index an, an dem das Slice beginnen soll, das zweite ist der Index, an dem das Slice enden soll (und ist nicht exklusiv). Wenn die Argumente nicht angegeben werden, wird standardmäßig am Anfang des Arrays begonnen und bis zum Ende durchgezogen, was eine einfache Möglichkeit ist, eine Kopie des gesamten Arrays zu erstellen. Die Methode `slice` verändert das ursprüngliche Array nicht, sondern gibt ein neues zurück.
+
+Hier ist ein Beispiel:
+
+```js
+const arr = ["Cat", "Dog", "Tiger", "Zebra"];
+const newArray = arr.slice(1, 3);
+```
+
+`newArray` würde den Wert `["Dog", "Tiger"]` haben.
+
+# --instructions--
+
+Verwende die Methode `slice` in der Funktion `sliceArray`, um einen Teil des Arrays `anim` mit den angegebenen Indizes `beginSlice` und `endSlice` zurückzugeben. Die Funktion sollte ein Array zurückgeben.
+
+# --hints--
+
+Dein Code sollte die Methode `slice` verwenden.
+
+```js
+assert(code.match(/\.slice/g));
+```
+
+Die Variable `inputAnim` sollte sich nicht ändern.
+
+```js
+assert(
+ JSON.stringify(inputAnim) ===
+ JSON.stringify(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)` sollte `["Dog", "Tiger"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 1, 3)) ===
+ JSON.stringify(['Dog', 'Tiger'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)` sollte `["Cat"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 0, 1)) ===
+ JSON.stringify(['Cat'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)` sollte `["Dog", "Tiger", "Zebra"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 1, 4)) ===
+ JSON.stringify(['Dog', 'Tiger', 'Zebra'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sliceArray(anim, beginSlice, endSlice) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+const inputAnim = ["Cat", "Dog", "Tiger", "Zebra", "Ant"];
+sliceArray(inputAnim, 1, 3);
+```
+
+# --solutions--
+
+```js
+function sliceArray(anim, beginSlice, endSlice) {
+ return anim.slice(beginSlice, endSlice);
+}
+const inputAnim = ["Cat", "Dog", "Tiger", "Zebra", "Ant"];
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md
new file mode 100644
index 00000000000..d3b639894a4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md
@@ -0,0 +1,101 @@
+---
+id: 587d7da9367417b2b2512b69
+title: Ein Array mit der sort-Methode alphabetisch sortieren
+challengeType: 1
+forumTopicId: 18303
+dashedName: sort-an-array-alphabetically-using-the-sort-method
+---
+
+# --description--
+
+Die Methode `sort` sortiert die Elemente eines Arrays entsprechend der Callback-Funktion.
+
+Zum Beispiel:
+
+```js
+function ascendingOrder(arr) {
+ return arr.sort(function(a, b) {
+ return a - b;
+ });
+}
+
+ascendingOrder([1, 5, 2, 3, 4]);
+```
+
+Dies würde den Wert `[1, 2, 3, 4, 5]` zurückgeben.
+
+```js
+function reverseAlpha(arr) {
+ return arr.sort(function(a, b) {
+ return a === b ? 0 : a < b ? 1 : -1;
+ });
+}
+
+reverseAlpha(['l', 'h', 'z', 'b', 's']);
+```
+
+Dies würde den Wert `['z', 's', 'l', 'h', 'b']` zurückgeben.
+
+Die Standard-Sortiermethode von JavaScript sortiert nach dem Unicode-Punktwert eines Strings, was zu unerwarteten Ergebnissen führen kann. Daher ist es ratsam, eine Callback-Funktion bereitzustellen, die angibt, wie die Array-Elemente sortiert werden sollen. Wenn eine solche Callback-Funktion, die normalerweise `compareFunction` heißt, übergeben wird, werden die Array-Elemente nach dem Rückgabewert der `compareFunction` sortiert: Wenn `compareFunction(a,b)` für zwei Elemente `a` und `b` einen Wert kleiner als 0 zurückgibt, dann kommt `a` vor `b`. Wenn `compareFunction(a,b)` für zwei Elemente `a` und `b` einen Wert größer als 0 liefert, dann kommt `b` vor `a`. Wenn `compareFunction(a,b)` für zwei Elemente `a` und `b` einen Wert gleich 0 zurückgibt, dann bleiben `a` und `b` unverändert.
+
+# --instructions--
+
+Verwende die Methode `sort` in der Funktion `alphabeticalOrder`, um die Elemente von `arr` in alphabetischer Reihenfolge zu sortieren. Die Funktion sollte das sortierte Array zurückgeben.
+
+# --hints--
+
+Dein Code sollte die Methode `sort` verwenden.
+
+```js
+assert(code.match(/\.sort/g));
+```
+
+`alphabeticalOrder(["a", "d", "c", "a", "z", "g"])` sollte `["a", "a", "c", "d", "g", "z"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['a', 'd', 'c', 'a', 'z', 'g'])) ===
+ JSON.stringify(['a', 'a', 'c', 'd', 'g', 'z'])
+);
+```
+
+`alphabeticalOrder(["x", "h", "a", "m", "n", "m"])` sollte `["a", "h", "m", "m", "n", "x"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['x', 'h', 'a', 'm', 'n', 'm'])) ===
+ JSON.stringify(['a', 'h', 'm', 'm', 'n', 'x'])
+);
+```
+
+`alphabeticalOrder(["a", "a", "a", "a", "x", "t"])` sollte `["a", "a", "a", "a", "t", "x"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['a', 'a', 'a', 'a', 'x', 't'])) ===
+ JSON.stringify(['a', 'a', 'a', 'a', 't', 'x'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function alphabeticalOrder(arr) {
+ // Only change code below this line
+
+ return arr
+ // Only change code above this line
+}
+
+alphabeticalOrder(["a", "d", "c", "a", "z", "g"]);
+```
+
+# --solutions--
+
+```js
+function alphabeticalOrder(arr) {
+ return arr.sort();
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md
new file mode 100644
index 00000000000..afd6fb750d8
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md
@@ -0,0 +1,87 @@
+---
+id: 587d7daa367417b2b2512b6b
+title: Einen String mit der split-Methode in ein Array aufteilen
+challengeType: 1
+forumTopicId: 18305
+dashedName: split-a-string-into-an-array-using-the-split-method
+---
+
+# --description--
+
+Die Methode `split` zerlegt einen String in ein Array von Strings. Sie benötigt ein Argument für das Trennzeichen, das ein Zeichen zum Aufbrechen des Strings oder ein regulärer Ausdruck sein kann. Wenn das Begrenzungszeichen zum Beispiel ein Leerzeichen ist, erhältst du ein Array mit Wörtern, und wenn das Begrenzungszeichen ein leerer String ist, erhältst du ein Array mit jedem Zeichen des Strings.
+
+Hier sind zwei Beispiele, die einen String mit Hilfe eines regulären Ausdrucks nach Leerzeichen und einen anderen nach Ziffern aufteilen:
+
+```js
+const str = "Hello World";
+const bySpace = str.split(" ");
+
+const otherString = "How9are7you2today";
+const byDigits = otherString.split(/\d/);
+```
+
+`bySpace` würde den Wert `["Hello", "World"]` haben und `byDigits` würde den Wert `["How", "are", "you", "today"]` haben.
+
+Da Strings unveränderlich sind, macht es die Methode `split` einfacher, mit ihnen zu arbeiten.
+
+# --instructions--
+
+Verwende die Methode `split` innerhalb der Funktion `splitify`, um `str` in ein Array von Wörtern zu zerlegen. Die Funktion sollte das Array zurückgeben. Beachte, dass die Wörter nicht immer durch Leerzeichen getrennt sind und das Feld keine Satzzeichen enthalten sollte.
+
+# --hints--
+
+Dein Code sollte die Methode `split` verwenden.
+
+```js
+assert(code.match(/\.split/g));
+```
+
+`splitify("Hello World,I-am code")` sollte `["Hello", "World", "I", "am", "code"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(splitify('Hello World,I-am code')) ===
+ JSON.stringify(['Hello', 'World', 'I', 'am', 'code'])
+);
+```
+
+`splitify("Earth-is-our home")` sollte `["Earth", "is", "our", "home"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(splitify('Earth-is-our home')) ===
+ JSON.stringify(['Earth', 'is', 'our', 'home'])
+);
+```
+
+`splitify("This.is.a-sentence")` sollte `["This", "is", "a", "sentence"]` zurückgeben.
+
+```js
+assert(
+ JSON.stringify(splitify('This.is.a-sentence')) ===
+ JSON.stringify(['This', 'is', 'a', 'sentence'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function splitify(str) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+splitify("Hello World,I-am code");
+```
+
+# --solutions--
+
+```js
+function splitify(str) {
+ return str.split(/\W/);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md
new file mode 100644
index 00000000000..cb114d470e1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md
@@ -0,0 +1,112 @@
+---
+id: 587d7b8e367417b2b2512b5c
+title: Die Terminologie der funktionalen Programmierung verstehen
+challengeType: 1
+forumTopicId: 301240
+dashedName: understand-functional-programming-terminology
+---
+
+# --description--
+
+Das FCC-Team hatte einen Stimmungswandel und will jetzt zwei Sorten Tee: grünen und schwarzen Tee. Allgemeiner Fakt: Stimmungsschwankungen bei Kunden sind ziemlich normal.
+
+Mit diesen Informationen müssen wir die Funktion `getTea` aus der letzten Aufgabe wieder aufgreifen, um verschiedene Teeanfragen zu bearbeiten. Wir können `getTea` so abändern, dass es eine Funktion als Parameter akzeptiert, um die Art des Tees zu ändern, den es zubereitet. Das macht `getTea` flexibler und gibt dem Programmierer mehr Kontrolle, wenn sich die Kundenanforderungen ändern.
+
+Aber zuerst wollen wir ein paar funktionale Begriffe klären:
+
+Callbacks sind die Funktionen, die in eine andere Funktion eingeschleust oder übergeben werden, um den Aufruf dieser Funktion zu bestimmen. Du hast sie vielleicht schon an andere Methoden weitergegeben, zum Beispiel in `filter`. Die Callback-Funktion teilt JavaScript die Kriterien mit, nach denen ein Array gefiltert werden soll.
+
+Funktionen, die einer Variablen zugewiesen, an eine andere Funktion übergeben oder von einer anderen Funktion zurückgegeben werden können, werden Funktionen erster Klasse genannt. Alle Funktionen in JavaScript sind Funktionen erster Klasse.
+
+Die Funktionen, die eine Funktion als Argument nehmen oder eine Funktion als Rückgabewert zurückgeben, werden Funktionen höherer Ordnung genannt.
+
+Wenn Funktionen an eine andere Funktion übergeben oder von einer anderen Funktion zurückgegeben werden, dann können die übergebenen oder zurückgegebenen Funktionen als Lambda bezeichnet werden.
+
+# --instructions--
+
+Bereite 27 Tassen grünen Tee und 13 Tassen schwarzen Tee zu und speichere sie in den Variablen `tea4GreenTeamFCC` und `tea4BlackTeamFCC`. Beachte, dass die Funktion `getTea` geändert wurde, so dass sie jetzt eine Funktion als erstes Argument nimmt.
+
+Hinweis: Die Daten (die Anzahl der Tassen Tee) werden als letztes Argument angegeben. Wir werden das in späteren Lektionen genauer besprechen.
+
+# --hints--
+
+Die Variable `tea4GreenTeamFCC` sollte 27 Tassen grünen Tee für das Team enthalten.
+
+```js
+assert(tea4GreenTeamFCC.length === 27);
+```
+
+Die Variable `tea4GreenTeamFCC` sollte Tassen mit grünem Tee enthalten.
+
+```js
+assert(tea4GreenTeamFCC[0] === 'greenTea');
+```
+
+Die Variable `tea4BlackTeamFCC` sollte 13 Tassen schwarzen Tee enthalten.
+
+```js
+assert(tea4BlackTeamFCC.length === 13);
+```
+
+Die Variable `tea4BlackTeamFCC` sollte Tassen mit schwarzem Tee enthalten.
+
+```js
+assert(tea4BlackTeamFCC[0] === 'blackTea');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Function that returns a string representing a cup of green tea
+const prepareGreenTea = () => 'greenTea';
+
+// Function that returns a string representing a cup of black tea
+const prepareBlackTea = () => 'blackTea';
+
+/*
+Given a function (representing the tea type) and number of cups needed, the
+following function returns an array of strings (each representing a cup of
+a specific type of tea).
+*/
+const getTea = (prepareTea, numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+// Only change code below this line
+const tea4GreenTeamFCC = null;
+const tea4BlackTeamFCC = null;
+// Only change code above this line
+
+console.log(
+ tea4GreenTeamFCC,
+ tea4BlackTeamFCC
+);
+```
+
+# --solutions--
+
+```js
+const prepareGreenTea = () => 'greenTea';
+const prepareBlackTea = () => 'blackTea';
+
+const getTea = (prepareTea, numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+const tea4BlackTeamFCC = getTea(prepareBlackTea, 13);
+const tea4GreenTeamFCC = getTea(prepareGreenTea, 27);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md
new file mode 100644
index 00000000000..469b344604e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md
@@ -0,0 +1,139 @@
+---
+id: 587d7b8e367417b2b2512b5d
+title: Verstehe die Gefahren der Verwendung von imperativem Code
+challengeType: 1
+forumTopicId: 301241
+dashedName: understand-the-hazards-of-using-imperative-code
+---
+
+# --description--
+
+Funktionale Programmierung ist eine gute Angewohnheit. So bleibt dein Code einfach zu verwalten und du bist vor heimlichen Fehlern geschützt. Aber bevor wir dazu kommen, lass uns einen Blick auf einen imperativen Ansatz zur Programmierung werfen, um aufzuzeigen, wo du Probleme haben könntest.
+
+Im Englischen (und in vielen anderen Sprachen) wird der Imperativ verwendet, um Befehle zu erteilen. Ähnlich verhält es sich mit einem imperativen Programmierstil, der dem Computer eine Reihe von Anweisungen zur Ausführung einer Aufgabe gibt.
+
+Oftmals ändern die Anweisungen den Zustand des Programms, wie z. B. das Aktualisieren von globalen Variablen. Ein klassisches Beispiel ist das Schreiben einer `for`-Schleife, die genaue Anweisungen für die Iteration über die Indizes eines Arrays gibt.
+
+Im Gegensatz dazu ist die funktionale Programmierung eine Form der deklarativen Programmierung. Du teilst dem Computer mit, was du tun willst, indem du eine Methode oder Funktion aufrufst.
+
+JavaScript bietet viele vordefinierte Methoden für gängige Aufgaben, so dass du nicht schreiben musst, wie der Computer sie ausführen soll. Anstatt die oben erwähnte `for`-Schleife zu verwenden, könntest du zum Beispiel die `map`-Methode aufrufen, die die Details der Iteration über ein Array behandelt. Das hilft, semantische Fehler zu vermeiden, wie die "Off By One Error", die im Abschnitt Debugging behandelt wurden.
+
+Stell dir folgendes Szenario vor: Du surfst in deinem Browser im Internet und möchtest die von dir geöffneten Tabs verfolgen. Versuchen wir, dies mit einem einfachen objektorientierten Code zu modellieren.
+
+Ein Fensterobjekt besteht aus Registerkarten, und normalerweise hast du mehr als ein Fenster geöffnet. Die Titel der einzelnen geöffneten Seiten in jedem Window-Objekt werden in einem Array gespeichert. Nach der Arbeit im Browser (Öffnen neuer Tabs, Zusammenführen von Fenstern und Schließen von Tabs) möchtest du die noch offenen Tabs ausgeben. Geschlossene Tabs werden aus dem Array entfernt und neue Tabs werden (der Einfachheit halber) am Ende des Arrays hinzugefügt.
+
+Der Code-Editor zeigt eine Implementierung dieser Funktionalität mit Funktionen für `tabOpen()`, `tabClose()` und `join()`. Das Array `tabs` ist Teil des Window-Objekts und speichert die Namen der geöffneten Seiten.
+
+# --instructions--
+
+Überprüfe den Code im Editor. Es wird eine Methode verwendet, die Nebenwirkungen im Programm hat und ein falsches Verhalten verursacht. Die endgültige Liste der geöffneten Tabs, die in `finalTabs.tabs` gespeichert wird, sollte `['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']` sein, aber die Liste, die der Code erzeugt, ist etwas anders.
+
+Ändere `Window.prototype.tabClose` so, dass es die richtige Registerkarte entfernt.
+
+# --hints--
+
+`finalTabs.tabs` sollte wie folgt aussehen: `['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']`
+
+```js
+assert.deepEqual(finalTabs.tabs, [
+ 'FB',
+ 'Gitter',
+ 'Reddit',
+ 'Twitter',
+ 'Medium',
+ 'new tab',
+ 'Netflix',
+ 'YouTube',
+ 'Vine',
+ 'GMail',
+ 'Work mail',
+ 'Docs',
+ 'freeCodeCamp',
+ 'new tab'
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// tabs is an array of titles of each site open within the window
+const Window = function(tabs) {
+ this.tabs = tabs; // We keep a record of the array inside the object
+};
+
+// When you join two windows into one window
+Window.prototype.join = function(otherWindow) {
+ this.tabs = this.tabs.concat(otherWindow.tabs);
+ return this;
+};
+
+// When you open a new tab at the end
+Window.prototype.tabOpen = function(tab) {
+ this.tabs.push('new tab'); // Let's open a new tab for now
+ return this;
+};
+
+// When you close a tab
+Window.prototype.tabClose = function(index) {
+
+ // Only change code below this line
+
+ const tabsBeforeIndex = this.tabs.splice(0, index); // Get the tabs before the tab
+ const tabsAfterIndex = this.tabs.splice(index + 1); // Get the tabs after the tab
+
+ this.tabs = tabsBeforeIndex.concat(tabsAfterIndex); // Join them together
+
+ // Only change code above this line
+
+ return this;
+ };
+
+// Let's create three browser windows
+const workWindow = new Window(['GMail', 'Inbox', 'Work mail', 'Docs', 'freeCodeCamp']); // Your mailbox, drive, and other work sites
+const socialWindow = new Window(['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium']); // Social sites
+const videoWindow = new Window(['Netflix', 'YouTube', 'Vimeo', 'Vine']); // Entertainment sites
+
+// Now perform the tab opening, closing, and other operations
+const finalTabs = socialWindow
+ .tabOpen() // Open a new tab for cat memes
+ .join(videoWindow.tabClose(2)) // Close third tab in video window, and join
+ .join(workWindow.tabClose(1).tabOpen());
+console.log(finalTabs.tabs);
+```
+
+# --solutions--
+
+```js
+const Window = function(tabs) {
+ this.tabs = tabs;
+};
+
+Window.prototype.join = function(otherWindow) {
+ this.tabs = this.tabs.concat(otherWindow.tabs);
+ return this;
+};
+
+Window.prototype.tabOpen = function(tab) {
+ this.tabs.push('new tab');
+ return this;
+};
+
+Window.prototype.tabClose = function(index) {
+ const tabsBeforeIndex = this.tabs.slice(0, index);
+ const tabsAfterIndex = this.tabs.slice(index + 1);
+
+ this.tabs = tabsBeforeIndex.concat(tabsAfterIndex);
+ return this;
+ };
+
+const workWindow = new Window(['GMail', 'Inbox', 'Work mail', 'Docs', 'freeCodeCamp']);
+const socialWindow = new Window(['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium']);
+const videoWindow = new Window(['Netflix', 'YouTube', 'Vimeo', 'Vine']);
+
+const finalTabs = socialWindow
+ .tabOpen()
+ .join(videoWindow.tabClose(2))
+ .join(workWindow.tabClose(1).tabOpen());
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
new file mode 100644
index 00000000000..f8b4d4f074d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b88367417b2b2512b45
+title: 'Verwende Funktionen höherer Ordnung map, filter oder reduce, um ein komplexes Problem zu lösen'
+challengeType: 1
+forumTopicId: 301311
+dashedName: use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem
+---
+
+# --description--
+
+Nachdem du nun ein paar Aufgaben mit Funktionen höherer Ordnung wie `map()`, `filter()` und `reduce()` gelöst hast, kannst du sie jetzt anwenden, um eine komplexere Aufgabe zu lösen.
+
+# --instructions--
+
+Vervollständige den Code für die Funktion `squareList` mit einer beliebigen Kombination aus `map()`, `filter()` und `reduce()`. Die Funktion sollte ein neues Array zurückgeben, das die Quadratzahlen *nur* von den positiven ganzen Zahlen enthält (Dezimalzahlen sind keine ganzen Zahlen), wenn ihr ein Array mit reellen Zahlen übergeben wird. Ein Beispiel für ein Array mit reellen Zahlen ist `[-3, 4.8, 5, 3, -3.2]`.
+
+**Hinweis:** Deine Funktion sollte weder `for` noch `while`-Schleifen oder die Funktion `forEach()` verwenden.
+
+# --hints--
+
+`squareList` sollte eine Funktion (`function`) sein.
+
+```js
+assert.typeOf(squareList, 'function'),
+ 'squareList should be a function';
+```
+
+`for`, `while` und `forEach` sollten nicht verwendet werden.
+
+```js
+assert(!code.match(/for|while|forEach/g));
+```
+
+`map`, `filter` oder `reduce` sollten verwendet werden.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.(map|filter|reduce)\(/g)
+);
+```
+
+Die Funktion sollte ein `array` zurückgeben.
+
+```js
+assert(Array.isArray(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])));
+```
+
+`squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])` sollte `[16, 1764, 36]` zurückgeben.
+
+```js
+assert.deepStrictEqual(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2]), [
+ 16,
+ 1764,
+ 36
+]);
+```
+
+`squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3])` sollte `[9, 100, 49]` zurückgeben.
+
+```js
+assert.deepStrictEqual(squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3]), [
+ 9,
+ 100,
+ 49
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const squareList = arr => {
+ // Only change code below this line
+ return arr;
+ // Only change code above this line
+};
+
+const squaredIntegers = squareList([-3, 4.8, 5, 3, -3.2]);
+console.log(squaredIntegers);
+```
+
+# --solutions--
+
+```js
+const squareList = arr => {
+ const positiveIntegers = arr.filter(num => {
+ return num >= 0 && Number.isInteger(num);
+ });
+ const squaredIntegers = positiveIntegers.map(num => {
+ return num ** 2;
+ });
+ return squaredIntegers;
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md
new file mode 100644
index 00000000000..4133a1625ae
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md
@@ -0,0 +1,76 @@
+---
+id: 587d7dab367417b2b2512b6e
+title: Prüfe mit der Methode every, ob jedes Element in einem Array ein Kriterium erfüllt
+challengeType: 1
+forumTopicId: 301312
+dashedName: use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria
+---
+
+# --description--
+
+Die Methode `every` arbeitet mit Arrays, um zu prüfen, ob *jedes* Element einen bestimmten Test besteht. Sie gibt einen booleschen Wert zurück - `true`, wenn alle Werte die Kriterien erfüllen, `false`, wenn nicht.
+
+Der folgende Code würde zum Beispiel prüfen, ob jedes Element im Array `numbers` kleiner als 10 ist:
+
+```js
+const numbers = [1, 5, 8, 0, 10, 11];
+
+numbers.every(function(currentValue) {
+ return currentValue < 10;
+});
+```
+
+Die Methode `every` würde hier `false` zurückgeben.
+
+# --instructions--
+
+Verwende die Methode `every` innerhalb der Funktion `checkPositive`, um zu prüfen, ob jedes Element in `arr` positiv ist. Die Funktion sollte einen booleschen Wert zurückgeben.
+
+# --hints--
+
+Dein Code sollte die Methode `every` verwenden.
+
+```js
+assert(code.match(/\.every/g));
+```
+
+`checkPositive([1, 2, 3, -4, 5])` sollte `false` zurückgeben.
+
+```js
+assert.isFalse(checkPositive([1, 2, 3, -4, 5]));
+```
+
+`checkPositive([1, 2, 3, 4, 5])` sollte `true` zurückgeben.
+
+```js
+assert.isTrue(checkPositive([1, 2, 3, 4, 5]));
+```
+
+`checkPositive([1, -2, 3, -4, 5])` sollte `false` zurückgeben.
+
+```js
+assert.isFalse(checkPositive([1, -2, 3, -4, 5]));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+checkPositive([1, 2, 3, -4, 5]);
+```
+
+# --solutions--
+
+```js
+function checkPositive(arr) {
+ return arr.every(num => num > 0);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md
new file mode 100644
index 00000000000..c43a8c24e42
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md
@@ -0,0 +1,314 @@
+---
+id: 587d7b8f367417b2b2512b63
+title: Verwende die Filtermethode, um Daten aus einem Array zu extrahieren
+challengeType: 1
+forumTopicId: 18179
+dashedName: use-the-filter-method-to-extract-data-from-an-array
+---
+
+# --description--
+
+Eine weitere nützliche Array-Funktion ist `Array.prototype.filter()`, oder einfach `filter()`.
+
+`filter` ruft eine Funktion für jedes Element eines Arrays auf und gibt ein neues Array zurück, das nur die Elemente enthält, für die die Funktion `true` zurückgibt. Mit anderen Worten: Sie filtert das Array auf der Grundlage der übergebenen Funktion. Genau wie `map` macht sie das, ohne dass das ursprüngliche Array verändert werden muss.
+
+Die Callback-Funktion nimmt drei Argumente entgegen. Das erste Argument ist das aktuelle Element, das bearbeitet wird. Das zweite ist der Index dieses Elements und das dritte ist das Array, auf dem die Methode `filter` aufgerufen wurde.
+
+Unten findest du ein Beispiel, in dem du die Methode `filter` auf das Array `users` anwendest, um ein neues Array zu erstellen, das nur die Benutzer unter 30 Jahren enthält. Der Einfachheit halber wird im Beispiel nur das erste Argument des Callbacks verwendet.
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const usersUnder30 = users.filter(user => user.age < 30);
+console.log(usersUnder30);
+```
+
+Die Konsole würde den Wert `[ { name: 'Amy', age: 20 }, { name: 'camperCat', age: 10 } ]` anzeigen.
+
+# --instructions--
+
+Die Variable `watchList` enthält ein Array von Objekten mit Informationen über verschiedene Filme. Wende eine Kombination aus `filter` und `map` auf `watchList` an, um ein neues Array von Objekten nur mit den Keys `title` und `rating` zuzuweisen. Das neue Array sollte nur Objekte enthalten, deren `imdbRating` größer oder gleich 8.0 ist. Beachte, dass die `rating`-Werte als Strings im Objekt gespeichert werden und du sie eventuell in Zahlen umwandeln musst, um mathematische Operationen mit ihnen durchzuführen.
+
+# --hints--
+
+Die Variable `watchList` sollte sich nicht ändern.
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+Dein Code sollte die Methode `filter` verwenden.
+
+```js
+assert(code.match(/\s*\.\s*filter/g));
+```
+
+Dein Code sollte keine `for`-Schleife verwenden.
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/g));
+```
+
+`filteredList` sollt gleich `[{"title": "Inception", "rating": "8.8"}, {"title": "Interstellar", "rating": "8.6"}, {"title": "The Dark Knight", "rating": "9.0"}, {"title": "Batman Begins", "rating": "8.3"}]` sein.
+
+```js
+assert.deepEqual(filteredList, [
+ { title: 'Inception', rating: '8.8' },
+ { title: 'Interstellar', rating: '8.6' },
+ { title: 'The Dark Knight', rating: '9.0' },
+ { title: 'Batman Begins', rating: '8.3' }
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+// Only change code below this line
+
+const filteredList = "";
+
+// Only change code above this line
+
+console.log(filteredList);
+```
+
+# --solutions--
+
+```js
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+const filteredList = watchList.filter(e => e.imdbRating >= 8).map( ({Title: title, imdbRating: rating}) => ({title, rating}) );
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md
new file mode 100644
index 00000000000..2c1f2855785
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md
@@ -0,0 +1,329 @@
+---
+id: 587d7b8f367417b2b2512b61
+title: Verwende die map-Methode, um Daten aus einem Array zu extrahieren
+challengeType: 1
+forumTopicId: 18214
+dashedName: use-the-map-method-to-extract-data-from-an-array
+---
+
+# --description--
+
+Bis jetzt haben wir gelernt, reine Funktionen zu verwenden, um Nebeneffekte in einem Programm zu vermeiden. Außerdem haben wir gesehen, wie wichtig es ist, dass eine Funktion nur von ihren Eingabeargumenten abhängt.
+
+Das ist erst der Anfang. Wie der Name schon sagt, geht es bei der funktionalen Programmierung um eine Theorie der Funktionen.
+
+Es wäre sinnvoll, sie als Argumente an andere Funktionen zu übergeben und eine Funktion von einer anderen Funktion zurückzugeben. Funktionen gelten in JavaScript als Objekte erster Klasse , d. h. sie können wie jedes andere Objekt verwendet werden. Sie können in Variablen gespeichert, in einem Objekt abgelegt oder als Funktionsargumente übergeben werden.
+
+Beginnen wir mit einigen einfachen Array-Funktionen, die Methoden für den Prototyp des Array-Objekts sind. In dieser Übung schauen wir uns `Array.prototype.map()` an, oder einfacher `map`.
+
+Die Methode `map` durchläuft jedes Element in einem Array und gibt ein neues Array zurück, das die Ergebnisse des Aufrufs der Callback-Funktion für jedes Element enthält. Dies geschieht, ohne dass das ursprüngliche Array verändert wird.
+
+Wenn der Callback verwendet wird, werden ihm drei Argumente übergeben. Das erste Argument ist das aktuelle Element, das bearbeitet wird. Das zweite ist der Index dieses Elements und das dritte ist das Array, auf dem die Methode `map` aufgerufen wurde.
+
+Unten findest du ein Beispiel, in dem du die Methode `map` auf das Array `users` anwendest, um ein neues Array zu erstellen, das nur die Namen der Benutzer als Elemente enthält. Der Einfachheit halber wird im Beispiel nur das erste Argument des Callbacks verwendet.
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const names = users.map(user => user.name);
+console.log(names);
+```
+
+Die Konsole würde den Wert `[ 'John', 'Amy', 'camperCat' ]` ausgeben.
+
+# --instructions--
+
+Das Array `watchList` enthält Objekte mit Informationen über verschiedene Filme. Verwende `map` auf `watchList`, um der Variablen `ratings` ein neues Array von Objekten zuzuweisen. Jeder Film im neuen Array sollte nur einen Key `title` mit dem Namen des Films und einen Key `rating` mit der IMDB-Bewertung besitzen. Der Code im Editor verwendet dafür eine `for`-Schleife. Du solltest also die Schleifenfunktion durch deinen `map`-Ausdruck ersetzen.
+
+# --hints--
+
+Die Variable `watchList` sollte sich nicht ändern.
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+Dein Code sollte keine `for`-Schleife verwenden.
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/));
+```
+
+Dein Code sollte die Methode `map` verwenden.
+
+```js
+assert(code.match(/\.map/g));
+```
+
+`ratings` sollte gleich `[{"title": "Inception", "rating": "8.8"}, {"title": "Interstellar", "rating": "8.6"}, {"title": "The Dark Knight", "rating": "9.0"},{"title": "Batman Begins", "rating": "8.3"}, {"title": "Avatar", "rating": "7.9"}]` sein.
+
+```js
+assert.deepEqual(ratings, [
+ { title: 'Inception', rating: '8.8' },
+ { title: 'Interstellar', rating: '8.6' },
+ { title: 'The Dark Knight', rating: '9.0' },
+ { title: 'Batman Begins', rating: '8.3' },
+ { title: 'Avatar', rating: '7.9' }
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+// Only change code below this line
+
+const ratings = [];
+for (let i = 0; i < watchList.length; i++) {
+ ratings.push({title: watchList[i]["Title"], rating: watchList[i]["imdbRating"]});
+}
+
+// Only change code above this line
+
+console.log(JSON.stringify(ratings));
+```
+
+# --solutions--
+
+```js
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+const ratings = watchList.map(function(movie) {
+ return {
+ title: movie["Title"],
+ rating: movie["imdbRating"]
+ }
+});
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md
new file mode 100644
index 00000000000..843e5d04d7d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md
@@ -0,0 +1,345 @@
+---
+id: 587d7da9367417b2b2512b68
+title: Verwende die Methode reduce, um Daten zu analysieren
+challengeType: 1
+forumTopicId: 301313
+dashedName: use-the-reduce-method-to-analyze-data
+---
+
+# --description--
+
+`Array.prototype.reduce()`, oder einfach `reduce()`, ist die allgemeinste aller Array-Operationen in JavaScript. Du kannst fast jedes Problem bei der Verarbeitung von Arrays mit der Methode `reduce` lösen.
+
+Die Methode `reduce` ermöglicht allgemeinere Formen der Array-Verarbeitung und es ist möglich zu zeigen, dass sowohl `filter` als auch `map` als spezielle Anwendungen von `reduce` abgeleitet werden können. Die Methode `reduce` iteriert über jedes Element in einem Array und gibt einen einzelnen Wert zurück (z.B. String, Zahl, Objekt, Array). Dies wird über eine Callback-Funktion erreicht, die bei jeder Iteration aufgerufen wird.
+
+Die Callback-Funktion nimmt vier Argumente entgegen. Das erste Argument ist der Akkumulator, dem der Rückgabewert der Callback-Funktion aus der vorherigen Iteration zugewiesen wird, das zweite ist das aktuell verarbeitete Element, das dritte ist der Index dieses Elements und das vierte ist das Array, auf dem `reduce` aufgerufen wird.
+
+Neben der Callback-Funktion hat `reduce` einen zusätzlichen Parameter, der einen Anfangswert für den Akkumulator annimmt. Wenn dieser zweite Parameter nicht verwendet wird, wird die erste Iteration übersprungen und der zweiten Iteration wird das erste Element des Arrays als Akkumulator übergeben.
+
+Unten findest du ein Beispiel, in dem du `reduce` auf das Array `users` anwendest, um die Summe der Altersangaben aller Benutzer zu erhalten. Der Einfachheit halber werden im Beispiel nur das erste und zweite Argument verwendet.
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const sumOfAges = users.reduce((sum, user) => sum + user.age, 0);
+console.log(sumOfAges);
+```
+
+Die Konsole würde den Wert `64` ausgeben.
+
+In einem anderen Beispiel kannst du sehen, wie ein Objekt zurückgegeben werden kann, das die Namen der Benutzer als Eigenschaften und ihr Alter als Werte enthält.
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const usersObj = users.reduce((obj, user) => {
+ obj[user.name] = user.age;
+ return obj;
+}, {});
+console.log(usersObj);
+```
+
+Die Konsole würde den Wert `{ John: 34, Amy: 20, camperCat: 10 }` anzeigen.
+
+# --instructions--
+
+Die Variable `watchList` enthält ein Array von Objekten mit Informationen über verschiedene Filme. Verwende `reduce`, um die durchschnittliche IMDB-Bewertung der Filme zu finden, bei denen `Christopher Nolan` Regie geführt hat. Du hast bereits in den vergangenen Aufgaben gelernt, wie man Daten mit `filter` und `map` filtert und zuordnet. Du musst eventuell andere Variablen erstellen und die durchschnittliche Bewertung von der Funktion `getRating` zurückgeben. Beachte, dass die Ratingwerte als Strings im Objekt gespeichert werden und in Zahlen umgewandelt werden müssen, bevor sie in mathematischen Operationen verwendet werden.
+
+# --hints--
+
+Die Variable `watchList` sollte sich nicht ändern.
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+Dein Code sollte die Methode `reduce` verwenden.
+
+```js
+assert(code.match(/\.reduce/g));
+```
+
+`getRating(watchList)` sollte gleich 8,675 sein.
+
+```js
+assert(getRating(watchList) === 8.675);
+```
+
+Dein Code sollte keine `for`-Schleife verwenden.
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/g));
+```
+
+Dein Code sollte die richtige Ausgabe zurückgeben, nachdem du das Objekt `watchList` geändert hast.
+
+```js
+assert(getRating(watchList.filter((_, i) => i < 1 || i > 2)) === 8.55);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+function getRating(watchList) {
+ // Only change code below this line
+ let averageRating;
+
+
+ // Only change code above this line
+ return averageRating;
+}
+
+console.log(getRating(watchList));
+```
+
+# --solutions--
+
+```js
+const watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+function getRating(watchList) {
+ let averageRating;
+ const rating = watchList
+ .filter(obj => obj.Director === "Christopher Nolan")
+ .map(obj => Number(obj.imdbRating));
+ averageRating = rating.reduce((accum, curr) => accum + curr)/rating.length;
+ return averageRating;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md
new file mode 100644
index 00000000000..3bc876f68b2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md
@@ -0,0 +1,76 @@
+---
+id: 587d7dab367417b2b2512b6f
+title: Verwende die Methode some, um zu prüfen, ob ein Element in einem Array ein Kriterium erfüllt
+challengeType: 1
+forumTopicId: 301314
+dashedName: use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria
+---
+
+# --description--
+
+Die Methode `some` arbeitet mit Arrays, um zu prüfen, ob *ein* Element einen bestimmten Test besteht. Sie gibt einen booleschen Wert zurück - `true`, wenn einer der Werte die Kriterien erfüllt, `false`, wenn nicht.
+
+Der folgende Code würde zum Beispiel prüfen, ob ein Element im Array `numbers` kleiner als 10 ist:
+
+```js
+const numbers = [10, 50, 8, 220, 110, 11];
+
+numbers.some(function(currentValue) {
+ return currentValue < 10;
+});
+```
+
+Die Methode `some` würde `true` zurückgeben.
+
+# --instructions--
+
+Verwende die Methode `some` innerhalb der Funktion `checkPositive`, um zu prüfen, ob ein Element in `arr` positiv ist. Die Funktion sollte einen booleschen Wert zurückgeben.
+
+# --hints--
+
+Dein Code sollte die Methode `some` verwenden.
+
+```js
+assert(code.match(/\.some/g));
+```
+
+`checkPositive([1, 2, 3, -4, 5])` sollte `true` zurückgeben.
+
+```js
+assert(checkPositive([1, 2, 3, -4, 5]));
+```
+
+`checkPositive([1, 2, 3, 4, 5])` sollte `true` zurückgeben.
+
+```js
+assert(checkPositive([1, 2, 3, 4, 5]));
+```
+
+`checkPositive([-1, -2, -3, -4, -5])` sollte `false` zurückgeben.
+
+```js
+assert(!checkPositive([-1, -2, -3, -4, -5]));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+
+checkPositive([1, 2, 3, -4, 5]);
+```
+
+# --solutions--
+
+```js
+function checkPositive(arr) {
+ return arr.some(elem => elem > 0);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
new file mode 100644
index 00000000000..1be41c7bfed
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
@@ -0,0 +1,103 @@
+---
+id: a97fd23d9b809dac9921074f
+title: Optionale Argumente
+challengeType: 1
+forumTopicId: 14271
+dashedName: arguments-optional
+---
+
+# --description--
+
+Erstelle eine Funktion, die zwei Argumente summiert. Wenn nur ein Argument angegeben wird, dann gib eine Funktion zurück, die ein Argument erwartet und die Summe zurückgibt.
+
+Zum Beispiel sollte `addTogether(2, 3)` `5` zurückgeben, und `addTogether(2)` sollte eine Funktion zurückgeben.
+
+Wenn du diese Funktion mit einem einzigen Argument aufrufst, erhältst du die Summe zurück:
+
+```js
+var sumTwoAnd = addTogether(2);
+```
+
+`sumTwoAnd(3)` liefert `5`.
+
+Wenn eines der beiden Argumente keine gültige Zahl ist, wird undefined zurückgegeben.
+
+# --hints--
+
+`addTogether(2, 3)` sollte 5 zurückgeben.
+
+```js
+assert.deepEqual(addTogether(2, 3), 5);
+```
+
+`addTogether(23, 30)` sollte 53 zurückgeben.
+
+```js
+assert.deepEqual(addTogether(23, 30), 53);
+```
+
+`addTogether(5)(7)` sollte 12 zurückgeben.
+
+```js
+assert.deepEqual(addTogether(5)(7), 12);
+```
+
+`addTogether("https://www.youtube.com/watch?v=dQw4w9WgXcQ")` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(addTogether('https://www.youtube.com/watch?v=dQw4w9WgXcQ'));
+```
+
+`addTogether(2, "3")` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(addTogether(2, '3'));
+```
+
+`addTogether(2)([3])` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(addTogether(2)([3]));
+```
+
+`addTogether("2", 3)` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(addTogether('2', 3));
+```
+
+`addTogether(5, undefined)` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(addTogether(5, undefined));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function addTogether() {
+ return false;
+}
+
+addTogether(2,3);
+```
+
+# --solutions--
+
+```js
+function addTogether() {
+ var a = arguments[0];
+ if (toString.call(a) !== '[object Number]') return;
+ if (arguments.length === 1) {
+ return function(b) {
+ if (toString.call(b) !== '[object Number]') return;
+ return a + b;
+ };
+ }
+ var b = arguments[1];
+ if (toString.call(b) !== '[object Number]') return;
+ return a + arguments[1];
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
new file mode 100644
index 00000000000..c4a58b396de
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
@@ -0,0 +1,57 @@
+---
+id: a8d97bd4c764e91f9d2bda01
+title: Binäre Agenten
+challengeType: 1
+forumTopicId: 14273
+dashedName: binary-agents
+---
+
+# --description--
+
+Gibt einen übersetzten englischen Satz des übergebenen Binär-Strings zurück.
+
+Der Binär-String wird durch Leerzeichen getrennt.
+
+# --hints--
+
+`binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")` soll den String `Aren't bonfires fun!?` ausgeben
+
+```js
+assert.deepEqual(
+ binaryAgent(
+ '01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111'
+ ),
+ "Aren't bonfires fun!?"
+);
+```
+
+`binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")` soll den String `I love FreeCodeCamp!` ausgeben
+
+```js
+assert.deepEqual(
+ binaryAgent(
+ '01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001'
+ ),
+ 'I love FreeCodeCamp!'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function binaryAgent(str) {
+ return str;
+}
+
+binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
+```
+
+# --solutions--
+
+```js
+function binaryAgent(str) {
+ return str.split(' ').map(function(s) { return parseInt(s, 2); }).map(function(b) { return String.fromCharCode(b);}).join('');
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md
new file mode 100644
index 00000000000..059ef36cd37
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md
@@ -0,0 +1,89 @@
+---
+id: a6b0bb188d873cb2c8729495
+title: HTML-Entitäten konvertieren
+challengeType: 1
+forumTopicId: 16007
+dashedName: convert-html-entities
+---
+
+# --description--
+
+Konvertiere die Zeichen `&`, `<`, `>`, `"` (Anführungszeichen) und `'` (Apostroph) in einem String in ihre entsprechenden HTML-Entitäten.
+
+# --hints--
+
+`convertHTML("Dolce & Gabbana")` sollte den String `Dolce & Gabbana` zurückgeben.
+
+```js
+assert.match(convertHTML('Dolce & Gabbana'), /Dolce & Gabbana/);
+```
+
+`convertHTML("Hamburgers < Pizza < Tacos")` sollte den String `Hamburgers < Pizza < Tacos` zurückgeben.
+
+```js
+assert.match(
+ convertHTML('Hamburgers < Pizza < Tacos'),
+ /Hamburgers < Pizza < Tacos/
+);
+```
+
+`convertHTML("Sixty > twelve")` sollte den String `Sixty > twelve` zurückgeben.
+
+```js
+assert.match(convertHTML('Sixty > twelve'), /Sixty > twelve/);
+```
+
+`convertHTML('Stuff in "quotation marks"')` sollte den String `Stuff in "quotation marks"` zurückgeben.
+
+```js
+assert.match(
+ convertHTML('Stuff in "quotation marks"'),
+ /Stuff in "quotation marks"/
+);
+```
+
+`convertHTML("Schindler's List")` sollte den String `Schindler's List` zurückgeben.
+
+```js
+assert.match(convertHTML("Schindler's List"), /Schindler's List/);
+```
+
+`convertHTML("<>")` sollte den String `<>` zurückgeben.
+
+```js
+assert.match(convertHTML('<>'), /<>/);
+```
+
+`convertHTML("abc")` sollte den String `abc` zurückgeben.
+
+```js
+assert.strictEqual(convertHTML('abc'), 'abc');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertHTML(str) {
+ return str;
+}
+
+convertHTML("Dolce & Gabbana");
+```
+
+# --solutions--
+
+```js
+var MAP = { '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''};
+
+function convertHTML(str) {
+ return str.replace(/[&<>"']/g, function(c) {
+ return MAP[c];
+ });
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md
new file mode 100644
index 00000000000..cb8acbdc179
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md
@@ -0,0 +1,189 @@
+---
+id: a5de63ebea8dbee56860f4f2
+title: Differenz von zwei Arrays
+challengeType: 1
+forumTopicId: 16008
+dashedName: diff-two-arrays
+---
+
+# --description--
+
+Vergleicht zwei Arrays und gibt ein neues Array zurück, das alle Elemente enthält, die nur in einem der beiden gegebenen Arrays gefunden wurden, aber nicht in beiden. Mit anderen Worten: Gib die symmetrische Differenz der beiden Arrays zurück.
+
+**Hinweis:** Du kannst das Array mit seinen Elementen in beliebiger Reihenfolge zurückgeben.
+
+# --hints--
+
+`diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])` sollte ein Array zurückgeben.
+
+```js
+assert(typeof diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]) === 'object');
+```
+
+`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` sollte `["pink wool"]` zurückgeben.
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ ['pink wool']
+);
+```
+
+`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` sollte ein Array mit einem Element zurückgeben.
+
+```js
+assert(
+ diffArray(
+ ['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 1
+);
+```
+
+`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` sollte `["diorite", "pink wool"]` zurückgeben.
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ ['diorite', 'pink wool']
+);
+```
+
+`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` sollte ein Array mit zwei Elementen zurückgeben.
+
+```js
+assert(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 2
+);
+```
+
+`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` sollte `[]` zurückgeben.
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'dead shrub'],
+ ['andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ []
+);
+```
+
+`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` sollte ein leeres Array zurückgeben.
+
+```js
+assert(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'dead shrub'],
+ ['andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 0
+);
+```
+
+`[1, 2, 3, 5], [1, 2, 3, 4, 5]` sollte `[4]` zurückgeben.
+
+```js
+assert.sameMembers(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]), [4]);
+```
+
+`[1, 2, 3, 5], [1, 2, 3, 4, 5]` sollte ein Array mit einem Element zurückgeben.
+
+```js
+assert(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]).length === 1);
+```
+
+`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` sollte `["piglet", 4]` zurückgeben.
+
+```js
+assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]), [
+ 'piglet',
+ 4
+]);
+```
+
+`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` sollte ein Array mit zwei Elementen zurückgeben.
+
+```js
+assert(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]).length === 2);
+```
+
+`[], ["snuffleupagus", "cookie monster", "elmo"]` sollte `["snuffleupagus", "cookie monster", "elmo"]` zurückgeben.
+
+```js
+assert.sameMembers(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']), [
+ 'snuffleupagus',
+ 'cookie monster',
+ 'elmo'
+]);
+```
+
+`[], ["snuffleupagus", "cookie monster", "elmo"]` sollte ein Array mit drei Elementen zurückgeben.
+
+```js
+assert(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']).length === 3);
+```
+
+`[1, "calf", 3, "piglet"], [7, "filly"]` sollte `[1, "calf", 3, "piglet", 7, "filly"]` zurückgeben.
+
+```js
+assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']), [
+ 1,
+ 'calf',
+ 3,
+ 'piglet',
+ 7,
+ 'filly'
+]);
+```
+
+`[1, "calf", 3, "piglet"], [7, "filly"]` sollte ein Array mit sechs Elementen zurückgeben.
+
+```js
+assert(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']).length === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function diffArray(arr1, arr2) {
+ const newArr = [];
+ return newArr;
+}
+
+diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
+```
+
+# --solutions--
+
+```js
+function diffArray(arr1, arr2) {
+ const newArr = [];
+ const h1 = Object.create(null);
+ arr1.forEach(function(e) {
+ h1[e] = e;
+ });
+ const h2 = Object.create(null);
+ arr2.forEach(function(e) {
+ h2[e] = e;
+ });
+
+ Object.keys(h1).forEach(function(e) {
+ if (!(e in h2)) newArr.push(h1[e]);
+ });
+ Object.keys(h2).forEach(function(e) {
+ if (!(e in h1)) newArr.push(h2[e]);
+ });
+ return newArr;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md
new file mode 100644
index 00000000000..e2d284a66ee
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md
@@ -0,0 +1,81 @@
+---
+id: afd15382cdfb22c9efe8b7de
+title: DNA-Kopplung
+challengeType: 1
+forumTopicId: 16009
+dashedName: dna-pairing
+---
+
+# --description--
+
+DNA-Strangpaare bestehen aus Nukleobasenpaaren. Basenpaare werden durch die Zeichen AT und CG beschrieben, welche die Grundbausteine der Doppelhelix-Form der DNA darstellen.
+
+Dem gegebenen DNA-Strang fehlt das Paarungselement. Schreib eine Funktion, die einen Treffer für das fehlende Basenpaar des gegebenen DNA-Stranges findet. Für jedes Zeichen im gegeben String soll das dazu passende Basenpaar-Zeichen gefunden werden. Die Ergebnisse sollen in einem 2D-Array zurückgegeben werden.
+
+Beispielsweise soll bei der Eingabe `GCG` die Ausgabe `[["G", "C"], ["C","G"], ["G", "C"]]` zurückgegeben werden
+
+Das Zeichen wird zusammen mit dem dazugehörigen Paar in einen Array geschrieben. Anschließend werden alle Arrays in einem Array zusammengefasst.
+
+# --hints--
+
+`pairElement("ATCGA")` sollte `[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]` zurückgeben.
+
+```js
+assert.deepEqual(pairElement('ATCGA'), [
+ ['A', 'T'],
+ ['T', 'A'],
+ ['C', 'G'],
+ ['G', 'C'],
+ ['A', 'T']
+]);
+```
+
+`pairElement("TTGAG")` sollte `[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]` zurückgeben.
+
+```js
+assert.deepEqual(pairElement('TTGAG'), [
+ ['T', 'A'],
+ ['T', 'A'],
+ ['G', 'C'],
+ ['A', 'T'],
+ ['G', 'C']
+]);
+```
+
+`pairElement("CTCTA")` sollte `[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]` zurückgeben.
+
+```js
+assert.deepEqual(pairElement('CTCTA'), [
+ ['C', 'G'],
+ ['T', 'A'],
+ ['C', 'G'],
+ ['T', 'A'],
+ ['A', 'T']
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function pairElement(str) {
+ return str;
+}
+
+pairElement("GCG");
+```
+
+# --solutions--
+
+```js
+var lookup = Object.create(null);
+lookup.A = 'T';
+lookup.T = 'A';
+lookup.C = 'G';
+lookup.G = 'C';
+
+function pairElement(str) {
+ return str.split('').map(function(p) {return [p, lookup[p]];});
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md
new file mode 100644
index 00000000000..d34ce408abf
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md
@@ -0,0 +1,104 @@
+---
+id: a5deed1811a43193f9f1c841
+title: Lass es fallen
+challengeType: 1
+forumTopicId: 16010
+dashedName: drop-it
+---
+
+# --description--
+
+Wenn du das Array `arr` hast, iteriere und entferne jedes Element, beginnend mit dem ersten Element (dem Index 0), bis die Funktion `func` `true` zurückgibt, wenn das iterierte Element durchlaufen wird.
+
+Dann gib den Rest des Arrays zurück, wenn die Bedingung erfüllt ist. Ansonsten sollte `arr` als leeres Array zurückgegeben werden.
+
+# --hints--
+
+`dropElements([1, 2, 3, 4], function(n) {return n >= 3;})` sollte `[3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 4], function (n) {
+ return n >= 3;
+ }),
+ [3, 4]
+);
+```
+
+`dropElements([0, 1, 0, 1], function(n) {return n === 1;})` sollte `[1, 0, 1]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([0, 1, 0, 1], function (n) {
+ return n === 1;
+ }),
+ [1, 0, 1]
+);
+```
+
+`dropElements([1, 2, 3], function(n) {return n > 0;})` sollte `[1, 2, 3]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3], function (n) {
+ return n > 0;
+ }),
+ [1, 2, 3]
+);
+```
+
+`dropElements([1, 2, 3, 4], function(n) {return n > 5;})` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 4], function (n) {
+ return n > 5;
+ }),
+ []
+);
+```
+
+`dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})` sollte `[7, 4]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 7, 4], function (n) {
+ return n > 3;
+ }),
+ [7, 4]
+);
+```
+
+`dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})` sollte `[3, 9, 2]` zurückgeben.
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 9, 2], function (n) {
+ return n > 2;
+ }),
+ [3, 9, 2]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function dropElements(arr, func) {
+ return arr;
+}
+
+dropElements([1, 2, 3], function(n) {return n < 3; });
+```
+
+# --solutions--
+
+```js
+function dropElements(arr, func) {
+ while (arr.length && !func(arr[0])) {
+ arr.shift();
+ }
+ return arr;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
new file mode 100644
index 00000000000..3d389b31836
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
@@ -0,0 +1,158 @@
+---
+id: a10d2431ad0c6a099a4b8b52
+title: Alles wird wahr
+challengeType: 1
+forumTopicId: 16011
+dashedName: everything-be-true
+---
+
+# --description--
+
+Prüfe, ob das Prädikat (zweites Argument) auf allen Elementen einer Sammlung (erstes Argument) wahr ist.
+
+Mit anderen Worten: Du bekommst eine Array-Sammlung von Objekten. Das Prädikat `pre` wird eine Objekteigenschaft sein und du musst `true` zurückgeben, wenn sein Wert `truthy` ist. Ansonsten wird `false` zurückgegeben.
+
+`truthy`-Werte sind in JavaScript Werte, die in einem booleschen Kontext als `true` ausgewertet werden.
+
+Denke daran, dass du auf Objekteigenschaften entweder über die Punktnotation oder die `[]`-Notation zugreifen kannst.
+
+# --hints--
+
+truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: `false}, {name: "Camperbot", role: "Bot", isBot: true}], "isBot")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Quincy", role: "Founder", isBot: false },
+ { name: "Naomi", role: "", isBot: false },
+ { name: "Camperbot", role: "Bot", isBot: true }
+ ],
+ "isBot"), false);
+```
+
+truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "`Camperbot", role: "Bot", isBot: true}], "name")` sollte `true zurückgeben`.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Quincy", role: "Founder", isBot: false },
+ { name: "Naomi", role: "", isBot: false },
+ { name: "Camperbot", role: "Bot", isBot: true }
+ ],
+ "name"), true);
+```
+
+truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: `false}, {name: "Camperbot", role: "Bot", isBot: true}], "role")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Quincy", role: "Founder", isBot: false },
+ { name: "Naomi", role: "", isBot: false },
+ { name: "Camperbot", role: "Bot", isBot: true }
+ ],
+ "role"), false);
+```
+
+`truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "Togepi", number: 175, caught: 1}], "number")` sollte `true zurückgeben`.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Pikachu", number: 25, caught: 3 },
+ { name: "Togepi", number: 175, caught: 1 },
+ ],
+ "number"), true);
+```
+
+truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "`Togepi", number: 175, caught: 1}, {name: "MissingNo", number: NaN, caught: 0}], "caught")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Pikachu", number: 25, caught: 3 },
+ { name: "Togepi", number: 175, caught: 1 },
+ { name: "MissingNo", number: NaN, caught: 0 },
+ ],
+ "caught"), false);
+```
+
+`truthCheck([{name: "Pikachu", number: 25, caught: 3}, {name: "Togepi", number: 175, caught: 1}, {name: "MissingNo", number: NaN, caught: 0}], "number")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Pikachu", number: 25, caught: 3 },
+ { name: "Togepi", number: 175, caught: 1 },
+ { name: "MissingNo", number: NaN, caught: 0 },
+ ],
+ "number"), false);
+```
+
+`truthCheck([{name: "Quincy", username: "QuincyLarson"}, {name: "Naomi", username: "nhcarrigan"}, {name: "Camperbot"}], "username")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "Quincy", username: "QuincyLarson" },
+ { name: "Naomi", username: "nhcarrigan" },
+ { name: "Camperbot" }
+ ],
+ "username"), false);
+```
+
+`truthCheck([{name: "freeCodeCamp", users: [{name: "Quincy"}, {name: "Naomi"}]}, {name: "Code Radio", users: [{name: "Camperbot"}]}, {name: "", users: []}], "users")` sollte `true` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { name: "freeCodeCamp", users: [{ name: "Quincy" }, { name: "Naomi" }] },
+ { name: "Code Radio", users: [{ name: "Camperbot" }] },
+ { name: "", users: [] },
+ ],
+ "users"), true);
+```
+
+`truthCheck([{id: 1, data: {url: "https://freecodecamp.org", name: "freeCodeCamp"}}, {id: 2, data: {url: "https://coderadio.freecodecamp.org/", name: "CodeRadio"}}, {id: null, data: {}}], "data")` sollte `true` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { id: 1, data: { url: "https://www.freecodecamp.org", name: "freeCodeCamp" } },
+ { id: 2, data: { url: "https://coderadio.freecodecamp.org/", name: "CodeRadio" } },
+ { id: null, data: {} },
+ ],
+ "data"), true);
+```
+
+`truthCheck([{id: 1, data: {url: "https://freecodecamp.org", name: "freeCodeCamp"}}, {id: 2, data: {url: "https://coderadio.freecodecamp.org/", name: "CodeRadio"}}, {id: null, data: {}}], "id")` sollte `false` zurückgeben.
+
+```js
+assert.strictEqual(truthCheck(
+ [
+ { id: 1, data: { url: "https://www.freecodecamp.org", name: "freeCodeCamp" } },
+ { id: 2, data: { url: "https://coderadio.freecodecamp.org/", name: "CodeRadio" } },
+ { id: null, data: {} },
+ ],
+ "id"), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truthCheck(collection, pre) {
+ return pre;
+}
+
+truthCheck([{name: "Quincy", role: "Founder", isBot: false}, {name: "Naomi", role: "", isBot: false}, {name: "Camperbot", role: "Bot", isBot: true}], "isBot");
+```
+
+# --solutions--
+
+```js
+function truthCheck(collection, pre) {
+ return collection.every(function(e) { return e[pre]; });
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md
new file mode 100644
index 00000000000..08f139258e0
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md
@@ -0,0 +1,206 @@
+---
+id: a2f1d72d9b908d0bd72bb9f6
+title: Eine Person erstellen
+challengeType: 1
+forumTopicId: 16020
+dashedName: make-a-person
+---
+
+# --description--
+
+Fülle den Objekt-Konstruktor mit den folgenden Methoden aus:
+
+```js
+getFirstName()
+getLastName()
+getFullName()
+setFirstName(first)
+setLastName(last)
+setFullName(firstAndLast)
+```
+
+Führe die Tests durch, um die erwartete Ausgabe für jede Methode zu sehen. Die Methoden, die ein Argument annehmen, dürfen nur ein Argument akzeptieren, welches ein String sein muss. Diese Methoden müssen die einzigen verfügbaren Möglichkeiten sein, um mit dem Objekt zu interagieren.
+
+# --hints--
+
+Es sollten keine Eigenschaften hinzugefügt werden. `Object.keys(bob).length` sollte immer 6 zurückgeben.
+
+```js
+assert.strictEqual(
+ Object.keys((function () {
+ let bob = new Person('Bob Ross');
+ bob.setFirstName('Haskell');
+ bob.setLastName('Curry');
+ bob.setFullName('John Smith');
+ return bob;
+ })()).length,
+ 6
+ );
+```
+
+`bob instanceof Person` sollte `true` zurückgeben.
+
+```js
+assert.deepEqual(bob instanceof Person, true);
+```
+
+`bob.firstName` sollte `undefined` zurückgeben.
+
+```js
+assert.deepEqual(bob.firstName, undefined);
+```
+
+`bob.lastName` sollte `undefined` zurückgeben.
+
+```js
+assert.deepEqual(bob.lastName, undefined);
+```
+
+`bob.getFirstName()` sollte den String `Bob` zurückgeben.
+
+```js
+assert.deepEqual(bob.getFirstName(), 'Bob');
+```
+
+`bob.getLastName()` sollte den String `Ross` zurückgeben.
+
+```js
+assert.deepEqual(bob.getLastName(), 'Ross');
+```
+
+`bob.getFullName()` sollte den String `Bob Ross` zurückgeben.
+
+```js
+assert.deepEqual(bob.getFullName(), 'Bob Ross');
+```
+
+`bob.getFullName()` sollte den String `Haskell Ross` nach `bob.setFirstName("Haskell")` zurückgeben.
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFirstName('Haskell');
+ return bob.getFullName();
+ })(),
+ 'Haskell Ross'
+);
+```
+
+`bob.getFullName()` sollte den String `Haskell Curry` nach `bob.setLastName("Curry")` zurückgeben.
+
+```js
+assert.strictEqual(
+ (function () {
+ var _bob = new Person('Haskell Ross');
+ _bob.setLastName('Curry');
+ return _bob.getFullName();
+ })(),
+ 'Haskell Curry'
+);
+```
+
+`bob.getFullName()` sollte den String `Haskell Curry` nach `bob.setFullName("Haskell Curry")` zurückgeben.
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getFullName();
+ })(),
+ 'Haskell Curry'
+);
+```
+
+`bob.getFirstName()` sollte den String `Haskell` nach `bob.setFullName("Haskell Curry")` zurückgeben.
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getFirstName();
+ })(),
+ 'Haskell'
+);
+```
+
+`bob.getLastName()` sollte den String `Curry` nach `bob.setFullName("Haskell Curry")` zurückgeben.
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getLastName();
+ })(),
+ 'Curry'
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(bob){
+ bob = new Person("Bob Ross");
+}
+```
+
+## --seed-contents--
+
+```js
+const Person = function(firstAndLast) {
+ // Only change code below this line
+ // Complete the method below and implement the others similarly
+ this.getFullName = function() {
+ return "";
+ };
+ return firstAndLast;
+};
+
+const bob = new Person('Bob Ross');
+bob.getFullName();
+```
+
+# --solutions--
+
+```js
+const Person = function(firstAndLast) {
+
+ let firstName, lastName;
+
+ function updateName(str) {
+ firstName = str.split(" ")[0];
+ lastName = str.split(" ")[1];
+ }
+
+ updateName(firstAndLast);
+
+ this.getFirstName = function(){
+ return firstName;
+ };
+
+ this.getLastName = function(){
+ return lastName;
+ };
+
+ this.getFullName = function(){
+ return firstName + " " + lastName;
+ };
+
+ this.setFirstName = function(str){
+ firstName = str;
+ };
+
+
+ this.setLastName = function(str){
+ lastName = str;
+ };
+
+ this.setFullName = function(str){
+ updateName(str);
+ };
+};
+
+const bob = new Person('Bob Ross');
+bob.getFullName();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md
new file mode 100644
index 00000000000..f6ab2dfaa58
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md
@@ -0,0 +1,83 @@
+---
+id: af4afb223120f7348cdfc9fd
+title: Kartiere die Trümmer
+challengeType: 1
+forumTopicId: 16021
+dashedName: map-the-debris
+---
+
+# --description--
+
+Nach dem Dritten Keplerschen Gesetz beträgt die Umlaufzeit $T$ zweier Punktmassen, die sich auf einer kreisförmigen oder elliptischen Bahn umkreisen:
+
+$$ T = 2 \pi \sqrt{\frac{a^{3}}{\mu}} $$
+
+- $a$ ist die Halbachse der Umlaufbahn
+- $μ = GM$ ist der Standard-Gravitationsparameter
+- $G$ ist die Gravitationskonstante,
+- $M$ ist die Masse des massereicheren Körpers.
+
+Gibt ein neues Array zurück, das die durchschnittliche Höhe der Elemente in ihre Umlaufzeit (in Sekunden) umwandelt.
+
+Die Auflistung wird Objekte im Format `{name: 'name', avgAlt: avgAlt}` enthalten.
+
+Die Werte sollten auf die nächste ganze Zahl gerundet werden. Der umkreiste Körper ist die Erde.
+
+Der Radius der Erde beträgt 6367,4447 Kilometer, und der GM-Wert der Erde beträgt 398600,4418 km3 s-2 .
+
+# --hints--
+
+`orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])` sollte `[{name: "sputnik", orbitalPeriod: 86400}]` zurückgeben.
+
+```js
+assert.deepEqual(orbitalPeriod([{ name: 'sputnik', avgAlt: 35873.5553 }]), [
+ { name: 'sputnik', orbitalPeriod: 86400 }
+]);
+```
+
+`orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])` sollte `[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]` zurückgeben.
+
+```js
+assert.deepEqual(
+ orbitalPeriod([
+ { name: 'iss', avgAlt: 413.6 },
+ { name: 'hubble', avgAlt: 556.7 },
+ { name: 'moon', avgAlt: 378632.553 }
+ ]),
+ [
+ { name: 'iss', orbitalPeriod: 5557 },
+ { name: 'hubble', orbitalPeriod: 5734 },
+ { name: 'moon', orbitalPeriod: 2377399 }
+ ]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orbitalPeriod(arr) {
+ const GM = 398600.4418;
+ const earthRadius = 6367.4447;
+ return arr;
+}
+
+orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);
+```
+
+# --solutions--
+
+```js
+function orbitalPeriod(arr) {
+ const GM = 398600.4418;
+ const earthRadius = 6367.4447;
+ const TAU = 2 * Math.PI;
+ return arr.map(function(obj) {
+ return {
+ name: obj.name,
+ orbitalPeriod: Math.round(TAU * Math.sqrt(Math.pow(obj.avgAlt+earthRadius, 3)/GM))
+ };
+ });
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md
new file mode 100644
index 00000000000..05529141e12
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md
@@ -0,0 +1,72 @@
+---
+id: af7588ade1100bde429baf20
+title: Fehlende Buchstaben
+challengeType: 1
+forumTopicId: 16023
+dashedName: missing-letters
+---
+
+# --description--
+
+Finden Sie den fehlenden Buchstaben im übergebenen Buchstabenbereich und geben Sie ihn zurück.
+
+Wenn sich alle Buchstaben im Bereich befinden, gib `undefined` zurück.
+
+# --hints--
+
+`fearNotLetter("abce")` sollte den String `d` zurückgeben.
+
+```js
+assert.deepEqual(fearNotLetter('abce'), 'd');
+```
+
+`fearNotLetter("abcdefghjklmno")` sollte den String `i` zurückgeben.
+
+```js
+assert.deepEqual(fearNotLetter('abcdefghjklmno'), 'i');
+```
+
+`fearNotLetter("stvwx")` sollte den String `u` zurückgeben.
+
+```js
+assert.deepEqual(fearNotLetter('stvwx'), 'u');
+```
+
+`fearNotLetter("bcdf")` sollte den String `e` zurückgeben.
+
+```js
+assert.deepEqual(fearNotLetter('bcdf'), 'e');
+```
+
+`fearNotLetter("abcdefghijklmnopqrstuvwxyz")` sollte `undefined` zurückgeben.
+
+```js
+assert.isUndefined(fearNotLetter('abcdefghijklmnopqrstuvwxyz'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function fearNotLetter(str) {
+ return str;
+}
+
+fearNotLetter("abce");
+```
+
+# --solutions--
+
+```js
+function fearNotLetter (str) {
+ for (var i = str.charCodeAt(0); i <= str.charCodeAt(str.length - 1); i++) {
+ var letter = String.fromCharCode(i);
+ if (str.indexOf(letter) === -1) {
+ return letter;
+ }
+ }
+
+ return undefined;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md
new file mode 100644
index 00000000000..b406cf9fb0a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md
@@ -0,0 +1,93 @@
+---
+id: aa7697ea2477d1316795783b
+title: Schweine-Latein
+challengeType: 1
+forumTopicId: 16039
+dashedName: pig-latin
+---
+
+# --description--
+
+Schweine-Latein ist eine Art, englische Wörter zu verändern. Die Regeln lauten:
+
+\- Wenn ein Wort mit einem Konsonant beginnt, nimm den ersten Konsonanten oder Konsonanten Cluster, verschieben ihn an das Ende des Wortes und füge `ay` hinzu.
+
+\- Wenn ein Wort mit einem Vokal beginnt, füge einfach `way` am Ende hinzu.
+
+# --instructions--
+
+Übersetze den angegebenen String in Schweine-Latein. Die Input Strings sind garantiert englische Wörter in ausschließlich Kleinbuchstaben.
+
+# --hints--
+
+`translatePigLatin("california")` sollte den String `aliforniacay` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('california'), 'aliforniacay');
+```
+
+`translatePigLatin("paragraphs")` sollte den String `aragraphspay` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('paragraphs'), 'aragraphspay');
+```
+
+`translatePigLatin("glove")` sollte den String `oveglay` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('glove'), 'oveglay');
+```
+
+`translatePigLatin("algorithm")` sollte den String `algorithmway` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('algorithm'), 'algorithmway');
+```
+
+`translatePigLatin("eight")` sollte den String `eightway` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('eight'), 'eightway');
+```
+
+Sollte Wörter behandeln können, bei denen der erste Vokal in der Mitte des Wortes vorkommt. `translatePigLatin("schwartz")` sollte den String `artzschway` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('schwartz'), 'artzschway');
+```
+
+Sollte Wörter ohne Vokale behandeln. `translatePigLatin("rhythm")` sollte den String `rhythmay` zurückgeben.
+
+```js
+assert.deepEqual(translatePigLatin('rhythm'), 'rhythmay');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function translatePigLatin(str) {
+ return str;
+}
+
+translatePigLatin("consonant");
+```
+
+# --solutions--
+
+```js
+function translatePigLatin(str) {
+ if (isVowel(str.charAt(0))) return str + "way";
+ var front = [];
+ str = str.split('');
+ while (str.length && !isVowel(str[0])) {
+ front.push(str.shift());
+ }
+ return [].concat(str, front).join('') + 'ay';
+}
+
+function isVowel(c) {
+ return ['a', 'e', 'i', 'o', 'u'].indexOf(c.toLowerCase()) !== -1;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md
new file mode 100644
index 00000000000..68d2163c9cd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md
@@ -0,0 +1,100 @@
+---
+id: a0b5010f579e69b815e7c5d6
+title: Suchen und Ersetzen
+challengeType: 1
+forumTopicId: 16045
+dashedName: search-and-replace
+---
+
+# --description--
+
+Führe eine Suche durch, ersetze Teile des Satzes mit den angegebenen Argumenten und gib den neuen Satz zurück.
+
+Das erste Argument ist der Satz, an dem du das Suchen und Ersetzen anwenden wirst.
+
+Das zweite Argument ist das Wort, das du ersetzen wirst (davor).
+
+Mit dem dritten Argument bestimmst du, was das zweite Argument ersetzen soll (danach).
+
+**Hinweis:** Behalte die Groß- und Kleinschreibung des Originalwortes, wenn du es ersetzt. Zum Beispiel, wenn du das Wort `Book` durch das Wort `dog`ersetzen willst, sollte es als `Dog` ersetzt werden
+
+# --hints--
+
+`myReplace("Let us go to the store", "store", "mall")` sollte den String `Let us go to the mall` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('Let us go to the store', 'store', 'mall'),
+ 'Let us go to the mall'
+);
+```
+
+`myReplace("He is Sleeping on the couch", "Sleeping", "sitting")` sollte den String `He is Sitting on the couch` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('He is Sleeping on the couch', 'Sleeping', 'sitting'),
+ 'He is Sitting on the couch'
+);
+```
+
+`myReplace("I think we should look up there", "up", "Down")` sollte den String `I think we should look down there` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('I think we should look up there', 'up', 'Down'),
+ 'I think we should look down there'
+);
+```
+
+`myReplace("This has a spellngi error", "spellngi", "spelling")` sollte den String `This has a spelling error` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('This has a spellngi error', 'spellngi', 'spelling'),
+ 'This has a spelling error'
+);
+```
+
+`myReplace("His name is Tom", "Tom", "john")` sollte den String `His name is John` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('His name is Tom', 'Tom', 'john'),
+ 'His name is John'
+);
+```
+
+`myReplace("Let us get back to more Coding", "Coding", "algorithms")` sollte den String `Let us get back to more Algorithms` zurückgeben.
+
+```js
+assert.deepEqual(
+ myReplace('Let us get back to more Coding', 'Coding', 'algorithms'),
+ 'Let us get back to more Algorithms'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myReplace(str, before, after) {
+ return str;
+}
+
+myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
+```
+
+# --solutions--
+
+```js
+function myReplace(str, before, after) {
+ if (before.charAt(0) === before.charAt(0).toUpperCase()) {
+ after = after.charAt(0).toUpperCase() + after.substring(1);
+ } else {
+ after = after.charAt(0).toLowerCase() + after.substring(1);
+ }
+ return str.replace(before, after);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md
new file mode 100644
index 00000000000..09067ffe825
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md
@@ -0,0 +1,104 @@
+---
+id: a39963a4c10bc8b4d4f06d7e
+title: Suchen und Zerstören
+challengeType: 1
+forumTopicId: 16046
+dashedName: seek-and-destroy
+---
+
+# --description--
+
+Dir wird ein Ausgangsarray (das erste Argument in der `destroyer`-Funktion) zur Verfügung gestellt, gefolgt von einem oder mehreren Argumenten. Entferne alle Elemente aus dem Ausgangsarray, die den gleichen Wert wie diese Argumente haben.
+
+**Hinweis:** Du musst das `arguments`-Objekt verwenden.
+
+# --hints--
+
+`destroyer([1, 2, 3, 1, 2, 3], 2, 3)` sollte `[1, 1]` zurückgeben.
+
+```js
+assert.deepEqual(destroyer([1, 2, 3, 1, 2, 3], 2, 3), [1, 1]);
+```
+
+`destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)` sollte `[1, 5, 1]` zurückgeben.
+
+```js
+assert.deepEqual(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3), [1, 5, 1]);
+```
+
+`destroyer([3, 5, 1, 2, 2], 2, 3, 5)` sollte `[1]` zurückgeben.
+
+```js
+assert.deepEqual(destroyer([3, 5, 1, 2, 2], 2, 3, 5), [1]);
+```
+
+`destroyer([2, 3, 2, 3], 2, 3)` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(destroyer([2, 3, 2, 3], 2, 3), []);
+```
+
+`destroyer(["tree", "hamburger", 53], "tree", 53)` sollte `["hamburger"]` zurückgeben.
+
+```js
+assert.deepEqual(destroyer(['tree', 'hamburger', 53], 'tree', 53), [
+ 'hamburger'
+]);
+```
+
+`destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")` sollte `[12,92,65]` zurückgeben.
+
+```js
+assert.deepEqual(
+ destroyer(
+ [
+ 'possum',
+ 'trollo',
+ 12,
+ 'safari',
+ 'hotdog',
+ 92,
+ 65,
+ 'grandma',
+ 'bugati',
+ 'trojan',
+ 'yacht'
+ ],
+ 'yacht',
+ 'possum',
+ 'trollo',
+ 'safari',
+ 'hotdog',
+ 'grandma',
+ 'bugati',
+ 'trojan'
+ ),
+ [12, 92, 65]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function destroyer(arr) {
+ return arr;
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);
+```
+
+# --solutions--
+
+```js
+function destroyer(arr) {
+ var hash = Object.create(null);
+ [].slice.call(arguments, 1).forEach(function(e) {
+ hash[e] = true;
+ });
+ return arr.filter(function(e) { return !(e in hash);});
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md
new file mode 100644
index 00000000000..d7ecb85d02c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md
@@ -0,0 +1,89 @@
+---
+id: ae9defd7acaf69703ab432ea
+title: Kleinstes gemeinsames Vielfaches
+challengeType: 1
+forumTopicId: 16075
+dashedName: smallest-common-multiple
+---
+
+# --description--
+
+Finde das kleinste gemeinsame Vielfache der angegebenen Parameter, die gleichmäßig durch beide geteilt werden können sowie alle Sequenznummern im Bereich zwischen diesen Parametern.
+
+Der Bereich wird ein Array von zwei Zahlen sein, die nicht unbedingt in numerischer Reihenfolge sind.
+
+Wenn zum Beispiel 1 und 3 gegeben sind, finde das kleinste gemeinsame Vielfache von 1 und 3, das auch durch alle Zahlen *between* 1 und 3 gleichmäßig teilbar ist. Die Antwort hier lautet 6.
+
+# --hints--
+
+`smallestCommons([1, 5])` sollte eine Zahl zurückgeben.
+
+```js
+assert.deepEqual(typeof smallestCommons([1, 5]), 'number');
+```
+
+`smallestCommons([1, 5])` sollte 60 zurückgeben.
+
+```js
+assert.deepEqual(smallestCommons([1, 5]), 60);
+```
+
+`smallestCommons([5, 1])` sollte 60 zurückgeben.
+
+```js
+assert.deepEqual(smallestCommons([5, 1]), 60);
+```
+
+`smallestCommons([2, 10])` sollte 2520 zurückgeben.
+
+```js
+assert.deepEqual(smallestCommons([2, 10]), 2520);
+```
+
+`smallestCommons([1, 13])` sollte 360360 zurückgeben.
+
+```js
+assert.deepEqual(smallestCommons([1, 13]), 360360);
+```
+
+`smallestCommons([23, 18])` sollte 6056820 zurückgeben.
+
+```js
+assert.deepEqual(smallestCommons([23, 18]), 6056820);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function smallestCommons(arr) {
+ return arr;
+}
+
+smallestCommons([1,5]);
+```
+
+# --solutions--
+
+```js
+function gcd(a, b) {
+ while (b !== 0) {
+ a = [b, b = a % b][0];
+ }
+ return a;
+}
+
+function lcm(a, b) {
+ return (a * b) / gcd(a, b);
+}
+
+function smallestCommons(arr) {
+ arr.sort(function(a,b) {return a-b;});
+ var rng = [];
+ for (var i = arr[0]; i <= arr[1]; i++) {
+ rng.push(i);
+ }
+ return rng.reduce(lcm);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md
new file mode 100644
index 00000000000..5214cfddb00
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md
@@ -0,0 +1,84 @@
+---
+id: a105e963526e7de52b219be9
+title: Sortierte Union
+challengeType: 1
+forumTopicId: 16077
+dashedName: sorted-union
+---
+
+# --description--
+
+Schreibe eine Funktion, die zwei oder mehr Arrays annimmt und ein neues Array mit eindeutigen Werten in der Reihenfolge der ursprünglich angegebenen Arrays zurückgibt.
+
+Mit anderen Worten: Alle Werte aus allen Arrays sollten in ihrer ursprünglichen Reihenfolge, aber ohne Duplikate in das endgültige Array aufgenommen werden.
+
+Die eindeutigen Zahlen sollten nach ihrer ursprünglichen Reihenfolge sortiert werden, aber das endgültige Array sollte nicht in numerischer Reihenfolge sortiert sein.
+
+Beispiele findest du in den Tests der Behauptungen (nachfolgend).
+
+# --hints--
+
+`uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])` sollte `[1, 3, 2, 5, 4]` zurückgeben.
+
+```js
+assert.deepEqual(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]), [1, 3, 2, 5, 4]);
+```
+
+`uniteUnique([1, 2, 3], [5, 2, 1])` sollte `[1, 2, 3, 5]` zurückgeben.
+
+```js
+assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1]), [1, 2, 3, 5]);
+```
+
+`uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])` sollte `[1, 2, 3, 5, 4, 6, 7, 8]` zurückgeben.
+
+```js
+assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]), [
+ 1,
+ 2,
+ 3,
+ 5,
+ 4,
+ 6,
+ 7,
+ 8
+]);
+```
+
+`uniteUnique([1, 3, 2], [5, 4], [5, 6])` sollte `[1, 3, 2, 5, 4, 6]` zurückgeben.
+
+```js
+assert.deepEqual(uniteUnique([1, 3, 2], [5, 4], [5, 6]), [1, 3, 2, 5, 4, 6]);
+```
+
+`uniteUnique([1, 3, 2, 3], [5, 2, 1, 4], [2, 1])` sollte `[1, 3, 2, 5, 4]` zurückgeben.
+
+```js
+assert.deepEqual(uniteUnique([1, 3, 2, 3], [5, 2, 1, 4], [2, 1]), [1, 3, 2, 5, 4]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function uniteUnique(arr) {
+ return arr;
+}
+
+uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);
+```
+
+# --solutions--
+
+```js
+function uniteUnique(arr) {
+ return [].slice.call(arguments).reduce(function(a, b) {
+ return [].concat(
+ a,
+ b.filter(function(e, currentIndex) {
+ return b.indexOf(e) === currentIndex && a.indexOf(e) === -1;
+ }));
+ }, []);
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md
new file mode 100644
index 00000000000..567af8efb36
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md
@@ -0,0 +1,70 @@
+---
+id: a103376db3ba46b2d50db289
+title: Spinal Tap Case
+challengeType: 1
+forumTopicId: 16078
+dashedName: spinal-tap-case
+---
+
+# --description--
+
+Konvertiere einen String in Spinal Case. Spinal Case sind Wörter in Kleinbuchstaben, die durch Bindestriche verbunden sind.
+
+# --hints--
+
+`spinalCase("This Is Spinal Tap")` sollte den String `this-is-spinal-tap` zurückgeben.
+
+```js
+assert.deepEqual(spinalCase('This Is Spinal Tap'), 'this-is-spinal-tap');
+```
+
+`spinalCase("thisIsSpinalTap")` sollte den String `this-is-spinal-tap` zurückgeben.
+
+```js
+assert.strictEqual(spinalCase('thisIsSpinalTap'), 'this-is-spinal-tap');
+```
+
+`spinalCase("The_Andy_Griffith_Show")` sollte den String `the-andy-griffith-show` zurückgeben.
+
+```js
+assert.strictEqual(
+ spinalCase('The_Andy_Griffith_Show'),
+ 'the-andy-griffith-show'
+);
+```
+
+`spinalCase("Teletubbies say Eh-oh")` sollte den String `teletubbies-say-eh-oh` zurückgeben.
+
+```js
+assert.strictEqual(
+ spinalCase('Teletubbies say Eh-oh'),
+ 'teletubbies-say-eh-oh'
+);
+```
+
+`spinalCase("AllThe-small Things")` sollte den String `all-the-small-things` zurückgeben.
+
+```js
+assert.strictEqual(spinalCase('AllThe-small Things'), 'all-the-small-things');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spinalCase(str) {
+ return str;
+}
+
+spinalCase('This Is Spinal Tap');
+```
+
+# --solutions--
+
+```js
+function spinalCase(str) {
+ str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
+ return str.toLowerCase().replace(/\ |\_/g, '-');
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md
new file mode 100644
index 00000000000..0340dea00fe
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md
@@ -0,0 +1,72 @@
+---
+id: ab306dbdcc907c7ddfc30830
+title: Dampfwalze
+challengeType: 1
+forumTopicId: 16079
+dashedName: steamroller
+---
+
+# --description--
+
+Reduziere ein verschachteltes Array. Du musst die verschiedenen Ebenen der Verschachtelung berücksichtigen.
+
+# --hints--
+
+`steamrollArray([[["a"]], [["b"]]])` sollte `["a", "b"]` zurückgeben.
+
+```js
+assert.deepEqual(steamrollArray([[['a']], [['b']]]), ['a', 'b']);
+```
+
+`steamrollArray([1, [2], [3, [[4]]]])` sollte `[1, 2, 3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(steamrollArray([1, [2], [3, [[4]]]]), [1, 2, 3, 4]);
+```
+
+`steamrollArray([1, [], [3, [[4]]]])` sollte `[1, 3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(steamrollArray([1, [], [3, [[4]]]]), [1, 3, 4]);
+```
+
+`steamrollArray([1, {}, [3, [[4]]]])` sollte `[1, {}, 3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(steamrollArray([1, {}, [3, [[4]]]]), [1, {}, 3, 4]);
+```
+
+Deine Lösung sollte nicht `Array.prototype.flat()` oder `Array.prototype.flatMap()` Methoden verwenden.
+
+```js
+assert(!code.match(/\.\s*flat\s*\(/) && !code.match(/\.\s*flatMap\s*\(/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function steamrollArray(arr) {
+ return arr;
+}
+
+steamrollArray([1, [2], [3, [[4]]]]);
+```
+
+# --solutions--
+
+```js
+function steamrollArray(arr) {
+ if (!Array.isArray(arr)) {
+ return [arr];
+ }
+ var out = [];
+ arr.forEach(function(e) {
+ steamrollArray(e).forEach(function(v) {
+ out.push(v);
+ });
+ });
+ return out;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md
new file mode 100644
index 00000000000..da67af0cd44
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md
@@ -0,0 +1,70 @@
+---
+id: a3566b1109230028080c9345
+title: Summiere alle Zahlen in einem Bereich
+challengeType: 1
+forumTopicId: 16083
+dashedName: sum-all-numbers-in-a-range
+---
+
+# --description--
+
+Wir übergeben dir ein Array mit zwei Zahlen. Gib die Summe dieser beiden Zahlen plus die Summe aller Zahlen zwischen den beiden Zahlen zurück. Die niedrigste Zahl wird nicht immer an erster Stelle stehen.
+
+Zum Beispiel `sumAll([4,1])` sollte `10` zurückgeben, da die Summe aller Zahlen zwischen 1 und 4 (beides inklusive) `10` ist.
+
+# --hints--
+
+`sumAll([1, 4])` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof sumAll([1, 4]) === 'number');
+```
+
+`sumAll([1, 4])` sollte 10 zurückgeben.
+
+```js
+assert.deepEqual(sumAll([1, 4]), 10);
+```
+
+`sumAll([4, 1])` sollte 10 zurückgeben.
+
+```js
+assert.deepEqual(sumAll([4, 1]), 10);
+```
+
+`sumAll([5, 10])` sollte 45 zurückgeben.
+
+```js
+assert.deepEqual(sumAll([5, 10]), 45);
+```
+
+`sumAll([10, 5])` sollte 45 zurückgeben.
+
+```js
+assert.deepEqual(sumAll([10, 5]), 45);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumAll(arr) {
+ return 1;
+}
+
+sumAll([1, 4]);
+```
+
+# --solutions--
+
+```js
+function sumAll(arr) {
+ var sum = 0;
+ arr.sort(function(a,b) {return a-b;});
+ for (var i = arr[0]; i <= arr[1]; i++) {
+ sum += i;
+ }
+ return sum;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md
new file mode 100644
index 00000000000..f7ef65e093a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md
@@ -0,0 +1,82 @@
+---
+id: a5229172f011153519423690
+title: Summiere alle ungeraden Fibonacci-Zahlen
+challengeType: 1
+forumTopicId: 16084
+dashedName: sum-all-odd-fibonacci-numbers
+---
+
+# --description--
+
+Gib für eine positive ganze Zahl `num` die Summe aller ungeraden Fibonacci-Zahlen zurück, die kleiner oder gleich `num` sind.
+
+Die ersten beiden Zahlen in der Fibonacci Sequenz sind 1 und 1. Jede zusätzliche Zahl in der Sequenz ist die Summe der beiden vorherigen Zahlen. Die ersten sechs Zahlen der Fibonacci Sequenz sind 1, 1, 2, 3, 5 und 8.
+
+Zum Beispiel sollte `sumFibs(10)`, `10` zurückgeben, da alle ungeraden Fibonacci Zahlen kleiner oder gleich `10` 1, 1, 3 und 5 sind.
+
+# --hints--
+
+`sumFibs(1)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof sumFibs(1) === 'number');
+```
+
+`sumFibs(1000)` sollte 1785 zurückgeben.
+
+```js
+assert(sumFibs(1000) === 1785);
+```
+
+`sumFibs(4000000)` sollte 4613732 zurückgeben.
+
+```js
+assert(sumFibs(4000000) === 4613732);
+```
+
+`sumFibs(4)` sollte 5 zurückgeben.
+
+```js
+assert(sumFibs(4) === 5);
+```
+
+`sumFibs(75024)` sollte 60696 zurückgeben.
+
+```js
+assert(sumFibs(75024) === 60696);
+```
+
+`sumFibs(75025)` sollte 135721 zurückgeben.
+
+```js
+assert(sumFibs(75025) === 135721);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumFibs(num) {
+ return num;
+}
+
+sumFibs(4);
+```
+
+# --solutions--
+
+```js
+function sumFibs(num) {
+ var a = 1;
+ var b = 1;
+ var s = 0;
+ while (a <= num) {
+ if (a % 2 !== 0) {
+ s += a;
+ }
+ a = [b, b=b+a][0];
+ }
+ return s;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md
new file mode 100644
index 00000000000..798a4587fd4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md
@@ -0,0 +1,75 @@
+---
+id: a3bfc1673c0526e06d3ac698
+title: Summiere alle Primzahlen
+challengeType: 1
+forumTopicId: 16085
+dashedName: sum-all-primes
+---
+
+# --description--
+
+Eine Primzahl ist eine ganze Zahl größer als 1 mit genau zwei Divisoren: 1 und sich selbst. Zum Beispiel ist 2 eine Primzahl, weil sie nur durch 1 und 2 teilbar ist. Im Gegensatz dazu ist 4 keine Primzahl, da sie durch 1, 2 und 4 teilbar ist.
+
+Schreibe `sumPrimes` neu, so dass es die Summe aller Primzahlen zurückgibt, die kleiner oder gleich Null sind.
+
+# --hints--
+
+`sumPrimes(10)` sollte eine Zahl zurückgeben.
+
+```js
+assert.deepEqual(typeof sumPrimes(10), 'number');
+```
+
+`sumPrimes(10)` sollte 17 zurückgeben.
+
+```js
+assert.deepEqual(sumPrimes(10), 17);
+```
+
+`sumPrimes(977)` sollte 73156 zurückgeben.
+
+```js
+assert.deepEqual(sumPrimes(977), 73156);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumPrimes(num) {
+ return num;
+}
+
+sumPrimes(10);
+```
+
+# --solutions--
+
+```js
+function eratosthenesArray(n) {
+ var primes = [];
+ if (n > 2) {
+ var half = n>>1;
+ var sieve = Array(half);
+ for (var i = 1, limit = Math.sqrt(n)>>1; i <= limit; i++) {
+ if (!sieve[i]) {
+ for (var step = 2*i+1, j = (step*step)>>1; j < half; j+=step) {
+ sieve[j] = true;
+ }
+ }
+ }
+ primes.push(2);
+ for (var p = 1; p < half; p++) {
+ if (!sieve[p]) primes.push(2*p+1);
+ }
+ }
+ return primes;
+}
+
+function sumPrimes(num) {
+ return eratosthenesArray(num+1).reduce(function(a,b) {return a+b;}, 0);
+}
+
+sumPrimes(10);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md
new file mode 100644
index 00000000000..6679bfe95c4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md
@@ -0,0 +1,139 @@
+---
+id: a8e512fbe388ac2f9198f0fa
+title: Deshalb bist du
+challengeType: 1
+forumTopicId: 16092
+dashedName: wherefore-art-thou
+---
+
+# --description--
+
+Erstelle eine Funktion, die ein Array mit Objekten (erstes Argument) durchsucht und ein Array mit allen Objekten zurückgibt, die übereinstimmende Namens- und Wertepaare haben (zweites Argument). Jedes Namens- und Wertepaar des Quellobjekts muss im Objekt aus der Sammlung vorhanden sein, wenn es in das zurückgegebene Array aufgenommen werden soll.
+
+Wenn das erste Argument zum Beispiel `[{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]`, und das zweite Argument ist `{ last: "Capulet" }`, dann musst du das dritte Objekt aus dem Array (das erste Argument) zurückgeben, denn es enthält den Namen und seinen Wert, der als zweites Argument übergeben wurde.
+
+# --hints--
+
+`whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })` sollte `[{ first: "Tybalt", last: "Capulet" }]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [
+ { first: 'Romeo', last: 'Montague' },
+ { first: 'Mercutio', last: null },
+ { first: 'Tybalt', last: 'Capulet' }
+ ],
+ { last: 'Capulet' }
+ ),
+ [{ first: 'Tybalt', last: 'Capulet' }]
+);
+```
+
+`whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 })` sollte`[{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName([{ apple: 1 }, { apple: 1 }, { apple: 1, bat: 2 }], {
+ apple: 1
+ }),
+ [{ apple: 1 }, { apple: 1 }, { apple: 1, bat: 2 }]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 })` sollte`[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [{ apple: 1, bat: 2 }, { bat: 2 }, { apple: 1, bat: 2, cookie: 2 }],
+ { apple: 1, bat: 2 }
+ ),
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1, bat: 2, cookie: 2 }
+ ]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 })` sollte `[{ "apple": 1, "bat": 2, "cookie": 2 }]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [{ apple: 1, bat: 2 }, { apple: 1 }, { apple: 1, bat: 2, cookie: 2 }],
+ { apple: 1, cookie: 2 }
+ ),
+ [{ apple: 1, bat: 2, cookie: 2 }]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, { "bat":2 }], { "apple": 1, "bat": 2 })` sollte`[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1 },
+ { apple: 1, bat: 2, cookie: 2 },
+ { bat: 2 }
+ ],
+ { apple: 1, bat: 2 }
+ ),
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1, bat: 2, cookie: 2 }
+ ]
+);
+```
+
+`whatIsInAName([{"a": 1, "b": 2, "c": 3}], {"a": 1, "b": 9999, "c": 3})` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName([{ a: 1, b: 2, c: 3 }], { a: 1, b: 9999, c: 3 }),
+ []
+);
+```
+
+`whatIsInAName([{"a": 1, "b": 2, "c": 3, "d": 9999}], {"a": 1, "b": 9999, "c": 3})` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(
+ whatIsInAName([{ a: 1, b: 2, c: 3, d: 9999 }], { a: 1, b: 9999, c: 3 }),
+ []
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function whatIsInAName(collection, source) {
+ const arr = [];
+ // Only change code below this line
+
+
+ // Only change code above this line
+ return arr;
+}
+
+whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
+```
+
+# --solutions--
+
+```js
+function whatIsInAName(collection, source) {
+ const arr = [];
+ const keys = Object.keys(source);
+ collection.forEach(function(e) {
+ if(keys.every(function(key) {return e[key] === source[key];})) {
+ arr.push(e);
+ }
+ });
+ return arr;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md
new file mode 100644
index 00000000000..3884e06b266
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md
@@ -0,0 +1,88 @@
+---
+id: 56533eb9ac21ba0edf2244e2
+title: Caesar-Verschlüsselung
+challengeType: 5
+forumTopicId: 16003
+dashedName: caesars-cipher
+---
+
+# --description--
+
+Eine der einfachsten und bekanntesten ciphers ist die Caesar-cipher , auch bekannt als shift-cipher . Bei einer Shift Verschlüsselung werden die Bedeutungen der Buchstaben um einen bestimmten Betrag verschoben.
+
+Eine gängige moderne Anwendung ist die ROT13 Verschlüsselung, bei der die Werte der Buchstaben um 13 Stellen verschoben werden. Also gilt `A ↔ N`, `B ↔ O` und so weiter.
+
+Schreibe eine Funktion, die eine ROT13 kodierten String als Eingabe verwendet und einen dekodierten String zurückgibt.
+
+Alle Buchstaben werden groß geschrieben. Verändere keine nicht-alphabetischen Zeichen (z. B. Leerzeichen, Satzzeichen), sondern gib sie weiter.
+
+# --hints--
+
+`rot13("SERR PBQR PNZC")` sollte zum String `FREE CODE CAMP` dekodiert werden
+
+```js
+assert(rot13('SERR PBQR PNZC') === 'FREE CODE CAMP');
+```
+
+`rot13("SERR CVMMN!")` sollte zum String `FREE PIZZA!` dekodiert werden
+
+```js
+assert(rot13('SERR CVMMN!') === 'FREE PIZZA!');
+```
+
+`rot13("SERR YBIR?")` sollte zum String `FREE LOVE?` dekodiert werden
+
+```js
+assert(rot13('SERR YBIR?') === 'FREE LOVE?');
+```
+
+`rot13("GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.")` sollte zum String `THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.` dekodiert werden
+
+```js
+assert(
+ rot13('GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.') ===
+ 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function rot13(str) {
+ return str;
+}
+
+rot13("SERR PBQR PNZC");
+```
+
+# --solutions--
+
+```js
+var lookup = {
+ 'A': 'N','B': 'O','C': 'P','D': 'Q',
+ 'E': 'R','F': 'S','G': 'T','H': 'U',
+ 'I': 'V','J': 'W','K': 'X','L': 'Y',
+ 'M': 'Z','N': 'A','O': 'B','P': 'C',
+ 'Q': 'D','R': 'E','S': 'F','T': 'G',
+ 'U': 'H','V': 'I','W': 'J','X': 'K',
+ 'Y': 'L','Z': 'M'
+};
+
+function rot13(encodedStr) {
+ var codeArr = encodedStr.split(""); // String to Array
+ var decodedArr = []; // Your Result goes here
+ // Only change code below this line
+
+ decodedArr = codeArr.map(function(letter) {
+ if(lookup.hasOwnProperty(letter)) {
+ letter = lookup[letter];
+ }
+ return letter;
+ });
+
+ // Only change code above this line
+ return decodedArr.join(""); // Array to String
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md
new file mode 100644
index 00000000000..71e4ccf8ce6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md
@@ -0,0 +1,252 @@
+---
+id: aa2e6f85cab2ab736c9a9b24
+title: Registrierkasse
+challengeType: 5
+forumTopicId: 16012
+dashedName: cash-register
+---
+
+# --description--
+
+Entwirf eine Registrierkassenfunktion `checkCashRegister()`, die als erstes Argument den Kaufpreis (`price`), als zweites Argument die Bezahlung (`cash`) und als drittes Argument den Kassenbestand (`cid`) akzeptiert.
+
+`cid` ist ein 2D-Array mit den verfügbaren Währungen.
+
+Die Funktion `checkCashRegister()` sollte immer ein Objekt mit einem Key `status` und einem Key `change` zurückgeben.
+
+Gib `{status: "INSUFFICIENT_FUNDS", change: []}` zurück, wenn der Kassenbestand geringer ist als das fällige Wechselgeld, oder wenn du das genaue Wechselgeld nicht zurückgeben kannst.
+
+Gib `{status: "CLOSED", change: [...]}` als Wert für den Key `change` zurück, wenn der Kassenbestand gleich dem fälligen Wechselgeld ist.
+
+Andernfalls wird `{status: "OPEN", change: [...]}`, mit dem fälligen Wechselgeld in Münzen und Scheinen, sortiert in der höchsten bis niedrigsten Reihenfolge, als Wert des Keys `change` zurückgegeben.
+
+Währungseinheit Anzahl Penny $0.01 (PENNY) Nickel $0.05 (NICKEL) Dime $0.1 (DIME) Quarter $0.25 (QUARTER) Dollar $1 (ONE) Fünf Dollar $5 (FIVE) Zehn Dollar $10 (TEN) Zwanzig Dollar $20 (TWENTY) Einhundert Dollar $100 (ONE HUNDRED)
+
+Unten findest du ein Beispiel für Wechselgeld:
+
+```js
+[
+ ["PENNY", 1.01],
+ ["NICKEL", 2.05],
+ ["DIME", 3.1],
+ ["QUARTER", 4.25],
+ ["ONE", 90],
+ ["FIVE", 55],
+ ["TEN", 20],
+ ["TWENTY", 60],
+ ["ONE HUNDRED", 100]
+]
+```
+
+# --hints--
+
+`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` sollte ein Objekt zurückgeben.
+
+```js
+assert.deepEqual(
+ Object.prototype.toString.call(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ])
+ ),
+ '[object Object]'
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` sollte`{status: "OPEN", change: [["QUARTER", 0.5]]}` zurückgeben.
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ]),
+ { status: 'OPEN', change: [['QUARTER', 0.5]] }
+);
+```
+
+`checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` sollte`{status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}` zurückgeben.
+
+```js
+assert.deepEqual(
+ checkCashRegister(3.26, 100, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ]),
+ {
+ status: 'OPEN',
+ change: [
+ ['TWENTY', 60],
+ ['TEN', 20],
+ ['FIVE', 15],
+ ['ONE', 1],
+ ['QUARTER', 0.5],
+ ['DIME', 0.2],
+ ['PENNY', 0.04]
+ ]
+ }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` sollte`{status: "INSUFFICIENT_FUNDS", change: []}` zurückgeben.
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.01],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ { status: 'INSUFFICIENT_FUNDS', change: [] }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` sollte`{status: "INSUFFICIENT_FUNDS", change: []}` zurückgeben.
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.01],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 1],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ { status: 'INSUFFICIENT_FUNDS', change: [] }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` sollte`{status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}` zurückgeben.
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.5],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ {
+ status: 'CLOSED',
+ change: [
+ ['PENNY', 0.5],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]
+ }
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkCashRegister(price, cash, cid) {
+ let change;
+ return change;
+}
+
+checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]);
+```
+
+# --solutions--
+
+```js
+const denom = [
+ { name: "ONE HUNDRED", val: 100 },
+ { name: "TWENTY", val: 20 },
+ { name: "TEN", val: 10 },
+ { name: "FIVE", val: 5 },
+ { name: "ONE", val: 1 },
+ { name: "QUARTER", val: 0.25 },
+ { name: "DIME", val: 0.1 },
+ { name: "NICKEL", val: 0.05 },
+ { name: "PENNY", val: 0.01 },
+];
+
+function checkCashRegister(price, cash, cid) {
+ const output = { status: null, change: [] };
+ let change = cash - price;
+ const register = cid.reduce(
+ function (acc, curr) {
+ acc.total += curr[1];
+ acc[curr[0]] = curr[1];
+ return acc;
+ },
+ { total: 0 }
+ );
+ if (register.total === change) {
+ output.status = "CLOSED";
+ output.change = cid;
+ return output;
+ }
+ if (register.total < change) {
+ output.status = "INSUFFICIENT_FUNDS";
+ return output;
+ }
+ const change_arr = denom.reduce(function (acc, curr) {
+ let value = 0;
+ while (register[curr.name] > 0 && change >= curr.val) {
+ change -= curr.val;
+ register[curr.name] -= curr.val;
+ value += curr.val;
+ change = Math.round(change * 100) / 100;
+ }
+ if (value > 0) {
+ acc.push([curr.name, value]);
+ }
+ return acc;
+ }, []);
+ if (change_arr.length < 1 || change > 0) {
+ output.status = "INSUFFICIENT_FUNDS";
+ return output;
+ }
+ output.status = "OPEN";
+ output.change = change_arr;
+ return output;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md
new file mode 100644
index 00000000000..ef774a7a299
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md
@@ -0,0 +1,125 @@
+---
+id: aaa48de84e1ecc7c742e1124
+title: Palindrom-Prüfer
+challengeType: 5
+forumTopicId: 16004
+dashedName: palindrome-checker
+---
+
+# --description--
+
+Gibt `true` zurück, wenn der angegebene String ein Palindrom ist. Gib ansonsten `false` zurück.
+
+Ein Palindrom ist ein Wort oder ein Satz, der sowohl vorwärts als auch rückwärts gleich geschrieben wird, ohne Rücksicht auf Interpunktion, Groß- und Kleinschreibung.
+
+**Hinweis:** Du musst **alle nicht-alphanumerischen Zeichen** (Satzzeichen, Leerzeichen und Symbole) entfernen und alles in die gleiche Schreibweise (Klein- oder Großbuchstaben) umwandeln, um auf Palindrome zu prüfen.
+
+Wir übergeben Strings mit unterschiedlichen Formaten, wie zum Beispiel `racecar`, `RaceCar`, und `race CAR`.
+
+Wir werden auch Strings mit speziellen Symbolen übergeben, wie `2A3*3a2`, `2A3 3a2` und `2_A3*3#A2`.
+
+# --hints--
+
+`palindrome("eye")` sollte einen booleschen Wert zurückgeben.
+
+```js
+assert(typeof palindrome('eye') === 'boolean');
+```
+
+`palindrome("eye")` sollte `true` zurückgeben.
+
+```js
+assert(palindrome('eye') === true);
+```
+
+`palindrome("_eye")` sollte `true` zurückgeben.
+
+```js
+assert(palindrome('_eye') === true);
+```
+
+`palindrome("race car")` sollte`true` zurückgeben.
+
+```js
+assert(palindrome('race car') === true);
+```
+
+`palindrome("not a palindrome")` sollte `false` zurückgeben.
+
+```js
+assert(palindrome('not a palindrome') === false);
+```
+
+`palindrome("A man, a plan, a canal. Panama")` sollte`true` zurückgeben.
+
+```js
+assert(palindrome('A man, a plan, a canal. Panama') === true);
+```
+
+`palindrome("never odd or even")` sollte`true` zurückgeben.
+
+```js
+assert(palindrome('never odd or even') === true);
+```
+
+`palindrome("nope")` sollte`false` zurückgeben.
+
+```js
+assert(palindrome('nope') === false);
+```
+
+`palindrome("almostomla")` sollte`false` zurückgeben.
+
+```js
+assert(palindrome('almostomla') === false);
+```
+
+`palindrome("My age is 0, 0 si ega ym.")` sollte`true` zurückgeben.
+
+```js
+assert(palindrome('My age is 0, 0 si ega ym.') === true);
+```
+
+`palindrome("1 eye for of 1 eye.")` sollte `false` zurückgeben.
+
+```js
+assert(palindrome('1 eye for of 1 eye.') === false);
+```
+
+`palindrome("0_0 (: /-\ :) 0-0")` sollte`true` zurückgeben.
+
+```js
+assert(palindrome('0_0 (: /- :) 0-0') === true);
+```
+
+`palindrome("five|\_/|four")` sollte`false` zurückgeben.
+
+```js
+assert(palindrome('five|_/|four') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function palindrome(str) {
+ return true;
+}
+
+palindrome("eye");
+```
+
+# --solutions--
+
+```js
+function palindrome(str) {
+ var string = str.toLowerCase().split(/[^A-Za-z0-9]/gi).join('');
+ var aux = string.split('');
+ if (aux.join('') === aux.reverse().join('')){
+ return true;
+ }
+
+ return false;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md
new file mode 100644
index 00000000000..e0c0a058982
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md
@@ -0,0 +1,215 @@
+---
+id: a7f4d8f2483413a6ce226cac
+title: Konverter für römische Zahlen
+challengeType: 5
+forumTopicId: 16044
+dashedName: roman-numeral-converter
+---
+
+# --description--
+
+Konvertiere die übergebene Zahl in eine römische Zahl.
+
+| Römische Ziffern | Arabische Ziffern |
+| ---------------- | ----------------- |
+| M | 1000 |
+| CM | 900 |
+| D | 500 |
+| CD | 400 |
+| C | 100 |
+| XC | 90 |
+| L | 50 |
+| XL | 40 |
+| X | 10 |
+| IX | 9 |
+| V | 5 |
+| IV | 4 |
+| I | 1 |
+
+Alle Antworten mit römischen Ziffern sind in Großbuchstaben anzugeben.
+
+# --hints--
+
+`convertToRoman(2)` sollte den String `II` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(2), 'II');
+```
+
+`convertToRoman(3)` sollte den String `III` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(3), 'III');
+```
+
+`convertToRoman(4)` sollte den String `IV` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(4), 'IV');
+```
+
+`convertToRoman(5)` sollte den String `V` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(5), 'V');
+```
+
+`convertToRoman(9)` sollte den String `IX` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(9), 'IX');
+```
+
+`convertToRoman(12)` sollte den String `XII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(12), 'XII');
+```
+
+`convertToRoman(16)` sollte den String `XVI` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(16), 'XVI');
+```
+
+`convertToRoman(29)` sollte den String `XXIX` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(29), 'XXIX');
+```
+
+`convertToRoman(44)` sollte den String `XLIV` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(44), 'XLIV');
+```
+
+`convertToRoman(45)` sollte den String `XLV` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(45), 'XLV');
+```
+
+`convertToRoman(68)` sollte den String `LXVIII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(68), 'LXVIII');
+```
+
+`convertToRoman(83)` sollte den String `LXXXIII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(83), 'LXXXIII');
+```
+
+`convertToRoman(97)` sollte den String `XCVII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(97), 'XCVII');
+```
+
+`convertToRoman(99)` sollte den String `XCIX` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(99), 'XCIX');
+```
+
+`convertToRoman(400)` sollte den String `CD` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(400), 'CD');
+```
+
+`convertToRoman(500)` sollte den String `D` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(500), 'D');
+```
+
+`convertToRoman(501)` sollte den String `DI` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(501), 'DI');
+```
+
+`convertToRoman(649)` sollte den String `DCXLIX` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(649), 'DCXLIX');
+```
+
+`convertToRoman(798)` sollte den String `DCCXCVIII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(798), 'DCCXCVIII');
+```
+
+`convertToRoman(891)` sollte den String `DCCCXCI` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(891), 'DCCCXCI');
+```
+
+`convertToRoman(1000)` sollte den String `M` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(1000), 'M');
+```
+
+`convertToRoman(1004)` sollte den String `MIV` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(1004), 'MIV');
+```
+
+`convertToRoman(1006)` sollte den String `MVI` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(1006), 'MVI');
+```
+
+`convertToRoman(1023)` sollte den String `MXXIII` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(1023), 'MXXIII');
+```
+
+`convertToRoman(2014)` sollte den String `MMXIV` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(2014), 'MMXIV');
+```
+
+`convertToRoman(3999)` sollte den String `MMMCMXCIX` zurückgeben.
+
+```js
+assert.deepEqual(convertToRoman(3999), 'MMMCMXCIX');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToRoman(num) {
+ return num;
+}
+
+convertToRoman(36);
+```
+
+# --solutions--
+
+```js
+function convertToRoman(num) {
+ var ref = [['M', 1000], ['CM', 900], ['D', 500], ['CD', 400], ['C', 100], ['XC', 90], ['L', 50], ['XL', 40], ['X', 10], ['IX', 9], ['V', 5], ['IV', 4], ['I', 1]];
+ var res = [];
+ ref.forEach(function(p) {
+ while (num >= p[1]) {
+ res.push(p[0]);
+ num -= p[1];
+ }
+ });
+ return res.join('');
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md
new file mode 100644
index 00000000000..c44a4a622af
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md
@@ -0,0 +1,217 @@
+---
+id: aff0395860f5d3034dc0bfc9
+title: Telefonnummern-Prüfer
+challengeType: 5
+forumTopicId: 16090
+dashedName: telephone-number-validator
+---
+
+# --description--
+
+Gebe `true` zurück, wenn der übergebene String wie eine gültige US-Telefonnummer aussieht.
+
+Der Benutzer kann das Formularfeld beliebig ausfüllen, solange es das Format einer gültigen US-Nummer hat. Im Folgenden sind Beispiele für gültige Formate für US-Nummern aufgeführt (für andere Alternativen siehe Tests unten):
+
+555-555-5555
+
+Für diese Aufgabe wird dir ein String wie `800-692-7753` oder `8oo-six427676;laskdjf` angezeigt. Deine Aufgabe ist es, die US-Telefonnummer anhand einer Kombination der oben angegebenen Formate zu bestätigen oder abzulehnen. Die Vorwahl ist erforderlich. Wenn die Landesvorwahl angegeben ist, musst du bestätigen, dass die Landesvorwahl `1` ist. Gib `true` aus, wenn der String eine gültige US-Telefonnummer ist; ansonsten soll `false` ausgegeben werden.
+
+# --hints--
+
+`telephoneCheck("555-555-5555")` soll einen Boolean zurückgeben.
+
+```js
+assert(typeof telephoneCheck('555-555-5555') === 'boolean');
+```
+
+`telephoneCheck("1 555-555-5555")` soll `true` zurückgeben.
+
+```js
+assert(telephoneCheck('1 555-555-5555') === true);
+```
+
+`telephoneCheck("1 (555) 555-5555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('1 (555) 555-5555') === true);
+```
+
+`telephoneCheck("5555555555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('5555555555') === true);
+```
+
+`telephoneCheck("555-555-5555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('555-555-5555') === true);
+```
+
+`telephoneCheck("(555)555-5555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('(555)555-5555') === true);
+```
+
+`telephoneCheck("1(555)555-5555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('1(555)555-5555') === true);
+```
+
+`telephoneCheck("555-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('555-5555') === false);
+```
+
+`telephoneCheck("5555555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('5555555') === false);
+```
+
+`telephoneCheck("1 555)555-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('1 555)555-5555') === false);
+```
+
+`telephoneCheck("1 555 555 5555")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('1 555 555 5555') === true);
+```
+
+`telephoneCheck("1 456 789 4444")` sollte `true` zurückgeben.
+
+```js
+assert(telephoneCheck('1 456 789 4444') === true);
+```
+
+`telephoneCheck("123**&!!asdf#")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('123**&!!asdf#') === false);
+```
+
+`telephoneCheck("55555555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('55555555') === false);
+```
+
+`telephoneCheck("(6054756961)")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('(6054756961)') === false);
+```
+
+`telephoneCheck("2 (757) 622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('2 (757) 622-7382') === false);
+```
+
+`telephoneCheck("0 (757) 622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('0 (757) 622-7382') === false);
+```
+
+`telephoneCheck("-1 (757) 622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('-1 (757) 622-7382') === false);
+```
+
+`telephoneCheck("2 757 622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('2 757 622-7382') === false);
+```
+
+`telephoneCheck("10 (757) 622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('10 (757) 622-7382') === false);
+```
+
+`telephoneCheck("27576227382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('27576227382') === false);
+```
+
+`telephoneCheck("(275)76227382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('(275)76227382') === false);
+```
+
+`telephoneCheck("2(757)6227382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('2(757)6227382') === false);
+```
+
+`telephoneCheck("2(757)622-7382")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('2(757)622-7382') === false);
+```
+
+`telephoneCheck("555)-555-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('555)-555-5555') === false);
+```
+
+`telephoneCheck("(555-555-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('(555-555-5555') === false);
+```
+
+`telephoneCheck("(555)5(55?)-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('(555)5(55?)-5555') === false);
+```
+
+`telephoneCheck("55 55-55-555-5")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('55 55-55-555-5') === false);
+```
+
+`telefoncheck("11 555-555-5555")` sollte `false` zurückgeben.
+
+```js
+assert(telephoneCheck('11 555-555-5555') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function telephoneCheck(str) {
+ return true;
+}
+
+telephoneCheck("555-555-5555");
+```
+
+# --solutions--
+
+```js
+var re = /^([+]?1[\s]?)?((?:[(](?:[2-9]1[02-9]|[2-9][02-8][0-9])[)][\s]?)|(?:(?:[2-9]1[02-9]|[2-9][02-8][0-9])[\s.-]?)){1}([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2}[\s.-]?){1}([0-9]{4}){1}$/;
+
+function telephoneCheck(str) {
+ return re.test(str);
+}
+
+telephoneCheck("555-555-5555");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md
new file mode 100644
index 00000000000..ec3968b0b27
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md
@@ -0,0 +1,133 @@
+---
+id: 587d7db1367417b2b2512b87
+title: Methoden nach der Vererbung hinzufügen
+challengeType: 1
+forumTopicId: 301315
+dashedName: add-methods-after-inheritance
+---
+
+# --description--
+
+Eine Konstruktorfunktion, die ihr `prototype`-Objekt von einer Supertyp-Konstruktorfunktion erbt, kann zusätzlich zu den geerbten Methoden noch eigene Methoden besitzen.
+
+Zum Beispiel ist `Bird` ein Konstruktor, der seinen `prototype` von `Animal` erbt:
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() {
+ console.log("nom nom nom");
+};
+function Bird() { }
+Bird.prototype = Object.create(Animal.prototype);
+Bird.prototype.constructor = Bird;
+```
+
+Zusätzlich zu dem, was von `Animal` geerbt wird, möchtest du ein Verhalten hinzufügen, das nur für `Bird`-Objekte gilt. Hier bekommt `Bird` eine Funktion `fly()`. Funktionen werden dem `Bird's`-`prototype` auf die gleiche Weise hinzugefügt wie jede Konstruktorfunktion:
+
+```js
+Bird.prototype.fly = function() {
+ console.log("I'm flying!");
+};
+```
+
+Jetzt haben Instanzen von `Bird` sowohl die Methoden `eat()` als auch `fly()`:
+
+```js
+let duck = new Bird();
+duck.eat();
+duck.fly();
+```
+
+`duck.eat()` würde den String `nom nom nom` in der Konsole anzeigen und `duck.fly()` würde den String `I'm flying!` anzeigen.
+
+# --instructions--
+
+Füge den notwendigen Code hinzu, damit das `Dog`-. Objekt von `Animal` erbt und der `prototype`-Konstruktor von `Dog` auf `Dog` gesetzt wird. Dann füge dem `Dog`-Objekt eine Methode `bark()` hinzu, damit `beagle` sowohl `eat()` als auch `bark()` kann. Die Methode `bark()` sollte `Woof!` auf der Konsole ausgeben.
+
+# --hints--
+
+`Animal` sollte nicht auf die Methode `bark()` reagieren.
+
+```js
+assert(typeof Animal.prototype.bark == 'undefined');
+```
+
+`Dog` sollte die Methode `eat()` von `Animal` erben.
+
+```js
+assert(typeof Dog.prototype.eat == 'function');
+```
+
+Der `Dog`-Prototyp sollte eine Methode `bark()` besitzen.
+
+```js
+assert('bark' in Dog.prototype);
+```
+
+`beagle` sollte eine Instanz (`instanceof`) von `Animal` sein.
+
+```js
+assert(beagle instanceof Animal);
+```
+
+Der Konstruktor für `beagle` sollte auf `Dog` gesetzt werden.
+
+```js
+assert(beagle.constructor === Dog);
+```
+
+`beagle.eat()` sollte den String `nom nom nom` in der Konsole ausgeben.
+
+```js
+console.log = function (msg) {
+ throw msg;
+};
+assert.throws(() => beagle.eat(), 'nom nom nom');
+```
+
+`beagle.bark()` sollte den String `Woof!` in der Konsole ausgeben.
+
+```js
+console.log = function (msg) {
+ throw msg;
+};
+assert.throws(() => beagle.bark(), 'Woof!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() { console.log("nom nom nom"); };
+
+function Dog() { }
+
+// Only change code below this line
+
+
+
+
+// Only change code above this line
+
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() { console.log("nom nom nom"); };
+
+function Dog() { }
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.constructor = Dog;
+Dog.prototype.bark = function () {
+ console.log('Woof!');
+};
+let beagle = new Dog();
+
+beagle.eat();
+beagle.bark();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md
new file mode 100644
index 00000000000..989bc9fcdf2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md
@@ -0,0 +1,103 @@
+---
+id: 587d7daf367417b2b2512b7f
+title: Ändere den Prototyp in ein neues Objekt
+challengeType: 1
+forumTopicId: 301316
+dashedName: change-the-prototype-to-a-new-object
+---
+
+# --description--
+
+Bisher hast du die Eigenschaften des `prototype` einzeln hinzugefügt:
+
+```js
+Bird.prototype.numLegs = 2;
+```
+
+Das wird nach mehr als ein paar Eigenschaften mühsam.
+
+```js
+Bird.prototype.eat = function() {
+ console.log("nom nom nom");
+}
+
+Bird.prototype.describe = function() {
+ console.log("My name is " + this.name);
+}
+```
+
+Eine effizientere Methode ist es, den `prototype` auf ein neues Objekt zu setzen, das die Eigenschaften bereits enthält. Auf diese Weise werden die Eigenschaften alle auf einmal hinzugefügt:
+
+```js
+Bird.prototype = {
+ numLegs: 2,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --instructions--
+
+Füge die Eigenschaft `numLegs` und die beiden Methoden `eat()` und `describe()` zu dem `prototype` von `Dog` hinzu, indem du den `prototype` auf ein neues Objekt setzt.
+
+# --hints--
+
+`Dog.prototype` sollte auf ein neues Objekt gesetzt werden.
+
+```js
+assert(/Dog\.prototype\s*?=\s*?{/.test(code));
+```
+
+`Dog.prototype` sollte die Eigenschaft `numLegs` besitzen.
+
+```js
+assert(Dog.prototype.numLegs !== undefined);
+```
+
+`Dog.prototype` sollte die Methode `eat()` enthalten.
+
+```js
+assert(typeof Dog.prototype.eat === 'function');
+```
+
+`Dog.prototype` sollte die Methode `describe()` enthalten.
+
+```js
+assert(typeof Dog.prototype.describe === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype = {
+ // Only change code below this line
+
+};
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+Dog.prototype = {
+numLegs: 4,
+ eat () {
+ console.log('nom nom nom');
+ },
+ describe () {
+ console.log('My name is ' + this.name);
+ }
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md
new file mode 100644
index 00000000000..a7d249a19cd
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md
@@ -0,0 +1,69 @@
+---
+id: 587d7dac367417b2b2512b73
+title: Erstelle ein einfaches JavaScript-Objekt
+challengeType: 1
+forumTopicId: 301317
+dashedName: create-a-basic-javascript-object
+---
+
+# --description--
+
+Denke an Dinge, die Menschen jeden Tag sehen, wie Autos, Geschäfte und Vögel. Das alles sind Objekte : greifbare Dinge, die Menschen beobachten und mit denen sie interagieren können.
+
+Was sind einige Eigenschaften dieser Objekte? Ein Auto hat Räder. Geschäfte verkaufen Gegenstände. Vögel haben Flügel.
+
+Diese Merkmale, oder Eigenschaften , definieren, was ein Objekt ausmacht. Beachte, dass ähnliche Objekte die gleichen Eigenschaften haben, aber unterschiedliche Werte für diese Eigenschaften haben können. Zum Beispiel haben alle Autos Räder, aber nicht alle Autos haben die gleiche Anzahl von Rädern.
+
+Objekte in JavaScript werden verwendet, um reale Objekte zu modellieren und ihnen Eigenschaften und Verhaltensweisen zu geben, die denen ihrer realen Gegenstücke entsprechen. Hier ist ein Beispiel, das diese Konzepte verwendet, um ein Objekt "Ente"(`duck`) zu erstellen:
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2
+};
+```
+
+Dieses Objekt `duck` hat zwei Eigenschaften/Wertpaare: einen Namen (`name`) von `Aflac` und eine Anzahl Beine (`numLegs`) von 2.
+
+# --instructions--
+
+Erstelle ein Objekt `dog` mit den Eigenschaften `name` und `numLegs` und setze sie auf einen String bzw. eine Zahl.
+
+# --hints--
+
+`dog` sollte ein Objekt sein.
+
+```js
+assert(typeof dog === 'object');
+```
+
+`dog` sollte eine Eigenschaft `name` besitzen, die auf einen String gesetzt ist.
+
+```js
+assert(typeof dog.name === 'string');
+```
+
+`dog` sollte eine Eigenschaft `numLegs` besitzen, die auf eine Zahl gesetzt ist.
+
+```js
+assert(typeof dog.numLegs === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+
+};
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: '',
+ numLegs: 4
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md
new file mode 100644
index 00000000000..eb6b857e150
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md
@@ -0,0 +1,70 @@
+---
+id: 587d7dad367417b2b2512b75
+title: Erstelle eine Methode für ein Objekt
+challengeType: 1
+forumTopicId: 301318
+dashedName: create-a-method-on-an-object
+---
+
+# --description--
+
+Objekte können eine besondere Art von Eigenschaft haben, die Methode genannt wird.
+
+Methoden sind Eigenschaften, die Funktionen sind. Dies fügt einem Objekt ein anderes Verhalten hinzu. Hier ist das Beispiel `duck` mit einer Methode:
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2,
+ sayName: function() {return "The name of this duck is " + duck.name + ".";}
+};
+duck.sayName();
+```
+
+Das Beispiel fügt die Methode `sayName` hinzu, die eine Funktion ist, die einen Satz mit dem Namen der Ente (`duck`) zurückgibt. Beachte, dass die Methode in der Rückgabeanweisung mit `duck.name` auf die Eigenschaft `name` zugreift. Die nächste Aufgabe befasst sich mit einer anderen Möglichkeit, dies zu tun.
+
+# --instructions--
+
+Benutze das Objekt `dog` und gib ihm eine Methode namens `sayLegs`. Die Methode sollte den Satz `This dog has 4 legs.` zurückgeben.
+
+# --hints--
+
+`dog.sayLegs()` sollte eine Funktion sein.
+
+```js
+assert(typeof dog.sayLegs === 'function');
+```
+
+`dog.sayLegs()` sollte den angegebenen String zurückgeben - beachte, dass Satzzeichen und Abstände wichtig sind.
+
+```js
+assert(dog.sayLegs() === 'This dog has 4 legs.');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+
+};
+
+dog.sayLegs();
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs () {
+ return 'This dog has ' + this.numLegs + ' legs.';
+ }
+};
+
+dog.sayLegs();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md
new file mode 100644
index 00000000000..b8ffa5df46b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md
@@ -0,0 +1,67 @@
+---
+id: 587d7dad367417b2b2512b77
+title: Definiere eine Konstruktorfunktion
+challengeType: 1
+forumTopicId: 16804
+dashedName: define-a-constructor-function
+---
+
+# --description--
+
+Konstruktoren sind Funktionen, die neue Objekte erzeugen. Sie definieren Eigenschaften und Verhaltensweisen, die zu dem neuen Objekt gehören werden. Betrachte sie als eine Vorlage für die Erstellung von neuen Objekten.
+
+Hier ist ein Beispiel für einen Konstruktor:
+
+```js
+function Bird() {
+ this.name = "Albert";
+ this.color = "blue";
+ this.numLegs = 2;
+}
+```
+
+Dieser Konstruktor definiert ein Objekt `Bird` mit den Eigenschaften `name`, `color` und `numLegs`, die jeweils auf Albert, blue und 2 gesetzt sind. Konstruktoren folgen ein paar Konventionen:
+
+Konstruktoren werden mit einem großgeschriebenen Namen definiert, um sie von anderen Funktionen zu unterscheiden, die keine constructors sind. Konstruktoren verwenden das Schlüsselwort this, um Eigenschaften des Objekts zu setzen, das sie erzeugen werden. Innerhalb des Konstruktors verweist this auf das neue Objekt, das erstellt wird. Konstruktoren definieren Eigenschaften und Verhaltensweisen, anstatt einen Wert zurückzugeben, wie es andere Funktionen können. Eigene Eigenschaften und Prototyp (`prototype`)-Eigenschaften. Eigene Eigenschaften werden direkt in der Objektinstanz selbst definiert. Und die Prototypeigenschaften werden im `prototype` definiert.
+
+```js
+function Bird(name) {
+ this.name = name; //own property
+}
+
+Bird.prototype.numLegs = 2; // prototype property
+
+let duck = new Bird("Donald");
+```
+
+So fügst du die eigenen Eigenschaften von `duck` in das Array `ownProps` und die Eigenschaften von `prototype` in das Array `prototypeProps` ein:
+
+```js
+let ownProps = [];
+let prototypeProps = [];
+
+for (let property in duck) {
+ if(duck.hasOwnProperty(property)) {
+ ownProps.push(property);
+ } else {
+ prototypeProps.push(property);
+ }
+}
+
+console.log(ownProps);
+console.log(prototypeProps);
+```
+
+`console.log(ownProps)` würde `["name"]` in der Konsole anzeigen, und `console.log(prototypeProps)` würde `["numLegs"]` anzeigen.
+
+# --instructions--
+
+Füge alle eigenen Eigenschaften von `beagle` zu dem Array `ownProps` hinzu. Füge alle `prototype`-Eigenschaften von `Dog` zum Array `prototypeProps` hinzu.
+
+# --hints--
+
+Das Array `ownProps` sollte nur `name` enthalten.
+
+```js
+assert.deepEqual(ownProps, ['name']);
+```
+
+Das Array `prototypeProps` sollte nur `numLegs` enthalten.
+
+```js
+assert.deepEqual(prototypeProps, ['numLegs']);
+```
+
+Du solltest diese Aufgabe lösen, ohne die eingebaute Methode `Object.keys()` zu verwenden.
+
+```js
+assert(!/\Object.keys/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype.numLegs = 4;
+
+let beagle = new Dog("Snoopy");
+
+let ownProps = [];
+let prototypeProps = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype.numLegs = 4;
+
+let beagle = new Dog("Snoopy");
+
+let ownProps = [];
+let prototypeProps = [];
+for (let prop in beagle) {
+ if (beagle.hasOwnProperty(prop)) {
+ ownProps.push(prop);
+ } else {
+ prototypeProps.push(prop);
+ }
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md
new file mode 100644
index 00000000000..5e70ec782d3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md
@@ -0,0 +1,75 @@
+---
+id: 587d7dad367417b2b2512b76
+title: Erstelle wiederverwendbaren Code mit dem Schlüsselwort "this"
+challengeType: 1
+forumTopicId: 301321
+dashedName: make-code-more-reusable-with-the-this-keyword
+---
+
+# --description--
+
+In der letzten Aufgabe wurde eine Methode für das Objekt `duck` eingeführt. Es verwendet die Punktnotation `duck.name`, um auf den Wert der Eigenschaft `name` innerhalb der Rückgabeanweisung zuzugreifen:
+
+```js
+sayName: function() {return "The name of this duck is " + duck.name + ".";}
+```
+
+Das ist zwar eine zulässige Möglichkeit, auf die Eigenschaft des Objekts zuzugreifen, aber es gibt einen Haken. Wenn sich der Variablenname ändert, muss jeder Code, der auf den ursprünglichen Namen verweist, ebenfalls aktualisiert werden. Bei einer kurzen Objektdefinition ist das kein Problem, aber wenn ein Objekt viele Verweise auf seine Eigenschaften hat, ist die Wahrscheinlichkeit für Fehler größer.
+
+Eine Möglichkeit, diese Probleme zu vermeiden, ist das Schlüsselwort `this`:
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2,
+ sayName: function() {return "The name of this duck is " + this.name + ".";}
+};
+```
+
+`this` ist ein umfangreiches Thema, und das obige Beispiel ist nur eine Möglichkeit, es zu nutzen. Im aktuellen Kontext bezieht sich `this` auf das Objekt, mit dem die Methode verbunden ist: `duck`. Wenn der Name des Objekts in `mallard` geändert wird, ist es nicht nötig, alle Verweise auf `duck` im Code zu finden. Das macht den Code wiederverwendbar und einfacher zu lesen.
+
+# --instructions--
+
+Ändere die Methode `dog.sayLegs`, um alle Verweise auf `dog` zu entfernen. Nimm das Beispiel von `duck` zur Hilfe.
+
+# --hints--
+
+`dog.sayLegs()` sollte den vorgegebenen String zurückgeben.
+
+```js
+assert(dog.sayLegs() === 'This dog has 4 legs.');
+```
+
+Dein Code sollte das Schlüsselwort `this` verwenden, um auf die Eigenschaft `numLegs` von `dog` zuzugreifen.
+
+```js
+assert(code.match(/this\.numLegs/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs: function() {return "This dog has " + dog.numLegs + " legs.";}
+};
+
+dog.sayLegs();
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs () {
+ return 'This dog has ' + this.numLegs + ' legs.';
+ }
+};
+
+dog.sayLegs();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md
new file mode 100644
index 00000000000..4c0bfc2bfb1
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md
@@ -0,0 +1,100 @@
+---
+id: 587d7db1367417b2b2512b88
+title: Geerbte Methoden überschreiben
+challengeType: 1
+forumTopicId: 301322
+dashedName: override-inherited-methods
+---
+
+# --description--
+
+In den vorherigen Aufgaben hast du gelernt, dass ein Objekt sein Verhalten (Methoden) von einem anderen Objekt erben kann, indem es dessen `prototype`-Objekt referenziert:
+
+```js
+ChildObject.prototype = Object.create(ParentObject.prototype);
+```
+
+Dann erhielt das Kindobjekt (`ChildObject`) seine eigenen Methoden, indem es sie mit seinem `prototype` verkettete:
+
+```js
+ChildObject.prototype.methodName = function() {...};
+```
+
+Es ist möglich, eine geerbte Methode außer Kraft zu setzen. Das geht auf die gleiche Weise - indem du eine Methode zu `ChildObject.prototype` hinzufügst, die den gleichen Namen trägt wie die Methode, die überschrieben werden soll. Hier ist ein Beispiel für `Bird`, das die von `Animal` geerbte Methode `eat()` überschreibt:
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() {
+ return "nom nom nom";
+};
+function Bird() { }
+
+Bird.prototype = Object.create(Animal.prototype);
+
+Bird.prototype.eat = function() {
+ return "peck peck peck";
+};
+```
+
+Wenn du eine Instanz `let duck = new Bird();` hast und du rufst `duck.eat()` auf, so sucht JavaScript die Methode in der `prototype`-Kette von `duck`:
+
+1. `duck` => Ist `eat()` hier definiert? Nein.
+2. `Bird` => Ist `eat()` hier definiert? => Ja. Führe sie aus und höre auf zu suchen.
+3. `Animal` => `eat()` ist auch definiert, aber JavaScript hat die Suche abgebrochen, bevor diese Ebene erreicht wurde.
+4. Object => JavaScript hat die Suche vor Erreichen dieses Levels beendet.
+
+# --instructions--
+
+Überschreibe die Methode `fly()` für `Penguin` so, dass sie den String `Alas, this is a flightless bird.` zurückgibt.
+
+# --hints--
+
+`penguin.fly()` sollte den String `Alas, this is a flightless bird.` zurückgeben.
+
+```js
+assert(penguin.fly() === 'Alas, this is a flightless bird.');
+```
+
+Die Methode `bird.fly()` sollte den String `I am flying!` zurückgeben.
+
+```js
+assert(new Bird().fly() === 'I am flying!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird() { }
+
+Bird.prototype.fly = function() { return "I am flying!"; };
+
+function Penguin() { }
+Penguin.prototype = Object.create(Bird.prototype);
+Penguin.prototype.constructor = Penguin;
+
+// Only change code below this line
+
+
+
+// Only change code above this line
+
+let penguin = new Penguin();
+console.log(penguin.fly());
+```
+
+# --solutions--
+
+```js
+function Bird() { }
+
+Bird.prototype.fly = function() { return "I am flying!"; };
+
+function Penguin() { }
+Penguin.prototype = Object.create(Bird.prototype);
+Penguin.prototype.constructor = Penguin;
+Penguin.prototype.fly = () => 'Alas, this is a flightless bird.';
+let penguin = new Penguin();
+console.log(penguin.fly());
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md
new file mode 100644
index 00000000000..f4948b5537e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md
@@ -0,0 +1,86 @@
+---
+id: 587d7daf367417b2b2512b80
+title: Denke daran, die Konstruktoreigenschaft zu setzen, wenn du den Prototyp änderst
+challengeType: 1
+forumTopicId: 301323
+dashedName: remember-to-set-the-constructor-property-when-changing-the-prototype
+---
+
+# --description--
+
+Es gibt einen entscheidenden Nebeneffekt, wenn du den Prototyp manuell auf ein neues Objekt setzt. Es löscht die`constructor` Eigenschaft! Diese Eigenschaft kann verwendet werden, um zu prüfen, welche Konstruktorfunktion die Instanz erstellt hat. Da die Eigenschaft jedoch überschrieben wurde, liefert sie jetzt falsche Ergebnisse:
+
+```js
+duck.constructor === Bird;
+duck.constructor === Object;
+duck instanceof Bird;
+```
+
+In dieser Reihenfolge würden diese Ausdrücke `false`, `true` und `true` ergeben.
+
+Um dies zu beheben, musst du jedes Mal, wenn ein Prototyp manuell auf ein neues Objekt gesetzt wird, daran denken, die `constructor`-Eigenschaft zu definieren:
+
+```js
+Bird.prototype = {
+ constructor: Bird,
+ numLegs: 2,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --instructions--
+
+Definiere die `constructor`-Eigenschaft in dem `Dog` `prototype`.
+
+# --hints--
+
+`Dog.prototype` sollte die `constructor`-Eigenschaft setzen.
+
+```js
+assert(Dog.prototype.constructor === Dog);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+// Only change code below this line
+Dog.prototype = {
+
+ numLegs: 4,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+Dog.prototype = {
+ constructor: Dog,
+ numLegs: 4,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md
new file mode 100644
index 00000000000..29c194927ba
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md
@@ -0,0 +1,91 @@
+---
+id: 587d7db1367417b2b2512b86
+title: Setze eine geerbte Konstruktoreigenschaft zurück
+challengeType: 1
+forumTopicId: 301324
+dashedName: reset-an-inherited-constructor-property
+---
+
+# --description--
+
+Wenn ein Objekt seinen `prototype` von einem anderen Objekt erbt, erbt es auch die Konstruktoreigenschaft des Supertyps.
+
+Hier ist ein Beispiel:
+
+```js
+function Bird() { }
+Bird.prototype = Object.create(Animal.prototype);
+let duck = new Bird();
+duck.constructor
+```
+
+Aber `duck` und alle Instanzen von `Bird` sollten zeigen, dass sie von `Bird` und nicht von `Animal` erstellt wurden. Dazu kannst du die Konstruktor-Eigenschaft von `Bird` manuell auf das `Bird`-Objekt setzen:
+
+```js
+Bird.prototype.constructor = Bird;
+duck.constructor
+```
+
+# --instructions--
+
+Korrigiere den Code, damit `duck.constructor` und `beagle.constructor` ihre jeweiligen Konstruktoren zurückgeben.
+
+# --hints--
+
+`Bird.prototype` sollte eine Instanz von `Animal` sein.
+
+```js
+assert(Animal.prototype.isPrototypeOf(Bird.prototype));
+```
+
+Der `duck.constructor` sollte `Bird` zurückgeben.
+
+```js
+assert(duck.constructor === Bird);
+```
+
+`Dog.prototype` sollte eine Instanz von `Animal` sein.
+
+```js
+assert(Animal.prototype.isPrototypeOf(Dog.prototype));
+```
+
+`beagle.constructor` sollte `Dog` zurückgeben.
+
+```js
+assert(beagle.constructor === Dog);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+function Bird() { }
+function Dog() { }
+
+Bird.prototype = Object.create(Animal.prototype);
+Dog.prototype = Object.create(Animal.prototype);
+
+// Only change code below this line
+
+
+
+let duck = new Bird();
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+function Bird() { }
+function Dog() { }
+Bird.prototype = Object.create(Animal.prototype);
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.constructor = Dog;
+Bird.prototype.constructor = Bird;
+let duck = new Bird();
+let beagle = new Dog();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md
new file mode 100644
index 00000000000..ac2800a5d7f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md
@@ -0,0 +1,79 @@
+---
+id: 587d7db1367417b2b2512b85
+title: Setze den Prototyp des Kindes auf eine Instanz des Elternteils
+challengeType: 1
+forumTopicId: 301325
+dashedName: set-the-childs-prototype-to-an-instance-of-the-parent
+---
+
+# --description--
+
+In der vorherigen Aufgabe hast du den ersten Schritt gesehen, um das Verhalten vom Supertyp (oder Elterntyp) `Animal` zu erben: Erstelle eine neue Instanz von `Animal`.
+
+In dieser Aufgabe geht es um den nächsten Schritt: Setze den `prototype` des Subtyps (oder Kindes) - in diesem Fall `Bird` - auf eine Instanz von `Animal`.
+
+```js
+Bird.prototype = Object.create(Animal.prototype);
+```
+
+Denke daran, dass der `prototype` so etwas wie das "Rezept" für die Erstellung eines Objekts ist. In gewisser Weise enthält das Rezept für `Bird` jetzt alle wichtigen "Zutaten" von `Animal`.
+
+```js
+let duck = new Bird("Donald");
+duck.eat();
+```
+
+`duck` erbt alle Eigenschaften von `Animal`, einschließlich der Methode `eat`.
+
+# --instructions--
+
+Ändere den Code so, dass Instanzen von `Dog` von `Animal` erben.
+
+# --hints--
+
+`Dog.prototype` sollte eine Instanz von `Animal` sein.
+
+```js
+assert(Animal.prototype.isPrototypeOf(Dog.prototype));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Dog() { }
+
+// Only change code below this line
+
+
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Dog() { }
+Dog.prototype = Object.create(Animal.prototype);
+
+let beagle = new Dog();
+beagle.eat();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md
new file mode 100644
index 00000000000..3f22c0caab7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md
@@ -0,0 +1,104 @@
+---
+id: 587d7dae367417b2b2512b7b
+title: Eigene Eigenschaften verstehen
+challengeType: 1
+forumTopicId: 301326
+dashedName: understand-own-properties
+---
+
+# --description--
+
+Im folgenden Beispiel definiert der Konstruktor `Bird` zwei Eigenschaften: `name` und `numLegs`:
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let duck = new Bird("Donald");
+let canary = new Bird("Tweety");
+```
+
+`name` und `numLegs` werden eigene Eigenschaften genannt, weil sie direkt im Instanzobjekt definiert sind. Das bedeutet, dass `duck` und `canary` jeweils eine eigene Kopie dieser Eigenschaften besitzen. Tatsächlich hat jede Instanz von `Bird` ihre eigene Kopie dieser Eigenschaften. Der folgende Code fügt alle eigenen Eigenschaften von `duck` zu dem Array `ownProps` hinzu:
+
+```js
+let ownProps = [];
+
+for (let property in duck) {
+ if(duck.hasOwnProperty(property)) {
+ ownProps.push(property);
+ }
+}
+
+console.log(ownProps);
+```
+
+Die Konsole würde den Wert `["name", "numLegs"]` anzeigen.
+
+# --instructions--
+
+Füge die eigenen Eigenschaften von `canary` dem Array `ownProps` hinzu.
+
+# --hints--
+
+`ownProps` sollte die Werte `numLegs` und `name` enthalten.
+
+```js
+assert(ownProps.indexOf('name') !== -1 && ownProps.indexOf('numLegs') !== -1);
+```
+
+Du solltest diese Aufgabe lösen, ohne die eingebaute Methode `Object.keys()` zu verwenden.
+
+```js
+assert(!/Object(\.keys|\[(['"`])keys\2\])/.test(code));
+```
+
+Du solltest diese Aufgabe lösen, ohne das Array `ownProps` fest zu kodieren.
+
+```js
+assert(
+ !/\[\s*(?:'|")(?:name|numLegs)|(?:push|concat)\(\s*(?:'|")(?:name|numLegs)/.test(
+ code
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let canary = new Bird("Tweety");
+let ownProps = [];
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let canary = new Bird("Tweety");
+function getOwnProps (obj) {
+ const props = [];
+
+ for (let prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ props.push(prop);
+ }
+ }
+
+ return props;
+}
+
+const ownProps = getOwnProps(canary);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md
new file mode 100644
index 00000000000..b916da7d439
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md
@@ -0,0 +1,85 @@
+---
+id: 587d7daf367417b2b2512b7e
+title: Die Konstruktor-Eigenschaft verstehen
+challengeType: 1
+forumTopicId: 301327
+dashedName: understand-the-constructor-property
+---
+
+# --description--
+
+Es gibt eine spezielle Konstruktion (`constructor`)-Eigenschaft, die sich in den Objektinstanzen `duck` und `beagle` befindet, die in den vorherigen Aufgaben erstellt wurden:
+
+```js
+let duck = new Bird();
+let beagle = new Dog();
+
+console.log(duck.constructor === Bird);
+console.log(beagle.constructor === Dog);
+```
+
+Beide `console.log`-Aufrufe würden `true` in der Konsole anzeigen.
+
+Beachte, dass die Eigenschaft `constructor` ein Verweis auf die Konstruktorfunktion ist, die die Instanz erstellt hat. Der Vorteil der `constructor`-Eigenschaft ist, dass es möglich ist, nach dieser Eigenschaft zu suchen, um herauszufinden, um welche Art von Objekt es sich handelt. Hier ist ein Beispiel dafür, wie dies genutzt werden könnte:
+
+```js
+function joinBirdFraternity(candidate) {
+ if (candidate.constructor === Bird) {
+ return true;
+ } else {
+ return false;
+ }
+}
+```
+
+**Hinweis:** Da die `constructor`-Eigenschaft überschrieben werden kann (was in den nächsten beiden Aufgaben behandelt wird), ist es im Allgemeinen besser, die `instanceof`-Methode zu verwenden, um den Typ eines Objekts zu überprüfen.
+
+# --instructions--
+
+Schreibe eine Funktion `joinDogFraternity`, die einen `candidate` als Parameter annimmt und mithilfe der `constructor`-Eigenschaft `true` zurückgibt, wenn der Kandidat ein Hund (`Dog`) ist, andernfalls `false`.
+
+# --hints--
+
+`joinDogFraternity` sollte als Funktion definiert werden.
+
+```js
+assert(typeof joinDogFraternity === 'function');
+```
+
+`joinDogFraternity` sollte `true` zurückgeben, wenn `candidate` eine Instanz von `Dog` ist.
+
+```js
+assert(joinDogFraternity(new Dog('')) === true);
+```
+
+`joinDogFraternity` sollte die `constructor`-Eigenschaft verwenden.
+
+```js
+assert(/\.constructor/.test(code) && !/instanceof/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+// Only change code below this line
+function joinDogFraternity(candidate) {
+
+}
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+function joinDogFraternity(candidate) {
+ return candidate.constructor === Dog;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md
new file mode 100644
index 00000000000..237898a14ca
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md
@@ -0,0 +1,83 @@
+---
+id: 587d7db2367417b2b2512b8b
+title: Verstehe den sofort aufgerufenen Funktions-Ausdruck (Immediately Invoked Function Expression (IIFE))
+challengeType: 1
+forumTopicId: 301328
+dashedName: understand-the-immediately-invoked-function-expression-iife
+---
+
+# --description--
+
+Ein gängiges Muster in JavaScript ist es, eine Funktion auszuführen, sobald sie deklariert wird:
+
+```js
+(function () {
+ console.log("Chirp, chirp!");
+})();
+```
+
+Dies ist ein anonymer Funktionsausdruck, der sofort ausgeführt wird und sofort `Chirp, chirp!` ausgibt.
+
+Beachte, dass die Funktion keinen Namen hat und nicht in einer Variablen gespeichert ist. Die beiden Klammern () am Ende des Funktionsausdrucks bewirken, dass er sofort ausgeführt oder aufgerufen wird. Dieses Muster wird als sofort aufgerufener Funktionsausdruck oder IIFE bezeichnet.
+
+# --instructions--
+
+Schreibe die Funktion `makeNest` um und entferne ihren Aufruf, sodass sie stattdessen ein anonymer, sofort aufgerufener Funktionsausdruck (IIFE) ist.
+
+# --hints--
+
+Die Funktion sollte anonym sein.
+
+```js
+assert(/\((function|\(\))(=>|\(\)){?/.test(code.replace(/\s/g, '')));
+```
+
+Deine Funktion sollte am Ende des Ausdrucks Klammern haben, um sie sofort aufrufen zu können.
+
+```js
+assert(/\(.*(\)\(|\}\(\))\)/.test(code.replace(/[\s;]/g, '')));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function makeNest() {
+ console.log("A cozy nest is ready");
+}
+
+makeNest();
+```
+
+# --solutions--
+
+```js
+(function () {
+ console.log("A cozy nest is ready");
+})();
+```
+
+---
+
+```js
+(function () {
+ console.log("A cozy nest is ready");
+}());
+```
+
+---
+
+```js
+(() => {
+ console.log("A cozy nest is ready");
+})();
+```
+
+---
+
+```js
+(() =>
+ console.log("A cozy nest is ready")
+)();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md
new file mode 100644
index 00000000000..cd4f5db2f63
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md
@@ -0,0 +1,74 @@
+---
+id: 587d7db0367417b2b2512b82
+title: Die Prototypenkette verstehen
+challengeType: 1
+forumTopicId: 301329
+dashedName: understand-the-prototype-chain
+---
+
+# --description--
+
+Alle Objekte in JavaScript (mit ein paar Ausnahmen) haben einen Prototypen (`prototype`). Auch der `prototype` eines Objekts ist selbst ein Objekt.
+
+```js
+function Bird(name) {
+ this.name = name;
+}
+
+typeof Bird.prototype;
+```
+
+Weil ein `prototype` ein Objekt ist, kann ein `prototype` seinen eigenen `prototype` haben! In diesem Fall ist der `prototype` von `Bird.prototype` der `Object.prototype`:
+
+```js
+Object.prototype.isPrototypeOf(Bird.prototype);
+```
+
+Wie kann das hilfreich sein? Vielleicht erinnerst du dich an die Methode `hasOwnProperty` aus einer früheren Aufgabe:
+
+```js
+let duck = new Bird("Donald");
+duck.hasOwnProperty("name");
+```
+
+Die Methode `hasOwnProperty` ist in `Object.prototype` definiert, auf die `Bird.prototype` zugreifen kann, auf die wiederum `duck` zugreifen kann. Dies ist ein Beispiel für die `prototype`-Kette. In dieser `prototype`-Kette ist `Bird` der `supertype` für `duck`, während `duck` der `subtype` ist. `Object` ist ein `supertype` sowohl für `Bird` als auch für `duck`. `Object` ist ein `supertype` für alle Objekte in JavaScript. Deshalb kann jedes Objekt die Methode `hasOwnProperty` verwenden.
+
+# --instructions--
+
+Ändere den Code so ab, dass er die richtige Prototypenkette zeigt.
+
+# --hints--
+
+Dein Code sollte zeigen, dass `Object.prototype` der Prototyp von `Dog.prototype` ist.
+
+```js
+assert(/Object\.prototype\.isPrototypeOf/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+let beagle = new Dog("Snoopy");
+
+Dog.prototype.isPrototypeOf(beagle); // yields true
+
+// Fix the code below so that it evaluates to true
+???.isPrototypeOf(Dog.prototype);
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+let beagle = new Dog("Snoopy");
+Dog.prototype.isPrototypeOf(beagle);
+Object.prototype.isPrototypeOf(Dog.prototype);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md
new file mode 100644
index 00000000000..7eb89d36c21
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md
@@ -0,0 +1,63 @@
+---
+id: 587d7db0367417b2b2512b81
+title: Die Herkunft des Prototyps eines Objekts verstehen
+challengeType: 1
+forumTopicId: 301330
+dashedName: understand-where-an-objects-prototype-comes-from
+---
+
+# --description--
+
+Genau wie Menschen Gene von ihren Eltern erben, erbt ein Objekt seinen `prototype` direkt von der Konstruktionsfunktion, die es erstellt hat. Hier zum Beispiel erzeugt der `Bird`-Konstruktor das Objekt `duck`:
+
+```js
+function Bird(name) {
+ this.name = name;
+}
+
+let duck = new Bird("Donald");
+```
+
+`duck` erbt ihren `prototype` von der `Bird` Konstruktorfunktion. Du kannst diese Beziehung mit der `isPrototypeOf`-Methode anzeigen:
+
+```js
+Bird.prototype.isPrototypeOf(duck);
+```
+
+Dies würde `true` zurückgeben.
+
+# --instructions--
+
+Verwende `isPrototypeOf`, um den `prototype` von `beagle` zu ermitteln.
+
+# --hints--
+
+Du solltest zeigen, dass `Dog.prototype` der `prototype` von `beagle` ist.
+
+```js
+assert(/Dog\.prototype\.isPrototypeOf\(beagle\)/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+let beagle = new Dog("Snoopy");
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+let beagle = new Dog("Snoopy");
+Dog.prototype.isPrototypeOf(beagle);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md
new file mode 100644
index 00000000000..fd8c3d86e93
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md
@@ -0,0 +1,80 @@
+---
+id: 587d7dad367417b2b2512b78
+title: Verwende einen Konstruktor, um Objekte zu erstellen
+challengeType: 1
+forumTopicId: 18233
+dashedName: use-a-constructor-to-create-objects
+---
+
+# --description--
+
+Hier ist der Konstruktor `Bird` aus der vorherigen Aufgabe:
+
+```js
+function Bird() {
+ this.name = "Albert";
+ this.color = "blue";
+ this.numLegs = 2;
+}
+
+let blueBird = new Bird();
+```
+
+**HINWEIS:** `this` im Konstruktor bezieht sich immer auf das Objekt, das erstellt wird.
+
+Beachte, dass der Operator `new` verwendet wird, wenn du einen Konstruktor aufrufst. Damit wird JavaScript angewiesen, eine neue Instanz von `Bird` namens `blueBird` zu erstellen. Ohne den Operator `new` würde `this` innerhalb des Konstruktors nicht auf das neu erstellte Objekt zeigen, was zu unerwarteten Ergebnissen führen würde. Jetzt hat `blueBird` alle Eigenschaften, die im Konstruktor von `Bird` definiert sind:
+
+```js
+blueBird.name;
+blueBird.color;
+blueBird.numLegs;
+```
+
+Wie bei jedem anderen Objekt auch, kann auf seine Eigenschaften zugegriffen und sie verändert werden:
+
+```js
+blueBird.name = 'Elvira';
+blueBird.name;
+```
+
+# --instructions--
+
+Verwende den Konstruktor von `Dog` aus der letzten Aufgabe, um eine neue Instanz von `Dog` zu erstellen, indem du sie der Variablen `hound` zuweist.
+
+# --hints--
+
+`hound` sollte mit dem Konstruktor von `Dog` erstellt werden.
+
+```js
+assert(hound instanceof Dog);
+```
+
+Dein Code sollte den Operator `new` verwenden, um eine Instanz von `Dog` zu erstellen.
+
+```js
+assert(code.match(/new/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog() {
+ this.name = "Rupert";
+ this.color = "brown";
+ this.numLegs = 4;
+}
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog() {
+ this.name = "Rupert";
+ this.color = "brown";
+ this.numLegs = 4;
+}
+const hound = new Dog();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md
new file mode 100644
index 00000000000..818ae2e2556
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md
@@ -0,0 +1,111 @@
+---
+id: 587d7db2367417b2b2512b89
+title: Verwende ein Mixin, um gemeinsames Verhalten zwischen unverbundenen Objekten hinzuzufügen
+challengeType: 1
+forumTopicId: 301331
+dashedName: use-a-mixin-to-add-common-behavior-between-unrelated-objects
+---
+
+# --description--
+
+Wie du gesehen hast, wird das Verhalten durch Vererbung geteilt. Es gibt jedoch Fälle, in denen die Vererbung nicht die beste Lösung ist. Die Vererbung funktioniert nicht gut für nicht verwandte Objekte wie Vogel (`Bird`) und Flugzeug (`Airplane`). Sie können beide fliegen, aber ein `Bird` ist kein Typ von `Airplane` und andersherum.
+
+Für nicht verwandte Objekte ist es besser, Mixins zu verwenden. Ein Mixin ermöglicht es anderen Objekten, eine Sammlung von Funktionen zu nutzen.
+
+```js
+let flyMixin = function(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ }
+};
+```
+
+Das `flyMixin` nimmt ein beliebiges Objekt und gibt ihm die Methode `fly`.
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let plane = {
+ model: "777",
+ numPassengers: 524
+};
+
+flyMixin(bird);
+flyMixin(plane);
+```
+
+Hier werden `bird` und `plane` an `flyMixin` übergeben, das dann jedem Objekt die Funktion `fly` zuweist. Jetzt können `bird` und `plane` beide fliegen:
+
+```js
+bird.fly();
+plane.fly();
+```
+
+Die Konsole würde den String `Flying, wooosh!` zweimal anzeigen, einmal für jeden `.fly()`-Aufruf.
+
+Beachte, wie das Mixin es ermöglicht, dieselbe Methode `fly` für die nicht verwandten Objekte `bird` und `plane` wiederzuverwenden.
+
+# --instructions--
+
+Erstelle ein Mixin namens `glideMixin`, das eine Methode namens `glide` definiert. Verwende dann das `glideMixin`, um sowohl `bird` als auch `boat` die Fähigkeit zu geben, zu gleiten.
+
+# --hints--
+
+Dein Code sollte eine Variable `glideMixin` deklarieren, die eine Funktion ist.
+
+```js
+assert(typeof glideMixin === 'function');
+```
+
+Dein Code sollte `glideMixin` auf das `bird`-Objekt anwenden, um ihm die Methode `glide` zu geben.
+
+```js
+assert(typeof bird.glide === 'function');
+```
+
+Dein Code sollte `glideMixin` auf das `boat`-Objekt anwenden, um ihm die Methode `glide` zu geben.
+
+```js
+assert(typeof boat.glide === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let boat = {
+ name: "Warrior",
+ type: "race-boat"
+};
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let boat = {
+ name: "Warrior",
+ type: "race-boat"
+};
+function glideMixin (obj) {
+ obj.glide = () => 'Gliding!';
+}
+
+glideMixin(bird);
+glideMixin(boat);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md
new file mode 100644
index 00000000000..7940b37ae86
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md
@@ -0,0 +1,106 @@
+---
+id: 587d7db2367417b2b2512b8c
+title: Ein IIFE verwenden, um ein Modul zu erstellen
+challengeType: 1
+forumTopicId: 301332
+dashedName: use-an-iife-to-create-a-module
+---
+
+# --description--
+
+Ein sofort aufgerufener Funktionsausdruck (IIFE) wird oft verwendet, um verwandte Funktionen in einem einzigen Objekt oder Modul zusammenzufassen. In einer früheren Aufgabe wurden zum Beispiel zwei Mixins definiert:
+
+```js
+function glideMixin(obj) {
+ obj.glide = function() {
+ console.log("Gliding on the water");
+ };
+}
+function flyMixin(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ };
+}
+```
+
+Wir können diese Mixins wie folgt in einem Modul zusammenfassen:
+
+```js
+let motionModule = (function () {
+ return {
+ glideMixin: function(obj) {
+ obj.glide = function() {
+ console.log("Gliding on the water");
+ };
+ },
+ flyMixin: function(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ };
+ }
+ }
+})();
+```
+
+Beachte, dass du einen sofort aufgerufenen Funktionsausdruck (IIFE) hast, der ein Objekt `motionModule` zurückgibt. Dieses zurückgegebene Objekt enthält alle Mixin-Verhaltensweisen als Eigenschaften des Objekts. Der Vorteil des Modulmusters ist, dass alle Bewegungsabläufe in ein einziges Objekt verpackt werden können, das dann von anderen Teilen deines Codes verwendet werden kann. Hier ist ein Beispiel dafür:
+
+```js
+motionModule.glideMixin(duck);
+duck.glide();
+```
+
+# --instructions--
+
+Erstelle ein Modul namens `funModule`, um die beiden Mixins `isCuteMixin` und `singMixin` zu verpacken. `funModule` sollte ein Objekt zurückgeben.
+
+# --hints--
+
+`funModule` sollte definiert sein und ein Objekt zurückgeben.
+
+```js
+assert(typeof funModule === 'object');
+```
+
+`funModule.isCuteMixin` sollte auf eine Funktion zugreifen.
+
+```js
+assert(typeof funModule.isCuteMixin === 'function');
+```
+
+`funModule.singMixin` sollte auf eine Funktion zugreifen.
+
+```js
+assert(typeof funModule.singMixin === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let isCuteMixin = function(obj) {
+ obj.isCute = function() {
+ return true;
+ };
+};
+let singMixin = function(obj) {
+ obj.sing = function() {
+ console.log("Singing to an awesome tune");
+ };
+};
+```
+
+# --solutions--
+
+```js
+const funModule = (function () {
+ return {
+ isCuteMixin: obj => {
+ obj.isCute = () => true;
+ },
+ singMixin: obj => {
+ obj.sing = () => console.log("Singing to an awesome tune");
+ }
+ };
+})();
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md
new file mode 100644
index 00000000000..eb74a72bb18
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md
@@ -0,0 +1,81 @@
+---
+id: 587d7db2367417b2b2512b8a
+title: >-
+ Verwende Closure, um Eigenschaften innerhalb eines Objekts vor externen Änderungen zu schützen
+challengeType: 1
+forumTopicId: 18234
+dashedName: >-
+ use-closure-to-protect-properties-within-an-object-from-being-modified-externally
+---
+
+# --description--
+
+In der vorherigen Aufgabe hatte `bird` eine öffentliche Eigenschaft `name`. Sie gilt als öffentlich, weil auf sie außerhalb der Definition von `bird` zugegriffen und sie verändert werden kann.
+
+```js
+bird.name = "Duffy";
+```
+
+Deshalb kann jeder Teil deines Codes den Namen von `bird` einfach in einen beliebigen Wert ändern. Denk an Dinge wie Passwörter und Bankkonten, die von jedem Teil deiner Codebasis leicht geändert werden können. Das könnte eine Menge Probleme verursachen.
+
+Der einfachste Weg, diese öffentliche Eigenschaft privat zu machen, ist die Erstellung einer Variablen innerhalb der Konstruktorfunktion. Dadurch ändert sich der Geltungsbereich der Variablen, sodass sie innerhalb der Konstruktorfunktion und nicht mehr global verfügbar ist. Auf diese Weise kann auf die Variable nur durch Methoden zugegriffen werden, die auch innerhalb der Konstruktorfunktion vorhanden sind.
+
+```js
+function Bird() {
+ let hatchedEgg = 10;
+
+ this.getHatchedEggCount = function() {
+ return hatchedEgg;
+ };
+}
+let ducky = new Bird();
+ducky.getHatchedEggCount();
+```
+
+Hier ist `getHatchedEggCount` eine privilegierte Methode, weil sie Zugriff auf die private Variable `hatchedEgg` hat. Das ist möglich, weil `hatchedEgg` im gleichen Kontext deklariert wird wie `getHatchedEggCount`. In JavaScript hat eine Funktion immer Zugriff auf den Kontext, in dem sie erstellt wurde. Das nennt man `closure`.
+
+# --instructions--
+
+Ändere die Deklaration von `weight` in der Funktion `Bird`, damit es eine private Variable ist. Erstelle dann eine Methode `getWeight`, die den Wert 15 von `weight` zurückgibt.
+
+# --hints--
+
+Die Eigenschaft `weight` sollte eine private Variable sein und den Wert `15` zugewiesen bekommen.
+
+```js
+assert(code.match(/(var|let|const)\s+weight\s*\=\s*15\;?/g));
+```
+
+Dein Code sollte eine Methode in `Bird` namens `getWeight` erstellen, die den Wert der privaten Variable `weight` zurückgibt.
+
+```js
+assert(new Bird().getWeight() === 15);
+```
+
+Deine Funktion `getWeight` sollte die private Variable `weight` zurückgeben.
+
+```js
+assert(code.match(/((return\s+)|(\(\s*\)\s*\=\>\s*))weight\;?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird() {
+ this.weight = 15;
+
+
+}
+```
+
+# --solutions--
+
+```js
+function Bird() {
+ let weight = 15;
+
+ this.getWeight = () => weight;
+}
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md
new file mode 100644
index 00000000000..d574c74541f
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md
@@ -0,0 +1,62 @@
+---
+id: 587d7dac367417b2b2512b74
+title: Verwende die Punktnotation, um auf die Eigenschaften eines Objekts zuzugreifen
+challengeType: 1
+forumTopicId: 301333
+dashedName: use-dot-notation-to-access-the-properties-of-an-object
+---
+
+# --description--
+
+In der letzten Aufgabe wurde ein Objekt mit verschiedenen Eigenschaften erstellt. Jetzt wirst du sehen, wie du auf die Werte dieser Eigenschaften zugreifen kannst. Hier ist ein Beispiel:
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2
+};
+console.log(duck.name);
+```
+
+Um auf den Wert von `Aflac` zuzugreifen, wird die Punktnotation für den Objektnamen, `duck`, gefolgt von dem Namen der Eigenschaft, `name`, verwendet.
+
+# --instructions--
+
+Gib beide Eigenschaften des Objekts `dog` auf deiner Konsole aus.
+
+# --hints--
+
+Dein Code sollte `console.log` verwenden, um den Wert für die Eigenschaft `name` des Objekts `dog` auszugeben.
+
+```js
+assert(/console.log\(.*dog\.name.*\)/g.test(code));
+```
+
+Dein Code sollte `console.log` verwenden, um den Wert für die Eigenschaft `numLegs` des Objekts `dog` auszugeben.
+
+```js
+assert(/console.log\(.*dog\.numLegs.*\)/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4
+};
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4
+};
+console.log(dog.name);
+console.log(dog.numLegs);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md
new file mode 100644
index 00000000000..51eb787dd87
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md
@@ -0,0 +1,142 @@
+---
+id: 587d7db0367417b2b2512b83
+title: Nutze die Vererbung, damit du dich nicht wiederholst
+challengeType: 1
+forumTopicId: 301334
+dashedName: use-inheritance-so-you-dont-repeat-yourself
+---
+
+# --description--
+
+In der Programmierung gibt es ein Prinzip namens Don't Repeat Yourself (DRY) ("Wiederhole dich nicht selbst") . Der Grund, warum wiederholter Code ein Problem darstellt, ist, dass jede Änderung die Korrektur von Code an mehreren Stellen erfordert. Das bedeutet in der Regel mehr Arbeit für die Programmierer und mehr Raum für Fehler.
+
+Beachte im folgenden Beispiel, dass die Methode `describe` von `Bird` und `Dog` geteilt wird:
+
+```js
+Bird.prototype = {
+ constructor: Bird,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+
+Dog.prototype = {
+ constructor: Dog,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+Die Methode `describe` wird an zwei Stellen wiederholt. Der Code kann so bearbeitet werden, dass er dem DRY-Prinzip folgt, indem ein `supertype` (oder Elternteil) namens `Animal` erstellt wird:
+
+```js
+function Animal() { };
+
+Animal.prototype = {
+ constructor: Animal,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+Da `Animal` die Methode `describe` enthält, kannst du sie aus `Bird` und `Dog` entfernen:
+
+```js
+Bird.prototype = {
+ constructor: Bird
+};
+
+Dog.prototype = {
+ constructor: Dog
+};
+```
+
+# --instructions--
+
+Die Methode `eat` wird sowohl in `Cat` als auch in `Bear` wiederholt. Bearbeite den Code im Sinne von DRY, indem du die Methode `eat` in den `Animal` `supertype` verschiebst.
+
+# --hints--
+
+`Animal.prototype` sollte die Eigenschaft `eat` haben.
+
+```js
+assert(Animal.prototype.hasOwnProperty('eat'));
+```
+
+`Bear.prototype` sollte nicht die Eigenschaft `eat` besitzen.
+
+```js
+assert(!Bear.prototype.hasOwnProperty('eat'));
+```
+
+`Cat.prototype` sollte nicht die Eigenschaft `eat` besitzen.
+
+```js
+assert(!Cat.prototype.hasOwnProperty('eat'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Cat(name) {
+ this.name = name;
+}
+
+Cat.prototype = {
+ constructor: Cat,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Bear(name) {
+ this.name = name;
+}
+
+Bear.prototype = {
+ constructor: Bear,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+
+};
+```
+
+# --solutions--
+
+```js
+function Cat(name) {
+ this.name = name;
+}
+
+Cat.prototype = {
+ constructor: Cat
+};
+
+function Bear(name) {
+ this.name = name;
+}
+
+Bear.prototype = {
+ constructor: Bear
+};
+
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md
new file mode 100644
index 00000000000..49b9be69172
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dae367417b2b2512b7c
+title: Verwende Prototyp-Eigenschaften, um doppelten Code zu reduzieren
+challengeType: 1
+forumTopicId: 301336
+dashedName: use-prototype-properties-to-reduce-duplicate-code
+---
+
+# --description--
+
+Da `numLegs` wahrscheinlich den gleichen Wert für alle Instanzen von `Bird` hat, hast du im Grunde eine doppelte Variable `numLegs` in jeder Instanz von `Bird`.
+
+Das mag kein Problem sein, wenn es nur zwei Instanzen gibt, aber stell dir vor, es gibt Millionen von Instanzen. Das wären eine Menge doppelter Variablen.
+
+Ein besserer Weg ist es, den Prototyp (`prototype`) von `Bird` zu benutzen. Die Eigenschaften im `prototype` werden von ALLEN Instanzen von `Bird` gemeinsam genutzt. Hier erfährst du, wie du `numLegs` zum `Bird prototype` hinzufügst:
+
+```js
+Bird.prototype.numLegs = 2;
+```
+
+Jetzt haben alle Instanzen von `Bird` die Eigenschaft `numLegs`.
+
+```js
+console.log(duck.numLegs);
+console.log(canary.numLegs);
+```
+
+Da alle Instanzen automatisch die Eigenschaften des Prototypen(`prototype`) besitzen, kannst du dir einen Prototypen(`prototype`) wie ein "Rezept" für die Erstellung von Objekten vorstellen. Beachte, dass der `prototype` für `duck` und `canary` Teil des Konstruktors von `Bird` als `Bird.prototype` ist. Fast jedes Objekt in JavaScript hat eine Eigenschaft `prototype`, die Teil der Konstruktorfunktion ist, die es erstellt hat.
+
+# --instructions--
+
+Füge eine Eigenschaft `numLegs` zum `prototype` von `Dog` hinzu
+
+# --hints--
+
+`beagle` sollte eine Eigenschaft `numLegs` besitzen.
+
+```js
+assert(beagle.numLegs !== undefined);
+```
+
+`beagle.numLegs` sollte eine Zahl sein.
+
+```js
+assert(typeof beagle.numLegs === 'number');
+```
+
+`numLegs` sollte eine `prototype`-Eigenschaft sein und keine eigene Eigenschaft.
+
+```js
+assert(beagle.hasOwnProperty('numLegs') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+
+
+// Only change code above this line
+let beagle = new Dog("Snoopy");
+```
+
+# --solutions--
+
+```js
+function Dog (name) {
+ this.name = name;
+}
+Dog.prototype.numLegs = 4;
+let beagle = new Dog("Snoopy");
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md
new file mode 100644
index 00000000000..ec8a5019187
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md
@@ -0,0 +1,79 @@
+---
+id: 587d7dae367417b2b2512b7a
+title: Überprüfe den Konstruktor eines Objekts mit instanceof
+challengeType: 1
+forumTopicId: 301337
+dashedName: verify-an-objects-constructor-with-instanceof
+---
+
+# --description--
+
+Immer wenn eine Konstruktorfunktion ein neues Objekt erzeugt, wird dieses Objekt als Instanz des Konstruktors bezeichnet. JavaScript bietet mit dem Operator `instanceof` eine praktische Möglichkeit, dies zu überprüfen. `instanceof` ermöglicht es dir, ein Objekt mit einem Konstruktor zu vergleichen und `true` oder `false` zurückzugeben, je nachdem, ob das Objekt mit dem Konstruktor erstellt wurde oder nicht. Hier ist ein Beispiel:
+
+```js
+let Bird = function(name, color) {
+ this.name = name;
+ this.color = color;
+ this.numLegs = 2;
+}
+
+let crow = new Bird("Alexis", "black");
+
+crow instanceof Bird;
+```
+
+Diese Methode `instanceof` würde `true` zurückgeben.
+
+Wenn ein Objekt ohne einen Konstruktor erstellt wird, bestätigt `instanceof`, dass es nicht eine Instanz dieses Konstruktors ist:
+
+```js
+let canary = {
+ name: "Mildred",
+ color: "Yellow",
+ numLegs: 2
+};
+
+canary instanceof Bird;
+```
+
+Diese Methode `instanceof` würde `false` zurückgeben.
+
+# --instructions--
+
+Erstelle eine neue Instanz des Konstruktors `House`, nenne sie `myHouse` und übergebe eine Anzahl von Schlafzimmern. Verwende dann `instanceof`, um zu überprüfen, ob es sich um eine Instanz von `House` handelt.
+
+# --hints--
+
+`myHouse` sollte ein Attribut `numBedrooms` besitzen, das auf eine Zahl gesetzt ist.
+
+```js
+assert(typeof myHouse.numBedrooms === 'number');
+```
+
+Du solltest überprüfen, ob `myHouse` eine Instanz von `House` ist, indem du den Operator `instanceof` verwendest.
+
+```js
+assert(/myHouse\s*instanceof\s*House/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function House(numBedrooms) {
+ this.numBedrooms = numBedrooms;
+}
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function House(numBedrooms) {
+ this.numBedrooms = numBedrooms;
+}
+const myHouse = new House(4);
+console.log(myHouse instanceof House);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md
new file mode 100644
index 00000000000..ac6f414877c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dba367417b2b2512ba8
+title: Prüfe auf Alle oder Keine
+challengeType: 1
+forumTopicId: 301338
+dashedName: check-for-all-or-none
+---
+
+# --description--
+
+Manchmal gibt es Teile des Musters, nach dem du suchen möchtest, die es vielleicht gar nicht gibt. Es kann aber wichtig sein, sie trotzdem zu überprüfen.
+
+Du kannst die mögliche Existenz eines Elements mit einem Fragezeichen angeben, `?`. Damit wird geprüft, ob das vorhergehende Element Null oder Eins ist. Du kannst dir dieses Symbol so vorstellen, dass das vorangegangene Element optional ist.
+
+Es gibt zum Beispiel leichte Unterschiede zwischen amerikanischem und britischem Englisch und du kannst das Fragezeichen verwenden, um beide Schreibweisen abzugleichen.
+
+```js
+let american = "color";
+let british = "colour";
+let rainbowRegex= /colou?r/;
+rainbowRegex.test(american);
+rainbowRegex.test(british);
+```
+
+Beide Aufrufe der Methode `test` würden `true` zurückgeben.
+
+# --instructions--
+
+Ändere den regulären Ausdruck `favRegex` so, dass er sowohl auf die amerikanische (`favorite`) als auch auf die britische (`favourite`) Version des Wortes passt.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte das optionale Symbol `?` verwenden.
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.source.match(/\?/).length > 0);
+```
+
+Dein regulärer Ausdruck sollte mit dem String `favorite` übereinstimmen.
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favorite'));
+```
+
+Dein regulärer Ausdruck sollte mit dem String `favourite` übereinstimmen.
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favourite'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `fav` passen.
+
+```js
+favRegex.lastIndex = 0;
+assert(!favRegex.test('fav'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let favWord = "favorite";
+let favRegex = /change/; // Change this line
+let result = favRegex.test(favWord);
+```
+
+# --solutions--
+
+```js
+let favWord = "favorite";
+let favRegex = /favou?r/;
+let result = favRegex.test(favWord);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md
new file mode 100644
index 00000000000..d69094eb3d5
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md
@@ -0,0 +1,90 @@
+---
+id: 5c3dda8b4d8df89bea71600f
+title: Prüfung auf gemischte Gruppierung von Zeichen
+challengeType: 1
+forumTopicId: 301339
+dashedName: check-for-mixed-grouping-of-characters
+---
+
+# --description--
+
+Manchmal wollen wir mit einem regulären Ausdruck nach Gruppen von Zeichen suchen und dazu verwenden wir die Klammern `()`.
+
+Wenn du entweder `Penguin` oder `Pumpkin` in einem String finden willst, kannst du den folgenden regulären Ausdruck verwenden: `/P(engu|umpk)in/g`
+
+Prüfe dann mit der Methode `test()`, ob die gewünschten Stringgruppen im Teststring enthalten sind.
+
+```js
+let testStr = "Pumpkin";
+let testRegex = /P(engu|umpk)in/;
+testRegex.test(testStr);
+```
+
+Die Methode `test` würde hier `true` zurückgeben.
+
+# --instructions--
+
+Korrigiere den regulären Ausdruck so, dass er die Namen `Franklin Roosevelt` oder `Eleanor Roosevelt` unter Berücksichtigung der Groß- und Kleinschreibung prüft und Zugeständnisse bei mittleren Namen macht.
+
+Dann korrigiere den Code so, dass der von dir erstellte reguläre Ausdruck mit `myString` abgeglichen wird und entweder `true` oder `false` zurückgegeben wird, je nachdem, ob der reguläre Ausdruck passt.
+
+# --hints--
+
+Dein regulärer Ausdruck `myRegex` sollte `true` für den String `Franklin D. Roosevelt` zurückgeben.
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Franklin D. Roosevelt'));
+```
+
+Dein regulärer Ausdruck `myRegex` sollte `true` für den String `Eleanor Roosevelt` zurückgeben.
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Eleanor Roosevelt'));
+```
+
+Dein regulärer Ausdruck `myRegex` sollte `false` für den String `Franklin Rosevelt` zurückgeben.
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Franklin Rosevelt'));
+```
+
+Dein regulärer Ausdruck `myRegex` sollte `false` für den String `Frank Roosevelt` zurückgeben.
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Frank Roosevelt'));
+```
+
+Du solltest `.test()` verwenden, um den regulären Ausdruck zu testen.
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+Dein Ergebnis sollte `true` zurückgeben.
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /False/; // Change this line
+let result = false; // Change this line
+// After passing the challenge experiment with myString and see how the grouping works
+```
+
+# --solutions--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /(Franklin|Eleanor).*Roosevelt/;
+let result = myRegex.test(myString);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md
new file mode 100644
index 00000000000..c3af33f8f4c
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md
@@ -0,0 +1,73 @@
+---
+id: 587d7db4367417b2b2512b92
+title: Treffer extrahieren
+challengeType: 1
+forumTopicId: 301340
+dashedName: extract-matches
+---
+
+# --description--
+
+Bisher hast du nur geprüft, ob ein Muster in einem String existiert oder nicht. Du kannst die gefundenen Treffer auch mit der Methode `.match()` extrahieren.
+
+Um die Methode `.match()` zu verwenden, wendest du die Methode auf einen String an und gibst den Regex innerhalb der Klammern ein.
+
+Hier ist ein Beispiel:
+
+```js
+"Hello, World!".match(/Hello/);
+let ourStr = "Regular expressions";
+let ourRegex = /expressions/;
+ourStr.match(ourRegex);
+```
+
+Hier würde die erste Übereinstimmung (`match`) `["Hello"]` zurückgeben und die zweite `["expressions"]`.
+
+Beachte, dass die `.match`-Syntax das "Gegenteil" der `.test`-Methode ist, die du bisher verwendet hast:
+
+```js
+'string'.match(/regex/);
+/regex/.test('string');
+```
+
+# --instructions--
+
+Wende die Methode `.match()` an, um den String `coding` zu extrahieren.
+
+# --hints--
+
+Das Ergebnis (`result`) sollte den String `coding` enthalten
+
+```js
+assert(result.join() === 'coding');
+```
+
+Dein Regex `codingRegex` sollte nach dem String `coding` suchen
+
+```js
+assert(codingRegex.source === 'coding');
+```
+
+Du solltest die Methode `.match()` verwenden.
+
+```js
+assert(code.match(/\.match\(.*\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /change/; // Change this line
+let result = extractStr; // Change this line
+```
+
+# --solutions--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /coding/; // Change this line
+let result = extractStr.match(codingRegex); // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md
new file mode 100644
index 00000000000..61c81d53f17
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md
@@ -0,0 +1,61 @@
+---
+id: 587d7db6367417b2b2512b9b
+title: Zeichen mit einer ungenauen Übereinstimmung finden (Lazy Matching)
+challengeType: 1
+forumTopicId: 301341
+dashedName: find-characters-with-lazy-matching
+---
+
+# --description--
+
+Bei regulären Ausdrücken findet eine greedy -Übereinstimmung den längsten möglichen Teil eines Strings, der dem Muster des regulären Ausdrucks entspricht, und gibt ihn zurück. Die Alternative ist eine lazy -Übereinstimmung, die den kleinstmöglichen Teil des Strings findet, der das Muster des regulären Ausdrucks erfüllt.
+
+Du kannst den regulären Ausdruck `/t[a-z]*i/` auf den String `"titanic"` anwenden. Dieser reguläre Ausdruck ist im Grunde ein Muster, das mit `t` beginnt, mit `i` endet und einige Buchstaben dazwischen hat.
+
+Reguläre Ausdrücke sind standardmäßig "gierig" (greedy), also würde die Übereinstimmung `["titani"]` ergeben. Er findet den größtmöglichen Teilstring, der dem Muster entspricht.
+
+Du kannst jedoch das `?`-Zeichen verwenden, um es auf eine "träge" (lazy) Übereinstimmung umzustellen. `"titanic"` verglichen mit dem angepassten regulären Ausdruck von `/t[a-z]*?i/` ergibt `["ti"]`.
+
+**Hinweis:** Das Parsen von HTML mit regulären Ausdrücken sollte vermieden werden, aber der Musterabgleich eines HTML-Strings mit regulären Ausdrücken ist völlig in Ordnung.
+
+# --instructions--
+
+Korrigiere den regulären Ausdruck `/<.*>/` so, dass er das HTML-Tag `` zurückgibt und nicht den Text `"Winter is coming "`. Denk daran, dass der Platzhalter `.` in einem regulären Ausdruck auf jedes beliebige Zeichen passt.
+
+# --hints--
+
+Die Variable `result` sollte ein Array sein, das `` enthält
+
+```js
+assert(result[0] == '');
+```
+
+`myRegex` sollte Lazy Matching verwenden
+
+```js
+assert(/[^\\][\*\+\?]\?/.test(myRegex));
+```
+
+`myRegex` sollte nicht den String `h1` enthalten
+
+```js
+assert(!myRegex.source.match('h1'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let text = "Winter is coming ";
+let myRegex = /<.*>/; // Change this line
+let result = text.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let text = "Winter is coming ";
+let myRegex = /<.*?>/; // Change this line
+let result = text.match(myRegex);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md
new file mode 100644
index 00000000000..c81980c0a94
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db4367417b2b2512b93
+title: Finde mehr als nur den ersten Treffer
+challengeType: 1
+forumTopicId: 301342
+dashedName: find-more-than-the-first-match
+---
+
+# --description--
+
+Bis jetzt konntest du ein Muster nur einmal extrahieren oder suchen.
+
+```js
+let testStr = "Repeat, Repeat, Repeat";
+let ourRegex = /Repeat/;
+testStr.match(ourRegex);
+```
+
+Hier würde `match` `["Repeat"]` zurückgeben.
+
+Um ein Muster mehr als einmal zu suchen oder zu extrahieren, kannst du das globale Search-Flag verwenden: `g`.
+
+```js
+let repeatRegex = /Repeat/g;
+testStr.match(repeatRegex);
+```
+
+Und hier liefert `match` den Wert `["Repeat", "Repeat", "Repeat"]`
+
+# --instructions--
+
+Finde mit dem Regex `starRegex` die beiden Wörter `Twinkle` und extrahiere sie aus dem String `twinkleStar`.
+
+**Hinweis**
+Du kannst mehrere Flags in deinem Regex benutzen, wie `/search/gi`
+
+# --hints--
+
+Dein Regex `starRegex` sollte den globalen Flag `g` verwenden
+
+```js
+assert(starRegex.flags.match(/g/).length == 1);
+```
+
+Dein Regex `starRegex` sollte den Flag `i` zur Unterscheidung von Groß- und Kleinschreibung verwenden
+
+```js
+assert(starRegex.flags.match(/i/).length == 1);
+```
+
+Dein Treffer sollte mit beiden Vorkommen des Wortes `Twinkle` übereinstimmen
+
+```js
+assert(
+ result.sort().join() ==
+ twinkleStar
+ .match(/twinkle/gi)
+ .sort()
+ .join()
+);
+```
+
+Dein Treffer `result` sollte zwei Elemente enthalten.
+
+```js
+assert(result.length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /change/; // Change this line
+let result = twinkleStar; // Change this line
+```
+
+# --solutions--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /twinkle/gi;
+let result = twinkleStar.match(starRegex);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md
new file mode 100644
index 00000000000..cd773915df7
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md
@@ -0,0 +1,108 @@
+---
+id: 587d7db7367417b2b2512b9c
+title: Finde einen oder mehrere Kriminelle bei einer Jagd
+challengeType: 1
+forumTopicId: 301343
+dashedName: find-one-or-more-criminals-in-a-hunt
+---
+
+# --description--
+
+Zeit, eine Pause einzulegen und deine neuen Schreibfähigkeiten für reguläre Ausdrücke zu testen. Eine Gruppe von Kriminellen ist aus dem Gefängnis ausgebrochen und weggelaufen, aber du weißt nicht, wie viele. Du weißt aber, dass sie eng zusammenbleiben, wenn sie mit anderen Menschen zusammen sind. Du bist dafür verantwortlich, alle Verbrecher auf einmal zu finden.
+
+Hier ist ein Beispiel, um zu sehen, wie man das macht:
+
+Der reguläre Ausdruck `/z+/` passt auf den Buchstaben `z`, wenn er ein oder mehrere Male hintereinander erscheint. Er würde Übereinstimmungen in allen folgenden Strings finden:
+
+```js
+"z"
+"zzzzzz"
+"ABCzzzz"
+"zzzzABC"
+"abczzzzzzzzzzzzzzzzzzzzzabc"
+```
+
+Aber er findet keine Übereinstimmungen in den folgenden Strings, da es keinen Buchstaben `z` gibt:
+
+```js
+""
+"ABC"
+"abcabc"
+```
+
+# --instructions--
+
+Schreibe einen "gierigen" (greedy) regulären Ausdruck, der einen oder mehrere Kriminelle innerhalb einer Gruppe von anderen Menschen findet. Ein Krimineller wird durch den Großbuchstaben `C` dargestellt.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte auf einen Kriminellen (`C`) in dem String `C` passen.
+
+```js
+assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
+```
+
+Dein regulärer Ausdruck sollte auf zwei Kriminelle (`CC`) in dem String `CC` passen.
+
+```js
+assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
+```
+
+Dein regulärer Ausdruck sollte auf drei Kriminelle (`CCC`) in dem String `P1P5P4CCCcP2P6P3` passen.
+
+```js
+assert(
+ 'P1P5P4CCCcP2P6P3'.match(reCriminals) &&
+ 'P1P5P4CCCcP2P6P3'.match(reCriminals)[0] == 'CCC'
+);
+```
+
+Dein regulärer Ausdruck sollte auf fünf Kriminelle (`CCCCC`) in dem String `P6P2P7P4P5CCCCCP3P1` passen.
+
+```js
+assert(
+ 'P6P2P7P4P5CCCCCP3P1'.match(reCriminals) &&
+ 'P6P2P7P4P5CCCCCP3P1'.match(reCriminals)[0] == 'CCCCC'
+);
+```
+
+Dein regulärer Ausdruck sollte keine Kriminellen in dem leeren String `""` finden.
+
+```js
+reCriminals.lastIndex = 0;
+assert(!reCriminals.test(''));
+```
+
+Dein regulärer Ausdruck sollte keine Kriminellen in dem String `P1P2P3` finden.
+
+```js
+reCriminals.lastIndex = 0;
+assert(!reCriminals.test('P1P2P3'));
+```
+
+Dein regulärer Ausdruck sollte 50 Kriminelle (`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`) in dem String `P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`. finden.
+
+```js
+assert(
+ 'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+ reCriminals
+ ) &&
+ 'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+ reCriminals
+ )[0] == 'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let reCriminals = /./; // Change this line
+```
+
+# --solutions--
+
+```js
+let reCriminals = /C+/; // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md
new file mode 100644
index 00000000000..20211d805d0
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md
@@ -0,0 +1,109 @@
+---
+id: 587d7db4367417b2b2512b91
+title: Groß- und Kleinschreibung beim Abgleich ignorieren
+challengeType: 1
+forumTopicId: 301344
+dashedName: ignore-case-while-matching
+---
+
+# --description--
+
+Bis jetzt hast du dir Regexe angeschaut, um wörtliche Übereinstimmungen von Strings zu finden. Aber manchmal möchtest du vielleicht auch Unterschiede in der Groß- und Kleinschreibung abgleichen.
+
+"Case" (oder manchmal auch "Letter Case") ist der Unterschied zwischen Großbuchstaben und Kleinbuchstaben. Beispiele für Großbuchstaben sind `A`, `B` und `C`. Beispiele für Kleinbuchstaben sind `a`, `b` und `c`.
+
+Du kannst beide Fälle mit einem so genannten Flag ( (oder Modifikator) abgleichen. Es gibt noch andere Flags, aber hier konzentrierst du dich auf das Flag, das Groß- und Kleinschreibung ignoriert - das Flag `i`. Du kannst sie verwenden, indem du sie an den Regex anhängst. Ein Beispiel für die Verwendung dieses Flags ist `/ignorecase/i`. Dieser Regex kann auf die Strings `ignorecase`, `igNoreCase` und `IgnoreCase` passen.
+
+# --instructions--
+
+Schreibe ein Regex `fccRegex`, das mit `freeCodeCamp` übereinstimmt, egal wie groß es ist. Dein Regex sollte keine Abkürzungen oder Variationen mit Leerzeichen finden.
+
+# --hints--
+
+Dein Regex sollte mit dem String `freeCodeCamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('freeCodeCamp'));
+```
+
+Dein Regex sollte mit dem String `FreeCodeCamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCodeCamp'));
+```
+
+Dein Regex sollte mit dem String `FreecodeCamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreecodeCamp'));
+```
+
+Dein Regex sollte mit dem String `FreeCodecamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCodecamp'));
+```
+
+Dein Regex sollte mit dem String `Free Code Camp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(!fccRegex.test('Free Code Camp'));
+```
+
+Dein Regex sollte mit dem String `FreeCOdeCamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FreeCOdeCamp'));
+```
+
+Dein Regex sollte nicht mit dem String `FCC` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(!fccRegex.test('FCC'));
+```
+
+Dein Regex sollte mit dem String `FrEeCoDeCamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FrEeCoDeCamp'));
+```
+
+Dein Regex sollte mit dem String `FrEeCodECamp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FrEeCodECamp'));
+```
+
+Dein Regex sollte mit dem String `FReeCodeCAmp` übereinstimmen
+
+```js
+fccRegex.lastIndex = 0;
+assert(fccRegex.test('FReeCodeCAmp'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /change/; // Change this line
+let result = fccRegex.test(myString);
+```
+
+# --solutions--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /freecodecamp/i; // Change this line
+let result = fccRegex.test(myString);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md
new file mode 100644
index 00000000000..5c144c15459
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md
@@ -0,0 +1,90 @@
+---
+id: 587d7db4367417b2b2512b90
+title: Einen literalen String mit verschiedenen Möglichkeiten abgleichen
+challengeType: 1
+forumTopicId: 301345
+dashedName: match-a-literal-string-with-different-possibilities
+---
+
+# --description--
+
+Mit Regexen wie `/coding/` kannst du nach dem Muster `coding` in einem anderen String suchen.
+
+Diese Funktion ist leistungsstark, um einzelne Strings zu suchen, aber sie ist auf ein einziges Muster beschränkt. Du kannst nach mehreren Mustern suchen, indem du den Operator `alternation` oder `OR` verwendest: `|`.
+
+Dieser Operator gleicht Muster vor oder nach ihm ab. Wenn du zum Beispiel die Strings `yes` oder `no` abgleichen willst, lautet der Regex, den du brauchst `/yes|no/`.
+
+Du kannst auch nach mehr als zwei Mustern suchen. Du kannst dies tun, indem du mehr Muster mit mehr `OR`-Operatoren zwischen ihnen hinzufügst, wie `/yes|no|maybe/`.
+
+# --instructions--
+
+Ergänze den Regex `petRegex`, um die Haustiere `dog`, `cat`, `bird` oder `fish` zu finden.
+
+# --hints--
+
+Dein Regex `petRegex` sollte `true` für folgenden String liefern `John has a pet dog.`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('John has a pet dog.'));
+```
+
+Deine Regex `petRegex` sollte `false` für folgenden String liefern `Emma has a pet rock.`
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Emma has a pet rock.'));
+```
+
+Dein Regex `petRegex` sollte `true` für folgenden String liefern `Emma has a pet bird.`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Emma has a pet bird.'));
+```
+
+Dein Regex `petRegex` sollte `true` für folgenden String liefern `Liz has a pet cat.`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Liz has a pet cat.'));
+```
+
+Dein Regex `petRegex` sollte `false` für folgenden String liefern `Kara has a pet dolphin.`
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Kara has a pet dolphin.'));
+```
+
+Dein Regex `petRegex` sollte `true` für folgenden String liefern `Alice has a pet fish.`
+
+```js
+petRegex.lastIndex = 0;
+assert(petRegex.test('Alice has a pet fish.'));
+```
+
+Dein Regex `petRegex` sollte `false` für folgenden String liefern `Jimmy has a pet computer.`
+
+```js
+petRegex.lastIndex = 0;
+assert(!petRegex.test('Jimmy has a pet computer.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /change/; // Change this line
+let result = petRegex.test(petString);
+```
+
+# --solutions--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /dog|cat|bird|fish/; // Change this line
+let result = petRegex.test(petString);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md
new file mode 100644
index 00000000000..a673f6cf74b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md
@@ -0,0 +1,98 @@
+---
+id: 587d7db7367417b2b2512b9f
+title: Alle Buchstaben und Zahlen finden
+challengeType: 1
+forumTopicId: 301346
+dashedName: match-all-letters-and-numbers
+---
+
+# --description--
+
+Mithilfe von Zeichenklassen konntest du mit `[a-z]` nach allen Buchstaben des Alphabets suchen. Diese Art von Zeichenklasse ist so häufig, dass es eine Kurzform dafür gibt, obwohl sie auch ein paar zusätzliche Zeichen enthält.
+
+Die nächstgelegene Zeichenklasse in JavaScript, die dem Alphabet entspricht, ist `\w`. Diese Kurzform ist gleich `[A-Za-z0-9_]`. Diese Zeichenklasse umfasst Groß- und Kleinbuchstaben sowie Zahlen. Beachte, dass diese Zeichenklasse auch das Unterstrichzeichen \[Underscore\] (`_`) enthält.
+
+```js
+let longHand = /[A-Za-z0-9_]+/;
+let shortHand = /\w+/;
+let numbers = "42";
+let varNames = "important_var";
+longHand.test(numbers);
+shortHand.test(numbers);
+longHand.test(varNames);
+shortHand.test(varNames);
+```
+
+Alle vier dieser `test`-Aufrufe würden `true` zurückgeben.
+
+Diese Kurzformen von Zeichenklassen sind auch als Kurzzeichen-Klassen bekannt.
+
+# --instructions--
+
+Verwende die Kurzzeichen-Klasse `\w`, um die Anzahl der alphanumerischen Zeichen in verschiedenen Zitaten und Strings zu zählen.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(alphabetRegexV2.global);
+```
+
+Dein regulärer Ausdruck sollte das Kurzzeichen `\w` verwenden, um alle alphanumerischen Zeichen zu finden.
+
+```js
+assert(/\\w/.test(alphabetRegexV2.source));
+```
+
+Dein regulärer Ausdruck sollte 31 alphanumerische Zeichen in dem String `The five boxing wizards jump quickly.` finden.
+
+```js
+assert(
+ 'The five boxing wizards jump quickly.'.match(alphabetRegexV2).length === 31
+);
+```
+
+Dein regulärer Ausdruck sollte 32 alphanumerische Zeichen in dem String `Pack my box with five dozen liquor jugs.` finden.
+
+```js
+assert(
+ 'Pack my box with five dozen liquor jugs.'.match(alphabetRegexV2).length ===
+ 32
+);
+```
+
+Dein regulärer Ausdruck sollte 30 alphanumerische Zeichen in dem String `How vexingly quick daft zebras jump!` finden.
+
+```js
+assert(
+ 'How vexingly quick daft zebras jump!'.match(alphabetRegexV2).length === 30
+);
+```
+
+Dein regulärer Ausdruck sollte 36 alphanumerische Zeichen in dem String `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` finden.
+
+```js
+assert(
+ '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(alphabetRegexV2)
+ .length === 36
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /change/; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /\w/g; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md
new file mode 100644
index 00000000000..3185dfff403
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db8367417b2b2512ba1
+title: Alle nicht-numerischen Zeichen abgleichen
+challengeType: 1
+forumTopicId: 301347
+dashedName: match-all-non-numbers
+---
+
+# --description--
+
+In der letzten Aufgabe wurde gezeigt, wie man mit der Kurzform `\d` mit einem kleingeschriebenen `d` nach Ziffern sucht. Du kannst auch nach nicht-numerischen Zeichen suchen, indem du eine ähnliche Kurzform verwendest, die stattdessen ein großes `D` verwendet.
+
+Die Kurzform für die Suche nach nicht-nummerischen Zeichen ist `\D`. Das ist identisch mit der Zeichenklasse `[^0-9]`, die nach einem einzelnen Zeichen sucht, das nicht eine Zahl zwischen null und neun ist.
+
+# --instructions--
+
+Verwende die abgekürzte Zeichenklasse `\D`, um zu zählen, wie viele nicht-numerische Zeichen in Filmtiteln enthalten sind.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte die Kurzform verwenden, um nicht-numerische Zeichen abzugleichen
+
+```js
+assert(/\\D/.test(noNumRegex.source));
+```
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(noNumRegex.global);
+```
+
+Dein regulärer Ausdruck sollte keine nicht-numerischen Zeichen in dem String `9` finden.
+
+```js
+assert('9'.match(noNumRegex) == null);
+```
+
+Dein regulärer Ausdruck sollte 6 nicht-numerische Zeichen in dem String `Catch 22` finden.
+
+```js
+assert('Catch 22'.match(noNumRegex).length == 6);
+```
+
+Dein regulärer Ausdruck sollte 11 nicht-numerische Zeichen in dem String `101 Dalmatians` finden.
+
+```js
+assert('101 Dalmatians'.match(noNumRegex).length == 11);
+```
+
+Dein regulärer Ausdruck sollte 15 nicht-numerische Zeichen in dem String `One, Two, Three` finden.
+
+```js
+assert('One, Two, Three'.match(noNumRegex).length == 15);
+```
+
+Dein regulärer Ausdruck sollte 12 nicht-numerische Zeichen in dem String `21 Jump Street` finden.
+
+```js
+assert('21 Jump Street'.match(noNumRegex).length == 12);
+```
+
+Dein regulärer Ausdruck sollte 17 nicht-numersiche Zeichen in dem String `2001: A Space Odyssey` finden.
+
+```js
+assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /change/; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /\D/g; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md
new file mode 100644
index 00000000000..0a01e971583
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md
@@ -0,0 +1,85 @@
+---
+id: 5d712346c441eddfaeb5bdef
+title: Alle Zahlen abgleichen
+challengeType: 1
+forumTopicId: 18181
+dashedName: match-all-numbers
+---
+
+# --description--
+
+Du hast Kurzformen für gängige Zeichenkettenmuster wie alphanumerische Zeichen gelernt. Ein anderes gängiges Muster ist die Suche nach Ziffern oder Zahlen.
+
+Die Abkürzung für die Suche nach Ziffernzeichen ist `\d`, mit einem kleingeschriebenen `d`. Dies entspricht der Zeichenklasse `[0-9]`, die nach einem einzelnen Zeichen mit einer beliebigen Zahl zwischen null und neun sucht.
+
+# --instructions--
+
+Verwende die Kurzzeichen-Klasse `\d`, um zu zählen, wie viele Ziffern ein Filmtitel hat. Ausgeschriebene Zahlen ("sechs" statt 6) zählen nicht.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte die Kurzform für Ziffernzeichen verwenden
+
+```js
+assert(/\\d/.test(numRegex.source));
+```
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(numRegex.global);
+```
+
+Deine regulärer Ausdruck sollte 1 Ziffer in dem String `9` finden.
+
+```js
+assert('9'.match(numRegex).length == 1);
+```
+
+Dein regulärer Ausdruck sollte 2 Ziffern in dem String `Catch 22` finden.
+
+```js
+assert('Catch 22'.match(numRegex).length == 2);
+```
+
+Dein regulärer Ausdruck sollte 3 Ziffern in dem String `101 Dalmatians` finden.
+
+```js
+assert('101 Dalmatians'.match(numRegex).length == 3);
+```
+
+Dein regulärer Ausdruck sollte keine Ziffern in dem String `One, Two, Three` finden.
+
+```js
+assert('One, Two, Three'.match(numRegex) == null);
+```
+
+Dein regulärer Ausdruck sollte 2 Ziffern in dem String `21 Jump Street` finden.
+
+```js
+assert('21 Jump Street'.match(numRegex).length == 2);
+```
+
+Dein regulärer Ausdruck sollte 4 Ziffern in dem String `2001: A Space Odyssey` finden.
+
+```js
+assert('2001: A Space Odyssey'.match(numRegex).length == 4);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /change/; // Change this line
+let result = movieName.match(numRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /\d/g; // Change this line
+let result = movieName.match(numRegex).length;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md
new file mode 100644
index 00000000000..a2675d503cc
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md
@@ -0,0 +1,119 @@
+---
+id: 587d7db5367417b2b2512b94
+title: Alles mit der Punkt-Wildcard abgleichen
+challengeType: 1
+forumTopicId: 301348
+dashedName: match-anything-with-wildcard-period
+---
+
+# --description--
+
+Manchmal wirst du die genauen Zeichen in deinen Mustern nicht kennen (oder musst sie nicht kennen). An alle Wörter zu denken, die z. B. mit einem Schreibfehler übereinstimmen, würde sehr lange dauern. Zum Glück kannst du mit dem Wildcardzeichen (Platzhalter) Zeit sparen: `.` (Punkt).
+
+Das Wildcardzeichen `.` passt auf ein beliebiges Zeichen. Die Wildcard wird auch `dot` und `period` genannt. Du kannst das Wildcardzeichen genau wie jedes andere Zeichen in dem Regex verwenden. Wenn du zum Beispiel `hug`, `huh`, `hut` und `hum` finden möchtest, kannst du den Regex `/hu./` verwenden, um alle vier Wörter zu finden.
+
+```js
+let humStr = "I'll hum a song";
+let hugStr = "Bear hug";
+let huRegex = /hu./;
+huRegex.test(humStr);
+huRegex.test(hugStr);
+```
+
+Diese beiden `test`-Aufrufe würden `true` zurückgeben.
+
+# --instructions--
+
+Ergänze den Regex `unRegex` so, dass er auf die Strings `run`, `sun`, `fun`, `pun`, `nun`, und `bun` zutrifft. Dein Regex sollte das Wildcardzeichen verwenden.
+
+# --hints--
+
+Du solltest die Methode `.test()` verwenden.
+
+```js
+assert(code.match(/\.test\(.*\)/));
+```
+
+Du solltest das Wildcardzeichen in deinem Regex `unRegex` verwenden.
+
+```js
+assert(/\./.test(unRegex.source));
+```
+
+Dein Regex `unRegex` sollte mit `run` in dem String `Let us go on a run.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Let us go on a run.'));
+```
+
+Dein Regex `unRegex` sollte mit `sun` in dem String `The sun is out today.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('The sun is out today.'));
+```
+
+Dein Regex `unRegex` sollte mit `fun` in dem String `Coding is a lot of fun.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Coding is a lot of fun.'));
+```
+
+Dein Regex `unRegex` sollte mit `pun` in dem String `Seven days without a pun makes one weak.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Seven days without a pun makes one weak.'));
+```
+
+Dein Regex `unRegex` sollte mit `nun` in dem String `One takes a vow to be a nun.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('One takes a vow to be a nun.'));
+```
+
+Dein Regex `unRegex` sollte mit `bun` in dem String `She got fired from the hot dog stand for putting her hair in a bun.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(
+ unRegex.test(
+ 'She got fired from the hot dog stand for putting her hair in a bun.'
+ )
+);
+```
+
+Dein Regex `unRegex` sollte nicht mit dem String `There is a bug in my code.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('There is a bug in my code.'));
+```
+
+Dein Regex `unRegex` sollte nicht mit dem String `Catch me if you can.` übereinstimmen.
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('Catch me if you can.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /change/; // Change this line
+let result = unRegex.test(exampleStr);
+```
+
+# --solutions--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /.un/; // Change this line
+let result = unRegex.test(exampleStr);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md
new file mode 100644
index 00000000000..70f557cd961
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md
@@ -0,0 +1,73 @@
+---
+id: 587d7db7367417b2b2512b9d
+title: Beginnende String-Muster abgleichen
+challengeType: 1
+forumTopicId: 301349
+dashedName: match-beginning-string-patterns
+---
+
+# --description--
+
+Frühere Aufgaben haben gezeigt, dass reguläre Ausdrücke verwendet werden können, um nach einer Reihe von Übereinstimmungen zu suchen. Sie werden auch für die Suche nach Mustern an bestimmten Stellen in Strings verwendet.
+
+In einer früheren Aufgabe hast du das Caret-Zeichen (`^`) innerhalb eines Zeichensatzes verwendet, um einen negierten Zeichensatz in der Form `[^thingsThatWillNotBeMatched]` zu erstellen. Außerhalb eines Zeichensatzes wird das Caret verwendet, um nach Mustern am Anfang von Strings zu suchen.
+
+```js
+let firstString = "Ricky is first and can be found.";
+let firstRegex = /^Ricky/;
+firstRegex.test(firstString);
+let notFirst = "You can't find Ricky now.";
+firstRegex.test(notFirst);
+```
+
+Der erste `test`-Aufruf würde `true` zurückgeben, während der zweite `false` zurückgeben würde.
+
+# --instructions--
+
+Verwende das Caret-Zeichen in einem regulären Ausdruck, um `Cal` nur am Anfang des Strings `rickyAndCal` zu finden.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte nach dem String `Cal` mit einem Großbuchstaben suchen.
+
+```js
+assert(calRegex.source == '^Cal');
+```
+
+Dein regulärer Ausdruck sollte keine Flags verwenden.
+
+```js
+assert(calRegex.flags == '');
+```
+
+Dein regulärer Ausdruck sollte auf den String `Cal` am Anfang des Strings passen.
+
+```js
+calRegex.lastIndex = 0;
+assert(calRegex.test('Cal and Ricky both like racing.'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Cal` in der Mitte eines Strings passen.
+
+```js
+calRegex.lastIndex = 0;
+assert(!calRegex.test('Ricky and Cal both like racing.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /change/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
+
+# --solutions--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /^Cal/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md
new file mode 100644
index 00000000000..4f5692a2d3b
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md
@@ -0,0 +1,59 @@
+---
+id: 587d7db6367417b2b2512b99
+title: Finde Zeichen, die ein oder mehrere Male vorkommen
+challengeType: 1
+forumTopicId: 301350
+dashedName: match-characters-that-occur-one-or-more-times
+---
+
+# --description--
+
+Manchmal musst du ein Zeichen (oder eine Gruppe von Zeichen) finden, das ein oder mehrere Male hintereinander auftaucht. Das bedeutet, dass es mindestens einmal vorkommt und wiederholt werden kann.
+
+Du kannst das Zeichen `+` verwenden, um zu überprüfen, ob das der Fall ist. Denke daran, dass das Zeichen oder Muster fortlaufend vorhanden sein muss. Das heißt, das Zeichen muss nacheinander wiederholt werden.
+
+Zum Beispiel würde `/a+/g` eine Übereinstimmung in `abc` finden und `["a"]` zurückgeben. Aufgrund des `+` würde es auch eine einzelne Übereinstimmung in `aabc` finden und `["aa"]` zurückgeben.
+
+Wenn er stattdessen den String `abab` prüfen würde, würde es zwei Übereinstimmungen finden und `["a", "a"]` zurückgeben, weil die `a` Zeichen nicht in einer Reihe stehen - zwischen ihnen befindet sich ein `b`. Da in dem String `bcd` kein `a` vorkommt, würde er keine Übereinstimmung finden.
+
+# --instructions--
+
+Du willst Übereinstimmungen finden, wenn der Buchstabe `s` ein oder mehrere Male in `Mississippi` vorkommt. Schreibe einen regulären Ausdruck, der das Zeichen `+` verwendet.
+
+# --hints--
+
+Dein regulärer Ausdruck `myRegex` sollte das Zeichen `+` verwenden, um ein oder mehrere `s`-Zeichen zu finden.
+
+```js
+assert(/\+/.test(myRegex.source));
+```
+
+Dein regulärer Ausdruck `myRegex` sollte 2 Elemente finden.
+
+```js
+assert(result.length == 2);
+```
+
+Die Variable `result` sollte ein Array mit zwei Übereinstimmungen von `ss` sein
+
+```js
+assert(result[0] == 'ss' && result[1] == 'ss');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /change/; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /s+/g; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md
new file mode 100644
index 00000000000..47184032379
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md
@@ -0,0 +1,96 @@
+---
+id: 587d7db6367417b2b2512b9a
+title: Finde Zeichen, die null oder mehr Mal vorkommen
+challengeType: 1
+forumTopicId: 301351
+dashedName: match-characters-that-occur-zero-or-more-times
+---
+
+# --description--
+
+Bei der letzten Aufgabe wurde das Pluszeichen `+` verwendet, um nach Zeichen zu suchen, die ein oder mehrere Male vorkommen. Es gibt auch eine Option, die Zeichen findet, die null oder mehr Mal vorkommen.
+
+Das Zeichen dafür ist das Sternchen oder der Stern: `*`.
+
+```js
+let soccerWord = "gooooooooal!";
+let gPhrase = "gut feeling";
+let oPhrase = "over the moon";
+let goRegex = /go*/;
+soccerWord.match(goRegex);
+gPhrase.match(goRegex);
+oPhrase.match(goRegex);
+```
+
+In dieser Reihenfolge würden die drei `match`-Aufrufe die Werte `["goooooooo"]`, `["g"]` und `null` zurückgeben.
+
+# --instructions--
+
+Für diese Aufgabe wurde `chewieQuote` hinter den Kulissen als String `Aaaaaaaaaaaaaaaarrrgh!` initialisiert. Erstelle nun einen regulären Ausdruck `chewieRegex`, der das `*`-Zeichen verwendet, um ein großgeschriebenes `A`-Zeichen, das unmittelbar von null oder mehr kleingeschriebenen `a`-Zeichen gefolgt wird, in `chewieQuote` zu finden. Dein regulärer Ausdruck braucht keine Flags oder Zeichenklassen und er sollte mit keinem der anderen Zitate übereinstimmen.
+
+# --hints--
+
+Dein regulärer Ausdruck `chewieRegex` sollte das Zeichen `*` verwenden, um auf null oder mehr `a`-Zeichen zu passen.
+
+```js
+assert(/\*/.test(chewieRegex.source));
+```
+
+Dein regulärer Ausdruck sollte auf den String `A` in `chewieQuote` passen.
+
+```js
+assert(result[0][0] === 'A');
+```
+
+Dein regulärer Ausdruck sollte auf den String `Aaaaaaaaaaaaaaaa` in `chewieQuote` passen.
+
+```js
+assert(result[0] === 'Aaaaaaaaaaaaaaaa');
+```
+
+Dein regulärer Ausdruck `chewieRegex` sollte 16 Zeichen in `chewieQuote` finden.
+
+```js
+assert(result[0].length === 16);
+```
+
+Dein regulärer Ausdruck sollte auf keine Zeichen in dem String `He made a fair move. Screaming about it can't help you.` passen.
+
+```js
+assert(
+ !"He made a fair move. Screaming about it can't help you.".match(chewieRegex)
+);
+```
+
+Dein regulärer Ausdruck sollte auf kein Zeichen in dem String `Let him have it. It's not wise to upset a Wookiee.` passen.
+
+```js
+assert(
+ !"Let him have it. It's not wise to upset a Wookiee.".match(chewieRegex)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+let chewieRegex = /change/; // Change this line
+// Only change code above this line
+
+let result = chewieQuote.match(chewieRegex);
+```
+
+# --solutions--
+
+```js
+ let chewieRegex = /Aa*/;
+ let result = chewieQuote.match(chewieRegex);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md
new file mode 100644
index 00000000000..20dd4a6fda4
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md
@@ -0,0 +1,66 @@
+---
+id: 587d7db7367417b2b2512b9e
+title: Abgleich von String-Mustern am Ende
+challengeType: 1
+forumTopicId: 301352
+dashedName: match-ending-string-patterns
+---
+
+# --description--
+
+In der letzten Aufgabe hast du gelernt, das Caret-Zeichen zu verwenden, um nach Mustern am Anfang von Strings zu suchen. Es gibt auch eine Möglichkeit, nach Mustern am Ende von Strings zu suchen.
+
+Du kannst das Ende von Strings suchen, indem du das Dollarzeichen `$` am Ende des regulären Ausdrucks verwendest.
+
+```js
+let theEnding = "This is a never ending story";
+let storyRegex = /story$/;
+storyRegex.test(theEnding);
+let noEnding = "Sometimes a story will have to end";
+storyRegex.test(noEnding);
+```
+
+Der erste `test`-Aufruf würde `true` zurückgeben, während der zweite `false` zurückgeben würde.
+
+# --instructions--
+
+Verwende das Ankerzeichen (`$`), um den String `caboose` am Ende des Strings `caboose` zu finden.
+
+# --hints--
+
+Du solltest nach `caboose` mit dem Dollarzeichen `$` als Anker in deinem regulären Ausdruck suchen.
+
+```js
+assert(lastRegex.source == 'caboose$');
+```
+
+Dein regulärer Ausdruck sollte keine Flags verwenden.
+
+```js
+assert(lastRegex.flags == '');
+```
+
+Du solltest `caboose` am Ende des Strings `The last car on a train is the caboose` finden.
+
+```js
+lastRegex.lastIndex = 0;
+assert(lastRegex.test('The last car on a train is the caboose'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /change/; // Change this line
+let result = lastRegex.test(caboose);
+```
+
+# --solutions--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /caboose$/; // Change this line
+let result = lastRegex.test(caboose);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md
new file mode 100644
index 00000000000..eb21c86f2dc
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md
@@ -0,0 +1,92 @@
+---
+id: 587d7db8367417b2b2512ba0
+title: Alles außer Buchstaben und Zahlen finden
+challengeType: 1
+forumTopicId: 301353
+dashedName: match-everything-but-letters-and-numbers
+---
+
+# --description--
+
+Du hast gelernt, dass du eine Kurzform für alphanumerische Zeichen `[A-Za-z0-9_]` mit `\w` verwenden kannst. Ein natürliches Muster, nach dem du suchen kannst, ist das Gegenteil von alphanumerischen Zeichen.
+
+Mit `\W` kannst du nach dem Gegenteil von `\w` suchen. Beachte, dass das entgegengesetzte Muster einen Großbuchstaben verwendet. Diese Kurzform ist das Gleiche wie `[^A-Za-z0-9_]`.
+
+```js
+let shortHand = /\W/;
+let numbers = "42%";
+let sentence = "Coding!";
+numbers.match(shortHand);
+sentence.match(shortHand);
+```
+
+Der erste `match`-Aufruf würde den Wert `["%"]` und der zweite würde `["!"]` zurückgeben.
+
+# --instructions--
+
+Verwende die Kurzzeichen-Klasse `\W`, um die Anzahl der nicht alphanumerischen Zeichen in verschiedenen Zitaten und Strings zu zählen.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(nonAlphabetRegex.global);
+```
+
+Dein regulärer Ausdruck sollte 6 nicht-alphanumerische Zeichen in dem String `The five boxing wizards jump quickly.` finden.
+
+```js
+assert(
+ 'The five boxing wizards jump quickly.'.match(nonAlphabetRegex).length == 6
+);
+```
+
+Dein regulärer Ausdruck sollte das Kurzzeichen verwenden, um Zeichen zu finden, die nicht alphanumerisch sind.
+
+```js
+assert(/\\W/.test(nonAlphabetRegex.source));
+```
+
+Dein regulärer Ausdruck sollte 8 nicht-alphanumerische Zeichen in dem String `Pack my box with five dozen liquor jugs.` finden.
+
+```js
+assert(
+ 'Pack my box with five dozen liquor jugs.'.match(nonAlphabetRegex).length == 8
+);
+```
+
+Dein regulärer Ausdruck sollte 6 nicht-alphanumerische Zeichen in dem String `How vexingly quick daft zebras jump!` finden.
+
+```js
+assert(
+ 'How vexingly quick daft zebras jump!'.match(nonAlphabetRegex).length == 6
+);
+```
+
+Dein regulärer Ausdruck sollte 12 nicht-alphanumerische Zeichen in dem String `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` finden.
+
+```js
+assert(
+ '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(nonAlphabetRegex)
+ .length == 12
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let nonAlphabetRegex = /change/; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards_jump quickly.";
+let nonAlphabetRegex = /\W/g; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md
new file mode 100644
index 00000000000..e38c7ebcfef
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md
@@ -0,0 +1,71 @@
+---
+id: 587d7db5367417b2b2512b96
+title: Buchstaben des Alphabets abgleichen
+challengeType: 1
+forumTopicId: 301354
+dashedName: match-letters-of-the-alphabet
+---
+
+# --description--
+
+Du hast gesehen, wie du Zeichensätze verwenden kannst, um eine Gruppe von Zeichen zu bestimmen, die übereinstimmen sollen, aber das ist eine Menge Tipparbeit, wenn du einen großen Bereich von Zeichen abgleichen musst (zum Beispiel alle Buchstaben des Alphabets). Zum Glück gibt es eine eingebaute Funktion, die dies schnell und einfach erledigt.
+
+Im Zeichensatz können Bindestriche (`-`) verwendet werden, um den Bereich der zu übereinstimmenden Zeichen zu definieren.
+
+Um zum Beispiel die Kleinbuchstaben `a` bis `e` zu finden, würdest du `[a-e]` verwenden.
+
+```js
+let catStr = "cat";
+let batStr = "bat";
+let matStr = "mat";
+let bgRegex = /[a-e]at/;
+catStr.match(bgRegex);
+batStr.match(bgRegex);
+matStr.match(bgRegex);
+```
+
+In dieser Reihenfolge würden die drei `match`-Aufrufe die Werte `["cat"]`, `["bat"]` und `null` zurückgeben.
+
+# --instructions--
+
+Finde alle Buchstaben in dem String `quoteSample`.
+
+**Hinweis**: Achte darauf, dass sowohl Groß- als auch Kleinbuchstaben übereinstimmen.
+
+# --hints--
+
+Dein Regex `alphabetRegex` sollte 35 Einträge finden.
+
+```js
+assert(result.length == 35);
+```
+
+Dein Regex `alphabetRegex` sollte den globale Flag verwenden.
+
+```js
+assert(alphabetRegex.flags.match(/g/).length == 1);
+```
+
+Dein regulärer Ausdruck `alphabetRegex` sollte die Groß- und Kleinschreibung nicht berücksichtigen.
+
+```js
+assert(alphabetRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /change/; // Change this line
+let result = alphabetRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /[a-z]/gi; // Change this line
+let result = quoteSample.match(alphabetRegex); // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md
new file mode 100644
index 00000000000..e8e68e85f73
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md
@@ -0,0 +1,74 @@
+---
+id: 587d7db3367417b2b2512b8f
+title: Literal-Strings abgleichen
+challengeType: 1
+forumTopicId: 301355
+dashedName: match-literal-strings
+---
+
+# --description--
+
+In der letzten Aufgabe hast du nach dem Wort `Hello` gesucht, indem du den regulären Ausdruck `/Hello/` verwendet hast. Dieser Regex suchte nach einer wörtlichen Übereinstimmung mit dem String `Hello`. Hier ist ein weiteres Beispiel für die Suche nach einer wörtlichen Übereinstimmung des Strings `Kevin`:
+
+```js
+let testStr = "Hello, my name is Kevin.";
+let testRegex = /Kevin/;
+testRegex.test(testStr);
+```
+
+Dieser `test`-Aufruf gibt `true` zurück.
+
+Jede andere Form von `Kevin` wird nicht zutreffen. Zum Beispiel passt der Regex `/Kevin/` nicht zu `kevin` oder `KEVIN`.
+
+```js
+let wrongRegex = /kevin/;
+wrongRegex.test(testStr);
+```
+
+Dieser `test`-Aufruf gibt `false` zurück.
+
+Eine zukünftige Aufgabe wird zeigen, wie man auch diese anderen Formen abgleichen kann.
+
+# --instructions--
+
+Vervollständige den Regex `waldoRegex`, um `"Waldo"` in dem String `waldoIsHiding` mit einer wörtlichen Übereinstimmung zu finden.
+
+# --hints--
+
+Dein Regex `waldoRegex` sollte den String `Waldo` finden
+
+```js
+waldoRegex.lastIndex = 0;
+assert(waldoRegex.test(waldoIsHiding));
+```
+
+Deine Regex `waldoRegex` sollte nicht nach etwas Anderem suchen.
+
+```js
+waldoRegex.lastIndex = 0;
+assert(!waldoRegex.test('Somewhere is hiding in this text.'));
+```
+
+Du solltest mit deinem Regex einen literalen String-Match durchführen.
+
+```js
+assert(!/\/.*\/i/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /search/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
+
+# --solutions--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /Waldo/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md
new file mode 100644
index 00000000000..bf58e026016
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md
@@ -0,0 +1,78 @@
+---
+id: 587d7db9367417b2b2512ba4
+title: Nicht-Leerzeichen abgleichen
+challengeType: 1
+forumTopicId: 18210
+dashedName: match-non-whitespace-characters
+---
+
+# --description--
+
+Du hast gelernt, wie man nach Leerzeichen sucht, indem man `\s` mit einem kleingeschriebenen `s` verwendet. Du kannst auch nach allem außer Leerzeichen suchen.
+
+Suche nach Nicht-Leerzeichen mit `\S`, das ist ein groß geschriebenes `s`. Dieses Muster passt nicht auf Leerzeichen, Wagenrücklauf, Tabulator, Seitenvorschub und Zeilenumbruch. Du kannst es dir ähnlich vorstellen wie die Zeichenklasse `[^ \r\t\f\n\v]`.
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let nonSpaceRegex = /\S/g;
+whiteSpace.match(nonSpaceRegex).length;
+```
+
+Der Wert, der von der Methode `.length` zurückgegeben wird, wäre `32`.
+
+# --instructions--
+
+Ändere den regulären Ausdruck `countNonWhiteSpace`, um nach mehreren Zeichen ohne Leerzeichen in einem String zu suchen.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(countNonWhiteSpace.global);
+```
+
+Dein regulärer Ausdruck sollte das Kurzzeichen `\S` verwenden, um alle Zeichen ohne Leerzeichen zu finden.
+
+```js
+assert(/\\S/.test(countNonWhiteSpace.source));
+```
+
+Dein regulärer Ausdruck sollte 35 Nicht-Leerzeichen in dem String `Men are from Mars and women are from Venus.` finden.
+
+```js
+assert(
+ 'Men are from Mars and women are from Venus.'.match(countNonWhiteSpace)
+ .length == 35
+);
+```
+
+Dein regulärer Ausdruck sollte 23 Nicht-Leerzeichen in dem String `Space: the final frontier.` finden.
+
+```js
+assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
+```
+
+Dein regulärer Ausdruck sollte 21 Nicht-Leerzeichen in dem String `MindYourPersonalSpace` finden.
+
+```js
+assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /change/; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /\S/g; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md
new file mode 100644
index 00000000000..5b1de161591
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md
@@ -0,0 +1,63 @@
+---
+id: 587d7db5367417b2b2512b97
+title: Zahlen und Buchstaben des Alphabets abgleichen
+challengeType: 1
+forumTopicId: 301356
+dashedName: match-numbers-and-letters-of-the-alphabet
+---
+
+# --description--
+
+Die Verwendung des Bindestrichs (`-`) für eine Reihe von Zeichen ist nicht auf Buchstaben beschränkt. Es funktioniert auch, um eine Reihe von Zahlen abzugleichen.
+
+Zum Beispiel passt `/[0-5]/` zu jeder Zahl zwischen `0` und `5`, einschließlich der `0` und `5`.
+
+Es ist auch möglich, eine Reihe von Buchstaben und Zahlen in einem einzigen Zeichensatz zu kombinieren.
+
+```js
+let jennyStr = "Jenny8675309";
+let myRegex = /[a-z0-9]/ig;
+jennyStr.match(myRegex);
+```
+
+# --instructions--
+
+Erstelle einen einzelnen regulärer Ausdruck, der auf einen Bereich von Buchstaben zwischen `h` und `s` und einen Bereich von Zahlen zwischen `2` und `6` passt. Vergiss nicht, die entsprechenden Flags in den regulärer Ausdruck einzufügen.
+
+# --hints--
+
+Dein regulärer Ausdruck `myRegex` sollte 17 Einträge finden.
+
+```js
+assert(result.length == 17);
+```
+
+Dein regulärer Ausdruck `myRegex` sollte das globale Flag verwenden.
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+Dein regulärer Ausdruck `myRegex` sollte die Groß-/Kleinschreibung nicht berücksichtigen.
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /[h-s2-6]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md
new file mode 100644
index 00000000000..610ff7f27e3
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db5367417b2b2512b95
+title: Ein einzelnes Zeichen mit mehreren Möglichkeiten abgleichen
+challengeType: 1
+forumTopicId: 301357
+dashedName: match-single-character-with-multiple-possibilities
+---
+
+# --description--
+
+Du hast gelernt, wie man literale Muster (`/literal/`) erkennt und das Wildcardzeichen (`/./`) verwendet. Das sind die Extreme der regulären Ausdrücke, von denen der eine exakte Übereinstimmungen findet und der andere alles abdeckt. Es gibt Möglichkeiten, die ein Gleichgewicht zwischen den beiden Extremen darstellen.
+
+Mit Zeichenklassen kannst du mit einer gewissen Flexibilität nach einem literalen Muster suchen. Mit Zeichenklassen kannst du eine Gruppe von Zeichen definieren, die du abgleichen möchtest, indem du sie in eckige (`[` und `]`) Klammern setzt.
+
+Du willst zum Beispiel `bag`, `big` und `bug` finden, aber nicht `bog`. Du kannst dafür den Regex `/b[aiu]g/` erstellen. `[aiu]` ist die Zeichenklasse, die nur auf die Zeichen `a`, `i` oder `u` passt.
+
+```js
+let bigStr = "big";
+let bagStr = "bag";
+let bugStr = "bug";
+let bogStr = "bog";
+let bgRegex = /b[aiu]g/;
+bigStr.match(bgRegex);
+bagStr.match(bgRegex);
+bugStr.match(bgRegex);
+bogStr.match(bgRegex);
+```
+
+In dieser Reihenfolge würden die vier `match`-Aufrufe die Werte `["big"]`, `["bag"]`, `["bug"]` und `null` zurückgeben.
+
+# --instructions--
+
+Verwende eine Zeichenklasse mit den Vokalen (`a`, `e`, `i`, `o`, `u`) in deinem Regex `vowelRegex`, um alle Vokale in dem String `quoteSample` zu finden.
+
+**Hinweis:** Achte darauf, dass sowohl Groß- als auch Kleinbuchstaben übereinstimmen.
+
+# --hints--
+
+Du solltest alle 25 Vokale finden.
+
+```js
+assert(result.length == 25);
+```
+
+Dein Regex `vowelRegex` sollte eine Zeichenklasse verwenden.
+
+```js
+assert(/\[.*\]/.test(vowelRegex.source));
+```
+
+Dein Regex `vowelRegex` sollte den global Flag verwenden.
+
+```js
+assert(vowelRegex.flags.match(/g/).length == 1);
+```
+
+Dein Regex `vowelRegex` sollte die Groß-/Kleinschreibung nicht berücksichtigen.
+
+```js
+assert(vowelRegex.flags.match(/i/).length == 1);
+```
+
+Dein Regex sollte keine Konsonanten enthalten.
+
+```js
+assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /change/; // Change this line
+let result = vowelRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /[aeiou]/gi; // Change this line
+let result = quoteSample.match(vowelRegex); // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md
new file mode 100644
index 00000000000..f14b431dce2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md
@@ -0,0 +1,57 @@
+---
+id: 587d7db6367417b2b2512b98
+title: Erkennung einzelner nicht spezifizierter Zeichen
+challengeType: 1
+forumTopicId: 301358
+dashedName: match-single-characters-not-specified
+---
+
+# --description--
+
+Bisher hast du eine Reihe von Zeichen erstellt, die du abgleichen möchtest, aber du kannst auch eine Reihe von Zeichen erstellen, die du nicht abgleichen möchtest. Diese Arten von Zeichensätzen werden negierte Zeichensätze genannt.
+
+Um einen negierten Zeichensatz zu erstellen, setzt du ein Caret-Zeichen (`^`) nach der öffnenden Klammer und vor den Zeichen, die du nicht abgleichen willst.
+
+Zum Beispiel passt `/[^aeiou]/gi` auf alle Zeichen, die keine Vokale sind. Beachte, dass Zeichen wie `.`, `!`, `[`, `@`, `/` und Leerzeichen erkannt werden - der negierte Vokalzeichensatz schließt nur die Vokale aus.
+
+# --instructions--
+
+Erstelle einen einzelnen regulären Ausdruck, der auf alle Zeichen passt, die keine Zahlen oder Vokale sind. Vergiss nicht, die entsprechenden Flags in deine regulären Ausdruck aufzunehmen.
+
+# --hints--
+
+Dein regulärer Ausdruck `myRegex` sollte 9 Einträge finden.
+
+```js
+assert(result.length == 9);
+```
+
+Dein regulärer Ausdruck `myRegex` sollte das globale Flag verwenden.
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+Dein regulärer Ausdruck`myRegex` sollte die Groß-/Kleinschreibung unberücksichtigt lassen.
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /[^0-9aeiou]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md
new file mode 100644
index 00000000000..73bf6b9f62e
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md
@@ -0,0 +1,77 @@
+---
+id: 587d7db8367417b2b2512ba3
+title: Leerzeichen abgleichen
+challengeType: 1
+forumTopicId: 301359
+dashedName: match-whitespace
+---
+
+# --description--
+
+Bei den bisherigen Aufgaben ging es darum, Buchstaben des Alphabets und Zahlen zu finden. Du kannst auch die Leerzeichen zwischen den Buchstaben abgleichen.
+
+Du kannst nach Leerzeichen suchen, indem du `\s` verwendest, das ist ein kleingeschriebenes `s`. Dieses Muster passt nicht nur auf Leerzeichen, sondern auch auf Wagenrücklauf (carriage return)-, Tabulator-, Seitenvorschub- und Zeilenvorschubzeichen. Du kannst dir das so ähnlich vorstellen wie die Zeichenklasse `[ \r\t\f\n\v]`.
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let spaceRegex = /\s/g;
+whiteSpace.match(spaceRegex);
+```
+
+Dieser `match`-Aufruf würde `[" ", " "]` zurückgeben.
+# --instructions--
+
+Ändere den regulärer Ausdruck `countWhiteSpace`, um nach mehreren Leerzeichen in einem String zu suchen.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte den globalen Flag verwenden.
+
+```js
+assert(countWhiteSpace.global);
+```
+
+Dein regulärer Ausdruck sollte das Kurzzeichen `\s` verwenden, um alle Leerzeichen abzugleichen.
+
+```js
+assert(/\\s/.test(countWhiteSpace.source));
+```
+
+Dein regulärer Ausdruck sollte acht Leerzeichen in dem String `Men are from Mars and women are from Venus.` finden.
+
+```js
+assert(
+ 'Men are from Mars and women are from Venus.'.match(countWhiteSpace).length ==
+ 8
+);
+```
+
+Dein regulärer Ausdruck sollte drei Leerzeichen in dem String `Space: the final frontier.` finden.
+
+```js
+assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
+```
+
+Dein regulärer Ausdruck sollte keine Leerzeichen in dem String `MindYourPersonalSpace` finden.
+
+```js
+assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /change/; // Change this line
+let result = sample.match(countWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /\s/g;
+let result = sample.match(countWhiteSpace);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md
new file mode 100644
index 00000000000..746bbdacc62
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md
@@ -0,0 +1,122 @@
+---
+id: 587d7dba367417b2b2512ba9
+title: Positive vorausschauende Behauptung und negative zurückblickende Behauptung (Lookaheads)
+challengeType: 1
+forumTopicId: 301360
+dashedName: positive-and-negative-lookahead
+---
+
+# --description--
+
+Lookaheads sind Muster, die JavaScript anweisen, in deinem String nach Mustern zu suchen, die weiter hinten liegen. Das kann nützlich sein, wenn du nach mehreren Mustern für denselben String suchen willst.
+
+Es gibt zwei Arten von Lookaheads: positive Lookaheads und negative Lookaheads .
+
+Ein positiver Lookahead prüft, ob das Element im Suchmuster vorhanden ist, gleicht es aber nicht tatsächlich ab. Ein positiver Lookahead wird in Form von `(?=...)` verwendet, wobei das `...` der erforderliche Teil ist, der nicht abgeglichen wird.
+
+Ein negativer Lookahead hingegen prüft, ob das Element im Suchmuster nicht vorhanden ist. Ein negativer Lookahead wird in Form von `(?!...)` verwendet, wobei `...` das Muster ist, das du nicht haben willst. Der Rest des Musters wird zurückgegeben, wenn der negative Lookahead-Teil nicht vorhanden ist.
+
+Die Lookaheads sind etwas verwirrend, aber ein paar Beispiele werden dir helfen.
+
+```js
+let quit = "qu";
+let noquit = "qt";
+let quRegex= /q(?=u)/;
+let qRegex = /q(?!u)/;
+quit.match(quRegex);
+noquit.match(qRegex);
+```
+
+Beide `match`-Aufrufe würden `["q"]` zurückgeben.
+
+Eine praktischere Anwendung von Lookaheads ist die Überprüfung von zwei oder mehr Mustern in einem String. Hier ist ein (naiver) einfacher Passwortprüfer, der nach 3 bis 6 Zeichen und mindestens einer Zahl sucht:
+
+```js
+let password = "abc123";
+let checkPass = /(?=\w{3,6})(?=\D*\d)/;
+checkPass.test(password);
+```
+
+# --instructions--
+
+Verwende Lookaheads in der `pwRegex`, um Passwörter abzugleichen, die mehr als 5 Zeichen lang sind und zwei aufeinanderfolgende Ziffern haben.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte zwei positive `lookaheads` verwenden.
+
+```js
+assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `astronaut` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('astronaut'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `banan1` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('banan1'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `bana12` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('bana12'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `abc123` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('abc123'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `12345` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('12345'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `8pass99` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('8pass99'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `1a2bcde` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(!pwRegex.test('1a2bcde'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `astr1on11aut` passen.
+
+```js
+pwRegex.lastIndex = 0;
+assert(pwRegex.test('astr1on11aut'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sampleWord = "astronaut";
+let pwRegex = /change/; // Change this line
+let result = pwRegex.test(sampleWord);
+```
+
+# --solutions--
+
+```js
+let pwRegex = /(?=\w{6})(?=\w*\d{2})/;
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md
new file mode 100644
index 00000000000..05c2fd4b754
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md
@@ -0,0 +1,61 @@
+---
+id: 587d7dbb367417b2b2512bac
+title: Leerzeichen am Anfang und Ende entfernen
+challengeType: 1
+forumTopicId: 301362
+dashedName: remove-whitespace-from-start-and-end
+---
+
+# --description--
+
+Manchmal sind Leerzeichen um Strings herum nicht erwünscht, aber sie sind da. Bei der typischen Verarbeitung von Strings werden die Leerzeichen am Anfang und am Ende entfernt.
+
+# --instructions--
+
+Schreibe einen regulären Ausdruck und verwende die entsprechenden String-Methoden, um Leerzeichen am Anfang und Ende von Strings zu entfernen.
+
+**Hinweis:** Die Methode `String.prototype.trim()` würde hier funktionieren, aber du musst diese Aufgabe mit regulären Ausdrücken lösen.
+
+# --hints--
+
+`result` sollte gleich dem String `Hello, World!` sein.
+
+```js
+assert(result === 'Hello, World!');
+```
+
+Deine Lösung sollte nicht die Methode `String.prototype.trim()` verwenden.
+
+```js
+assert(!code.match(/\.?[\s\S]*?trim/));
+```
+
+Der Variable `result` sollte nicht direkt ein String zugewiesen werden.
+
+```js
+assert(!code.match(/result\s*=\s*["'`].*?["'`]/));
+```
+
+Der Wert der Variable `hello` sollte nicht geändert werden.
+
+```js
+assert(hello === ' Hello, World! ');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let hello = " Hello, World! ";
+let wsRegex = /change/; // Change this line
+let result = hello; // Change this line
+```
+
+# --solutions--
+
+```js
+let hello = " Hello, World! ";
+let wsRegex = /^(\s+)(.+[^\s])(\s+)$/;
+let result = hello.replace(wsRegex, '$2');
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md
new file mode 100644
index 00000000000..4577050328a
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md
@@ -0,0 +1,136 @@
+---
+id: 587d7db8367417b2b2512ba2
+title: Mögliche Benutzernamen einschränken
+challengeType: 1
+forumTopicId: 301363
+dashedName: restrict-possible-usernames
+---
+
+# --description--
+
+Nutzernamen werden überall im Internet verwendet. Sie geben den Nutzern eine einzigartige Identität auf ihren Lieblingsseiten.
+
+Du musst alle Benutzernamen in einer Datenbank überprüfen. Hier sind einige einfache Regeln, die du bei der Erstellung deines Benutzernamens beachten musst.
+
+1) Nutzernamen dürfen nur alphanumerische Zeichen enthalten.
+
+2) Die einzigen Zahlen im Benutzernamen müssen am Ende stehen. Am Ende können es null oder mehr sein. Der Benutzername darf nicht mit einer Zahl beginnen.
+
+3) Der Benutzername kann in Klein- und Großbuchstaben geschrieben werden.
+
+4) Benutzernamen müssen mindestens zwei Zeichen lang sein. Ein zweistelliger Benutzername kann nur Buchstaben des Alphabets als Zeichen verwenden.
+
+# --instructions--
+
+Ändere den regulären Ausdruck `userCheck` so, dass er den oben genannten Bedingungen entspricht.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte auf den String `JACK` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('JACK'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `J` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('J'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `Jo` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Jo'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `Oceans11` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Oceans11'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `RegexGuru` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('RegexGuru'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `007` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('007'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `9` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('9'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `A1` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('A1'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `BadUs3rnam3` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('BadUs3rnam3'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `Z97` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('Z97'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `c57bT3` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('c57bT3'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `AB1` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(userCheck.test('AB1'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `J%4` passen.
+
+```js
+userCheck.lastIndex = 0;
+assert(!userCheck.test('J%4'))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let username = "JackOfAllTrades";
+let userCheck = /change/; // Change this line
+let result = userCheck.test(username);
+```
+
+# --solutions--
+
+```js
+let username = "JackOfAllTrades";
+const userCheck = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i;
+let result = userCheck.test(username);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md
new file mode 100644
index 00000000000..c42760250a2
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md
@@ -0,0 +1,115 @@
+---
+id: 587d7dbb367417b2b2512baa
+title: Wiederverwendung von Mustern mithilfe von Erfassungsgruppen
+challengeType: 1
+forumTopicId: 301364
+dashedName: reuse-patterns-using-capture-groups
+---
+
+# --description--
+
+Angenommen, du willst ein Wort finden, das mehrmals vorkommt, wie unten.
+
+```js
+let repeatStr = "row row row your boat";
+```
+
+Du könntest `/row row row/` verwenden, aber was ist, wenn du nicht weißt, welches Wort wiederholt wird? Erfassungsgruppen (Capture Groups) können verwendet werden, um wiederholte Teilstrings zu finden.
+
+Erfassungsgruppen werden gebildet, indem das zu erfassende Regex-Muster in Klammern eingeschlossen wird. In diesem Fall ist das Ziel, ein Wort zu erfassen, das aus alphanumerischen Zeichen besteht, also wird die Erfassungsgruppe `\w+` sein, eingeschlossen von Klammern: `/(\w+)/`.
+
+Der Teilstring, auf den die Gruppe passt, wird in einer temporären "Variablen" gespeichert, auf die innerhalb desselben regulären Ausdrucks mit einem Backslash und der Nummer der Erfassungsgruppe zugegriffen werden kann (z.B. `\1`). Erfassungsgruppen werden automatisch nach der Position ihrer öffnenden Klammern (von links nach rechts) nummeriert, beginnend bei 1.
+
+Das folgende Beispiel passt auf ein Wort, das dreimal durch Leerzeichen getrennt vorkommt:
+
+```js
+let repeatRegex = /(\w+) \1 \1/;
+repeatRegex.test(repeatStr); // Returns true
+repeatStr.match(repeatRegex); // Returns ["row row row", "row"]
+```
+
+Wenn du die Methode `.match()` auf einen String anwendest, erhältst du ein Array mit dem passenden Teilstring zusammen mit seinen erfassten Gruppen zurück.
+
+
+# --instructions--
+
+Verwende Erfassungsgruppen in `reRegex`, um einen String zu finden, der nur aus der gleichen Zahl besteht, die genau dreimal durch einzelne Leerzeichen getrennt wiederholt wird.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte die Kurzzeichen-Klasse für Ziffern verwenden.
+
+```js
+assert(reRegex.source.match(/\\d/));
+```
+
+Dein regulärer Ausdruck sollte eine Erfassungsgruppe zweimal wiederverwenden.
+
+```js
+assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
+```
+
+Dein regulärer Ausdruck sollte auf den String `42 42 42` zutreffen.
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('42 42 42'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `100 100 100` zutreffen.
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('100 100 100'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `42 42 42 42` zutreffen.
+
+```js
+assert.equal('42 42 42 42'.match(reRegex.source), null);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `42 42` zutreffen.
+
+```js
+assert.equal('42 42'.match(reRegex.source), null);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `101 102 103` zutreffen
+
+```js
+reRegex.lastIndex = 0;
+assert(!reRegex.test('101 102 103'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `1 2 3` zutreffen.
+
+```js
+reRegex.lastIndex = 0;
+assert(!reRegex.test('1 2 3'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `10 10 10` zutreffen.
+
+```js
+reRegex.lastIndex = 0;
+assert(reRegex.test('10 10 10'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /change/; // Change this line
+let result = reRegex.test(repeatNum);
+```
+
+# --solutions--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /^(\d+)\s\1\s\1$/;
+let result = reRegex.test(repeatNum);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md
new file mode 100644
index 00000000000..26863800927
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md
@@ -0,0 +1,92 @@
+---
+id: 587d7db9367417b2b2512ba7
+title: Lege die genaue Anzahl der Übereinstimmungen fest
+challengeType: 1
+forumTopicId: 301365
+dashedName: specify-exact-number-of-matches
+---
+
+# --description--
+
+Du kannst die Unter- und Oberzahl der Muster mit Quantifizierern in geschweiften Klammern angeben. Manchmal möchtest du nur eine bestimmte Anzahl von Übereinstimmungen.
+
+Wenn du eine bestimmte Anzahl von Mustern angeben willst, gib einfach diese Zahl zwischen die geschweiften Klammern ein.
+
+Um zum Beispiel nur das Wort `hah` mit dem Buchstaben `a` `3` Mal zu finden, würde dein regulärer Ausdruck `/ha{3}h/` lauten.
+
+```js
+let A4 = "haaaah";
+let A3 = "haaah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleHA = /ha{3}h/;
+multipleHA.test(A4);
+multipleHA.test(A3);
+multipleHA.test(A100);
+```
+
+In dieser Reihenfolge würden die drei `test`-Aufrufe `false`, `true` und `false` zurückgeben.
+
+# --instructions--
+
+Ändere den regulären Ausdruck `timRegex` so, dass er nur auf das Wort `Timber` passt, wenn es vier Buchstaben `m` hat.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte geschweifte Klammern verwenden.
+
+```js
+assert(timRegex.source.match(/{.*?}/).length > 0);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Timber` passen.
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timber'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Timmber` passen.
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmber'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Timmmber` passen.
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmmber'));
+```
+
+Dein regulärer Ausdruck sollte mit dem String `Timmmmber` übereinstimmen.
+
+```js
+timRegex.lastIndex = 0;
+assert(timRegex.test('Timmmmber'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Timber` mit 30 `m` passen.
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Ti' + 'm'.repeat(30) + 'ber'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /change/; // Change this line
+let result = timRegex.test(timStr);
+```
+
+# --solutions--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /Tim{4}ber/; // Change this line
+let result = timRegex.test(timStr);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md
new file mode 100644
index 00000000000..8a6c930eea6
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md
@@ -0,0 +1,95 @@
+---
+id: 587d7db9367417b2b2512ba6
+title: Lege nur die niedrigste Anzahl von Übereinstimmungen fest
+challengeType: 1
+forumTopicId: 301366
+dashedName: specify-only-the-lower-number-of-matches
+---
+
+# --description--
+
+Du kannst die Unter- und Oberzahl der Muster mit Quantifizierern in geschweiften Klammern angeben. Manchmal willst du nur die Untergrenze für die Anzahl der Muster angeben, aber keine Obergrenze.
+
+Wenn du nur die Unterzahl der Muster angeben willst, behalte die erste Zahl gefolgt von einem Komma bei.
+
+Um zum Beispiel nur den String `hah` zu finden, in dem der Buchstabe `a` mindestens `3` Mal vorkommt, würde dein regulärer Ausdruck `/ha{3,}h/` lauten.
+
+```js
+let A4 = "haaaah";
+let A2 = "haah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleA = /ha{3,}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+multipleA.test(A100);
+```
+
+In dieser Reihenfolge würden die drei `test`-Aufrufe `true`, `false` und `true` zurückgeben.
+
+# --instructions--
+
+Ändere den regulärer Ausdruck `haRegex` so, dass er nur auf das Wort `Hazzah` passt, wenn es vier oder mehr Buchstaben `z` hat.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte geschweifte Klammern verwenden.
+
+```js
+assert(haRegex.source.match(/{.*?}/).length > 0);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Hazzah` zutreffen.
+
+```js
+haRegex.lastIndex = 0;
+assert(!haRegex.test('Hazzah'));
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Hazzzah` zutreffen.
+
+```js
+haRegex.lastIndex = 0;
+assert(!haRegex.test('Hazzzah'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `Hazzzzah` zutreffen.
+
+```js
+assert('Hazzzzah'.match(haRegex)[0].length === 8);
+```
+
+Dein regulärer Ausdruck sollte auf den String `Hazzzzzah` zutreffen.
+
+```js
+assert('Hazzzzzah'.match(haRegex)[0].length === 9);
+```
+
+Dein regulärer Ausdruck sollte auf den String `Hazzzzzzah` zutreffen
+
+```js
+assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
+```
+
+Dein regulärer Ausdruck sollte auf den String `Hazzah` passen, der 30 `z` enthält.
+
+```js
+assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /change/; // Change this line
+let result = haRegex.test(haStr);
+```
+
+# --solutions--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /Haz{4,}ah/; // Change this line
+let result = haRegex.test(haStr);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md
new file mode 100644
index 00000000000..5be6d964221
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md
@@ -0,0 +1,93 @@
+---
+id: 587d7db9367417b2b2512ba5
+title: Obere und untere Anzahl von Übereinstimmungen festlegen
+challengeType: 1
+forumTopicId: 301367
+dashedName: specify-upper-and-lower-number-of-matches
+---
+
+# --description--
+
+Erinnere dich daran, dass du das Pluszeichen `+` verwendest, um nach einem oder mehreren Zeichen und das Sternchen `*`, um nach null oder mehr Zeichen zu suchen. Diese sind praktisch, aber manchmal willst du eine bestimmte Reihe von Mustern abgleichen.
+
+Du kannst die untere und obere Anzahl der Muster mit Quantifizierer festlegen. Quantifizierer werden mit geschweiften Klammern verwendet (`{` und`}`). Du setzt zwei Zahlen zwischen die geschweiften Klammern - für die untere und obere Anzahl der Muster.
+
+Um zum Beispiel nur den Buchstaben `a` zu finden, der zwischen `3` und `5` Mal in dem String `ah` vorkommt, würde dein regulärer Ausdruck `/a{3,5}h/` lauten.
+
+```js
+let A4 = "aaaah";
+let A2 = "aah";
+let multipleA = /a{3,5}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+```
+
+Der erste `test`-Aufruf würde `true`, während der zweite `false` zurückgeben würde.
+
+# --instructions--
+
+Ändere den regulären Ausdruck `ohRegex` so, dass er nur dann mit der gesamten Phrase `Oh no` übereinstimmt, wenn sie aus `3` bis `6` Buchstaben `h` besteht.
+
+# --hints--
+
+Dein regulärer Ausdruck sollte geschweifte Klammern verwenden.
+
+```js
+assert(ohRegex.source.match(/{.*?}/).length > 0);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Ohh no` passen.
+
+```js
+ohRegex.lastIndex = 0;
+assert(!ohRegex.test('Ohh no'));
+```
+
+Dein regulärer Ausdruck sollte auf den String `Ohh no` passen.
+
+```js
+assert('Ohhh no'.match(ohRegex)[0].length === 7);
+```
+
+Dein regulärer Ausdruck sollte mit dem String `Ohhhh no` übereinstimmen.
+
+```js
+assert('Ohhhh no'.match(ohRegex)[0].length === 8);
+```
+
+Dein regulärer Ausdruck sollte auf den String `Ohhhh no` passen.
+
+```js
+assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
+```
+
+Dein regulärer Ausdruck sollte mit dem String `Ohhhhh no` übereinstimmen.
+
+```js
+assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
+```
+
+Dein regulärer Ausdruck sollte nicht auf den String `Ohhhhhhh no` passen.
+
+```js
+ohRegex.lastIndex = 0;
+assert(!ohRegex.test('Ohhhhhhh no'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /change/; // Change this line
+let result = ohRegex.test(ohStr);
+```
+
+# --solutions--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /Oh{3,6} no/; // Change this line
+let result = ohRegex.test(ohStr);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md
new file mode 100644
index 00000000000..32e29591e15
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md
@@ -0,0 +1,88 @@
+---
+id: 587d7dbb367417b2b2512bab
+title: Erfassungsgruppen für das Suchen und Ersetzen verwenden
+challengeType: 1
+forumTopicId: 301368
+dashedName: use-capture-groups-to-search-and-replace
+---
+
+# --description--
+
+Die Suche ist nützlich. Du kannst die Suche aber noch leistungsfähiger machen, indem du den Text, den du gefunden hast, auch veränderst (oder ersetzt).
+
+Du kannst Text in einem String suchen und ersetzen, indem du `.replace()` auf einen String anwendest. Die Eingabe für `.replace()` ist zunächst das Regex-Muster, nach dem du suchen willst. Der zweite Parameter ist der String, der die Übereinstimmung ersetzen soll, oder eine Funktion, die etwas tut.
+
+```js
+let wrongText = "The sky is silver.";
+let silverRegex = /silver/;
+wrongText.replace(silverRegex, "blue");
+```
+
+Der `replace`-Aufruf würde den String `The sky is blue.` zurückgeben.
+
+Du kannst auch auf Erfassungsgruppen in dem Ersetzungsstring mit Dollarzeichen (`$`) zugreifen.
+
+```js
+"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
+```
+
+Der `replace`-Aufruf würde den String `Camp Code` zurückgeben.
+
+# --instructions--
+
+Schreibe einen regulären Ausdruck `fixRegex` mit drei Erfassungsgruppen, der nach jedem Wort in dem String `one two three` sucht. Aktualisiere dann die Variable `replaceText`, um `one two three` durch den String `three two one` zu ersetzen und weise das Ergebnis der Variablen `result` zu. Achte darauf, dass du Erfassungsgruppen in dem Ersetzungsstring mit der Syntax des Dollarzeichens (`$`) verwendest.
+
+# --hints--
+
+Du solltest `.replace()` für das Suchen und Ersetzen verwenden.
+
+```js
+assert(code.match(/\.replace\(.*\)/));
+```
+
+Dein regulärer Ausdruck sollte den String `one two three` in den String `three two one` ändern.
+
+```js
+assert(result === 'three two one');
+```
+
+Du solltest die letzte Zeile nicht ändern.
+
+```js
+assert(code.match(/result\s*=\s*str\.replace\(.*?\)/));
+```
+
+`fixRegex` sollte mindestens drei Erfassungsgruppen verwenden.
+
+```js
+assert(new RegExp(fixRegex.source + '|').exec('').length - 1 >= 3);
+```
+
+`replaceText` sollte eingeklammerte Teilmusterstrings verwenden (d.h. der n-te eingeklammerte Teilmusterstring, $n, entspricht der n-ten Erfassungsgruppe).
+
+```js
+{
+ const re = /(\$\d{1,2})+(?:[\D]|\b)/g;
+ assert(replaceText.match(re).length >= 3);
+}
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let str = "one two three";
+let fixRegex = /change/; // Change this line
+let replaceText = ""; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
+
+# --solutions--
+
+```js
+let str = "one two three";
+let fixRegex = /(\w+) (\w+) (\w+)/g; // Change this line
+let replaceText = "$3 $2 $1"; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
diff --git a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md
new file mode 100644
index 00000000000..80b6afc6c8d
--- /dev/null
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md
@@ -0,0 +1,59 @@
+---
+id: 587d7db3367417b2b2512b8e
+title: Anwendung der Methode test
+challengeType: 1
+forumTopicId: 301369
+dashedName: using-the-test-method
+---
+
+# --description--
+
+Reguläre Ausdrücke (Regex) werden in Programmiersprachen verwendet, um Teile von Texten abzugleichen. Du erstellst Muster ("Pattern"), die dir bei diesem Abgleich helfen.
+
+Wenn du das Wort `the` in dem String `The dog chased the cat` finden willst, kannst du den folgenden regulären Ausdruck verwenden: `/the/`. Beachte, dass Anführungszeichen innerhalb des regulären Ausdrucks nicht erforderlich sind.
+
+JavaScript hat mehrere Möglichkeiten, Regexe zu verwenden. Eine Möglichkeit, eine Regex zu testen, ist die Methode `.test()`. Die Methode `.test()` nimmt den Regex, wendet ihn auf einen String an (der in die Klammern gesetzt wird) und gibt `true` oder `false` zurück, wenn dein Muster etwas findet oder nicht.
+
+```js
+let testStr = "freeCodeCamp";
+let testRegex = /Code/;
+testRegex.test(testStr);
+```
+
+Die Methode `test` gibt hier `true` zurück.
+
+# --instructions--
+
+Wende den Regex `myRegex` auf den String `myString` mit der Methode `.test()` an.
+
+# --hints--
+
+Du solltest `.test()` verwenden, um den Regex zu testen.
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+Dein Ergebnis sollte `true` zurückgeben.
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex.test(myString); // Change this line
+```
diff --git a/curriculum/challenges/german/03-front-end-development-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md b/curriculum/challenges/german/03-front-end-development-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md
new file mode 100644
index 00000000000..d3c263a2435
--- /dev/null
+++ b/curriculum/challenges/german/03-front-end-development-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md
@@ -0,0 +1,90 @@
+---
+id: bad87fee1348bd9aec908849
+title: Füge Elemente deinen Bootstrap Wells hinzu
+challengeType: 0
+forumTopicId: 16636
+dashedName: add-elements-within-your-bootstrap-wells
+---
+
+# --description--
+
+Jetzt sind wir mehrere `div`-Elemente tief in jeder Spalte unserer Reihe. Tiefer werden wir nicht gehen. Nun können wir unsere `button`-Elemente hinzufügen.
+
+Verschachtel drei `button`-Elemente in jedes deiner `div`-Elemente mit dem Klassennamen `well`.
+
+# --hints--
+
+Drei `button`-Elemente sollten in jedem deiner `div`-Elemente der Klasse `well` verschachtelt sein.
+
+```js
+assert(
+ $('div.well:eq(0)').children('button').length === 3 &&
+ $('div.well:eq(1)').children('button').length === 3
+);
+```
+
+Du solltest insgesamt 6 `button`-Elemente haben.
+
+```js
+assert($('button') && $('button').length > 5);
+```
+
+All deine `button`-Elemente sollten abschließende Tags enthalten.
+
+```js
+assert(
+ code.match(/<\/button>/g) &&
+ code.match(//g).length === code.match(/
+ jQuery Playground
+
+ 
+```
+
+Menschen mit Sehbehinderungen sind auf Screenreader angewiesen, um Webinhalte in eine Sprachausgabe umzuwandeln. Sie erhalten keine Informationen, wenn sie nur visuell dargestellt werden. Bei Bildern können Screenreader auf das `alt`-Attribut zugreifen und dessen Inhalt lesen, um wichtige Informationen zu liefern.
+
+Ein guter `alt` Text liefert dem Leser eine kurze Beschreibung des Bildes. Du solltest immer ein `alt`-Attribut in dein Bild einfügen. Gemäß der HTML5-Spezifikation wird dies nun als verbindlich angesehen.
+
+# --instructions--
+
+Camper Cat ist zufällig sowohl ein Coding Ninja als auch ein tatsächlicher Ninja, der eine Website aufbaut um sein Wissen zu teilen. Das Profilbild, das er verwenden möchte, zeigt seine Fähigkeiten und sollte von allen Besuchern der Website wahrgenommen werden. Füge ein `alt`-Attribut in den `img`-Tag ein, das erklärt, dass Camper Cat Karate praktiziert. (Das Bild `src` verweist nicht auf eine tatsächliche Datei, du solltest also den `alt`-Text in der Anzeige sehen.)
+
+# --hints--
+
+Dein `img`-Tag sollte ein `alt`-Attribut besitzen und dieses sollte nicht leer sein.
+
+```js
+assert($('img').attr('alt'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+# --solutions--
+
+```html
+
+ 
+ 
+```
+
+Auch Hintergrundbilder fallen in der Regel unter das Stichwort "dekorativ". Allerdings werden sie in der Regel mit CSS-Regeln angewendet und sind daher nicht Teil des Markup-Screenreader-Prozesses.
+
+**Hinweis:** Bei Bildern mit einer Bildunterschrift solltest du trotzdem `alt`-Text einfügen, da er Suchmaschinen hilft, den Inhalt des Bildes zu katalogisieren.
+
+# --instructions--
+
+Camper Cat hat ein Seitengerüst für den Blog-Teil seiner Website codiert. Er plant, seine beiden Artikel mit einem dekorativen Bild eines Samuraischwertes optisch zu trennen. Füge ein `alt`-Attribut zum `img`-Tag hinzu und setze es auf einen leeren String. (Beachte, dass das Bild `src` nicht auf eine tatsächliche Datei verlinkt - mache dir keine Sorgen, dass in der Anzeige keine Schwerter zu sehen sind.)
+
+# --hints--
+
+Dein `img`-Tag sollte ein `alt`-Attribut haben.
+
+```js
+assert(!($('img').attr('alt') == undefined));
+```
+
+Das `alt`-Attribut sollte auf einen leeren String gesetzt werden.
+
+```js
+assert($('img').attr('alt') == '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+