chore(i18n,learn): processed translations (#47330)

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 <dfn>Indizes</dfn> 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 <dfn>nullbasierte</dfn> Indizierung, so dass das erste Element in einem Array den Index `0` hat.
+
+<br>
+
+**Beispiel**
+
+```js
+const array = [50, 60, 70];
+console.log(array[0]);
+const data = array[1];
+```
+
+`console.log(array[0])` gibt `50` aus, und `data` hat den Wert `60`.
+
+# --instructions--
+
+Erstelle eine Variable namens `myData` und setzte sie, mit Hilfe von Klammernotation, mit dem ersten Wert von `myArray` gleich.
+
+# --hints--
+
+Die Variable `myData` sollte gleich dem ersten Wert von `myArray` sein.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myArray !== 'undefined' &&
+      typeof myData !== 'undefined' &&
+      myArray[0] === myData
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+Die Daten in der Variable `myArray` sollten mit Hilfe von Klammernotation abgerufen werden.
+
+```js
+assert(
+  (function () {
+    if (code.match(/\s*=\s*myArray\[0\]/g)) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,z){return 'myArray = ' + JSON.stringify(y) + ', myData = ' + JSON.stringify(z);})(myArray, myData);}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [50, 60, 70];
+
+
+```
+
+# --solutions--
+
+```js
+const myArray = [50, 60, 70];
+const myData = myArray[0];
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md

@@ -0,0 +1,77 @@
+---
+id: 56592a60ddddeae28f7aa8e1
+title: Zugriff auf mehrdimensionale Arrays mit Indizes
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckND4Cq'
+forumTopicId: 16159
+dashedName: access-multi-dimensional-arrays-with-indexes
+---
+
+# --description--
+
+Man kann sich ein <dfn>mehrdimensionales</dfn> 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];
+```

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];
+```

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"];
+```

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'];
+```

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;
+```

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];
+```

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";
+```

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;
+```

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;
+}
+```

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 <dfn>Literalen</dfn> 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;
+```

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 <dfn>Zuweisungsoperator</dfn> ein Wert zugewiesen wurde, kannst du den Wert dieser Variablen mit dem <dfn>Zuweisungsoperator</dfn> 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;
+```

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 <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">Speichern von Werten mit dem Zuweisungsoperator</a> 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);
+```

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!"]
+};
+```

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 <dfn>Pseudocode</dfn> 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";
+  }
+}
+```

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 */
+```

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 <dfn>Vergleichsoperatoren</dfn> 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 <dfn>Datentypen</dfn> 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";
+}
+```

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";
+}
+```

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";
+}
+```

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";
+}
+```

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";
+}
+```

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";
+}
+```

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";
+}
+```

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";
+}
+```

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 <dfn>logische Und</dfn>-Operator (`&&`) gibt `true` zurück, wenn und nur wenn die <dfn>Operanden</dfn> 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";
+}
+```

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 <dfn>logische Oder</dfn>-Operator (`||`) gibt `true` zurück, wenn einer der <dfn>Operanden</dfn> `true` ist. Andernfalls wird `false` zurückgegeben.
+
+Der <dfn>logische Oder</dfn>-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";
+}
+```

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;
+```

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;
+```

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;
+```

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;
+```

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 <dfn>Verkettungsoperator</dfn>. Du kannst einen neuen String aus anderen Strings zusammensetzen, indem du sie <dfn>verkettest</dfn>.
+
+**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.";
+```

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 <dfn>verketten</dfn>. 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.";
+```

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!";
+```

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);
+}
+```

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.
+
+<table class='table table-striped'><thead><tr><th>Veränderung der Zählung</th><th>Karten</th></tr></thead><tbody><tr><td>+1</td><td>2, 3, 4, 5, 6</td></tr><tr><td>0</td><td>7, 8, 9</td></tr><tr><td>-1</td><td>10, 'J', 'Q', 'K', 'A'</td></tr></tbody></table>
+
+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";
+  }
+}
+```

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 <dfn>Gleitkommazahlen</dfn> oder <dfn>floats</dfn> 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 <a href="https://forum.freecodecamp.org/" target="_blank" rel="noopener noreferrer nofollow">freeCodeCamp-Forum</a> 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;
+```

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);
+```

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 <dfn>Daten</dfn> alles, was für den Computer von Bedeutung ist. JavaScript bietet acht verschiedene <dfn>Datentypen</dfn>, 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).
+
+<dfn>Variablen</dfn> 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 <dfn>deklarieren</dfn> 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;
+```

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 <dfn>String</dfn> <dfn>literal</dfn> 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";
+```

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 <dfn>dekrementieren</dfn> 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--;
+```

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;
+```

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;
+```

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;
+```

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 <dfn>ausgelassen</dfn> 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.
+
+<table class='table table-striped'><thead><tr><th>Code</th><th>Ausgabe</th></tr></thead><tbody><tr><td><code>\'</code></td><td>einzelnes Anführungszeichen</td></tr><tr><td><code>\"</code></td><td>doppeltes Anführungszeichen</td></tr><tr><td><code>\\</code></td><td>Backslash</td></tr><tr><td><code>\n</code></td><td>Zeilenumbruch</td></tr><tr><td><code>\r</code></td><td>Wagenrücklauf (Carriage Return)</td></tr><tr><td><code>\t</code></td><td>Tabulator</td></tr><tr><td><code>\b</code></td><td>Backspace</td></tr><tr><td><code>\f</code></td><td>Seitenvorschub (Formfeed)</td></tr></tbody></table>
+
+*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.
+
+<blockquote>FirstLine<br>    \SecondLine<br>ThirdLine</blockquote>
+
+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";
+```

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 <dfn>"ausblenden"</dfn>, indem du einen <dfn>backslash</dfn> (`\`) 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 <dfn>Backlashes</dfn>, 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\".";
+```

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!";
+```

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;
+```

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 <dfn>Rest</dfn>-Operator `%` gibt den Rest der Division von zwei Zahlen an.
+
+**Beispiel**
+
+<blockquote>5 % 2 = 1 weil<br>Math.floor(5 / 2) = 2 (Quotient)<br>2 * 2 = 4<br>5 - 4 = 1 (Rest)</blockquote>
+
+**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.
+
+<blockquote>17 % 2 = 1 (17 ist ungerade)<br>48 % 2 = 0 (48 ist gerade)</blockquote>
+
+**Hinweis:** Der <dfn>Rest</dfn>-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 <dfn>Rest</dfn> (`%`) 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;
+```

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 <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">Speichern von Werten mit dem Zuweisungsoperator</a> 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();
+}
+```

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.
+
+<ol><li>Verwende <code>Math.random()</code>, um eine zufällige Dezimalzahl zu erzeugen.</li><li>Multipliziere diese zufällige Dezimalzahl mit <code>20</code>.</li><li>Verwende eine andere Funktion, <code>Math.floor()</code>, um die Zahl auf die nächste ganze Zahl abzurunden.</li></ol>
+
+Denke daran, dass `Math.random()` niemals eine `1` zurückgeben kann und weil wir abrunden, ist es unmöglich, tatsächlich `20` zu erhalten. Diese Technik liefert uns eine ganze Zahl zwischen `0` und `19`.
+
+Alles zusammengenommen sieht unser Code folgendermaßen aus:
+
+```js
+Math.floor(Math.random() * 20);
+```
+
+Wir rufen `Math.random()` auf, multiplizieren das Ergebnis mit 20 und übergeben den Wert dann an die Funktion `Math.floor()`, um den Wert auf die nächste ganze Zahl abzurunden.
+
+# --instructions--
+
+Verwende diese Technik, um eine zufällige ganze Zahl zwischen `0` und `9` zu erzeugen und zurückzugeben.
+
+# --hints--
+
+Das Ergebnis von `randomWholeNum` sollte eine ganze Zahl sein.
+
+```js
+assert(
+  typeof randomWholeNum() === 'number' &&
+    (function () {
+      var r = randomWholeNum();
+      return Math.floor(r) === r;
+    })()
+);
+```
+
+Du solltest `Math.random` verwenden, um eine Zufallszahl zu erzeugen.
+
+```js
+assert(code.match(/Math.random/g).length >= 1);
+```
+
+Du solltest das Ergebnis von `Math.random` mit 10 multiplizieren, damit es eine Zahl zwischen null und neun ergibt.
+
+```js
+assert(
+  code.match(/\s*?Math.random\s*?\(\s*?\)\s*?\*\s*?10[\D]\s*?/g) ||
+    code.match(/\s*?10\s*?\*\s*?Math.random\s*?\(\s*?\)\s*?/g)
+);
+```
+
+Du solltest `Math.floor` verwenden, um den Dezimalteil der Zahl zu entfernen.
+
+```js
+assert(code.match(/Math.floor/g).length >= 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomWholeNum();})();
+```
+
+## --seed-contents--
+
+```js
+function randomWholeNum() {
+
+  // Only change code below this line
+
+  return Math.random();
+}
+```
+
+# --solutions--
+
+```js
+function randomWholeNum() {
+  return Math.floor(Math.random() * 10);
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.md

@@ -0,0 +1,102 @@
+---
+id: cf1111c1c12feddfaeb2bdef
+title: Generiere zufällige Ganzzahlen innerhalb eines Bereichs
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83yu6'
+forumTopicId: 18187
+dashedName: generate-random-whole-numbers-within-a-range
+---
+
+# --description--
+
+Anstatt wie zuvor eine zufällige ganze Zahl zwischen Null und einer bestimmten Zahl zu erzeugen, können wir eine zufällige ganze Zahl erzeugen, die in einen Bereich von zwei bestimmten Zahlen fällt.
+
+Dazu legen wir eine Mindestzahl `min` und eine Höchstzahl `max` fest.
+
+Hier ist die Formel, die wir verwenden werden. Nimm dir einen Moment Zeit, um ihn zu lesen und zu verstehen, was dieser Code macht:
+
+```js
+Math.floor(Math.random() * (max - min + 1)) + min
+```
+
+# --instructions--
+
+Erstelle eine Funktion namens `randomRange`, die einen Bereich `myMin` und `myMax` annimmt und eine zufällige ganze Zahl zurückgibt, die größer oder gleich `myMin` und kleiner oder gleich `myMax` ist.
+
+# --hints--
+
+Die niedrigste Zufallszahl, die mit `randomRange` erzeugt werden kann, sollte gleich deiner Mindestzahl, `myMin`, sein.
+
+```js
+assert(calcMin === 5);
+```
+
+Die höchste Zufallszahl, die mit `randomRange` erzeugt werden kann, sollte gleich deiner maximalen Zahl, `myMax`, sein.
+
+```js
+assert(calcMax === 15);
+```
+
+Die Zufallszahl, die von `randomRange` erzeugt wird, sollte eine ganze Zahl sein, keine Dezimalzahl.
+
+```js
+assert(randomRange(0, 1) % 1 === 0);
+```
+
+`randomRange` sollte sowohl `myMax` als auch `myMin` verwenden und eine Zufallszahl in deinem Bereich zurückgeben.
+
+```js
+assert(
+  (function () {
+    if (
+      code.match(/myMax/g).length > 1 &&
+      code.match(/myMin/g).length > 2 &&
+      code.match(/Math.floor/g) &&
+      code.match(/Math.random/g)
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var calcMin = 100;
+var calcMax = -100;
+for(var i = 0; i < 100; i++) {
+  var result = randomRange(5,15);
+  calcMin = Math.min(calcMin, result);
+  calcMax = Math.max(calcMax, result);
+}
+(function(){
+  if(typeof myRandom === 'number') {
+    return "myRandom = " + myRandom;
+  } else {
+    return "myRandom undefined";
+  }
+})()
+```
+
+## --seed-contents--
+
+```js
+function randomRange(myMin, myMax) {
+  // Only change code below this line
+  return 0;
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomRange(myMin, myMax) {
+  return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md

@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244be
+title: Globaler Gültigkeitsbereich (Scope) und Funktionen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQM7mCN'
+forumTopicId: 18193
+dashedName: global-scope-and-functions
+---
+
+# --description--
+
+In JavaScript bezieht sich <dfn>scope</dfn> auf die Sichtbarkeit von Variablen. Variablen, die außerhalb eines Funktionsblocks definiert werden, haben einen <dfn>globalen</dfn> 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);
+}
+```

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 <dfn>lokale</dfn> als auch <dfn>globale</dfn> 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;
+}
+```

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):
+
+<table class='table table-striped'><thead><tr><th>Schläge</th><th>Ausgabe</th></tr></thead><tbody><tr><td>1</td><td>"Hole-in-one!"</td></tr><tr><td>&#x3C;= par - 2</td><td>"Eagle"</td></tr><tr><td>par - 1</td><td>"Birdie"</td></tr><tr><td>par</td><td>"Par"</td></tr><tr><td>par + 1</td><td>"Bogey"</td></tr><tr><td>par + 2</td><td>"Double Bogey"</td></tr><tr><td>>= par + 3</td><td>"Go Home!"</td></tr></tbody></table>
+
+`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!";
+}
+```

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 <dfn>erhöhen</dfn> 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++;
+```

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 <dfn>initialisieren</dfn>.
+
+```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;
+```

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";
+  }
+}
+```

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;
+}
+```

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);
+}
+```

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];
+}
+```

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)
+```

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);
+}
+```

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--;
+}
+```

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 <dfn>lokalen</dfn> 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);
+```

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";
+  }
+}
+```

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();
+```

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 <dfn>Parameter</dfn> 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]);
+```

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();
+```

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]);
+```

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 <dfn>Datenstruktur</dfn> speichern. Ein JavaScript-Objekt ist eine Möglichkeit, flexible Daten zu verarbeiten. Sie erlauben beliebige Kombinationen von <dfn>Strings</dfn>, <dfn>Zahlen</dfn>, <dfn>Booleans</dfn>, <dfn>Arrays</dfn>, <dfn>Funktionen</dfn> und <dfn>Objekten</dfn>.
+
+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 <dfn>Metadaten</dfn> ü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",
+  ]
+  }
+];
+```

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 <dfn>änderbar (mutable)</dfn> 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;
+```

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;
+}
+```

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;
+```

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;
+```

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 <dfn>Mehrdimensionales Array</dfn> 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]];
+```

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;
+}
+```

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--
+
+<dfn>Parameter</dfn> 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 <dfn>"übergeben"</dfn> werden), wenn sie aufgerufen wird, nennt man <dfn>Argumente</dfn>.
+
+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--
+
+<ol><li>Erstelle eine Funktion namens <code>functionWithArgs</code>, die zwei Argumente akzeptiert und deren Summe auf der Konsole ausgibt.</li><li>Rufe die Funktion mit zwei Zahlen als Argumente auf.</li></ol>
+
+# --hints--
+
+`functionWithArgs` sollte eine Funktion sein.
+
+```js
+assert(typeof functionWithArgs === 'function');
+```
+
+`functionWithArgs(1,2)` sollte `3` ausgeben.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(1, 2);
+  uncapture();
+}
+assert(logOutput == 3);
+```
+
+`functionWithArgs(7,9)` sollte `16` ausgeben.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(7, 9);
+  uncapture();
+}
+assert(logOutput == 16);
+```
+
+Du solltest die `functionWithArgs` mit zwei Zahlen aufrufen, nachdem du sie definiert hast.
+
+```js
+assert(
+  /functionWithArgs\([-+]?\d*\.?\d*,[-+]?\d*\.?\d*\)/.test(
+    code.replace(/\s/g, '')
+  )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        if(message) logOutput = JSON.stringify(message).trim();
+        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();
+
+if (typeof functionWithArgs !== "function") { 
+  (function() { return "functionWithArgs is not defined"; })();
+} else {
+  (function() { return logOutput || "console.log never called"; })();
+}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function functionWithArgs(a, b) {
+  console.log(a + b);
+}
+functionWithArgs(10, 5);
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.md

@@ -0,0 +1,78 @@
+---
+id: 599a789b454f2bbd91a3ff4d
+title: Übe den Vergleich verschiedener Werte
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8PqCa'
+forumTopicId: 301174
+dashedName: practice-comparing-different-values
+---
+
+# --description--
+
+In den letzten beiden Aufgaben haben wir den Gleichheitsoperator (`==`) und den strikten Gleichheitsoperator (`===`) kennengelernt. Lass uns noch einmal kurz den Umgang mit diesen Operatoren üben.
+
+Wenn die zu vergleichenden Werte nicht vom gleichen Typ sind, führt der Gleichheitsoperator eine Typkonvertierung durch und wertet dann die Werte aus. Der strikte Gleichheitsoperator vergleicht jedoch sowohl den Datentyp als auch den Wert wie er ist, ohne einen Typ in den anderen zu konvertieren.
+
+**Beispiele**
+
+`3 == '3'` gibt `true` zurück, weil JavaScript eine Typkonvertierung von String zu Zahl durchführt. `3 === '3'` gibt false zurück, weil die Typen unterschiedlich sind und die Typkonvertierung nicht durchgeführt wird.
+
+**Hinweis:** In JavaScript kannst du den Typ einer Variablen oder eines Wertes mit dem `typeof`-Operator bestimmen, und zwar wie folgt:
+
+```js
+typeof 3
+typeof '3'
+```
+
+`typeof 3` gibt den String `number` zurück, und `typeof '3'` gibt den String `string` zurück.
+
+# --instructions--
+
+Die `compareEquality`-Funktion im Editor vergleicht zwei Werte mit dem Gleichheitsoperator. Ändere die Funktion so, dass sie den String `Equal` nur dann zurückgibt, wenn die Werte strikt gleich sind.
+
+# --hints--
+
+`compareEquality(10, "10")` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(compareEquality(10, '10') === 'Not Equal');
+```
+
+`compareEquality("20", 20)` sollte den String `Not Equal` zurückgeben
+
+```js
+assert(compareEquality('20', 20) === 'Not Equal');
+```
+
+Du solltest den Operator `===` verwenden
+
+```js
+assert(code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function compareEquality(a, b) {
+  if (a == b) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+compareEquality(10, "10");
+```
+
+# --solutions--
+
+```js
+function compareEquality(a,b) {
+  if (a === b) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.md

@@ -0,0 +1,144 @@
+---
+id: 5688e62ea601b2482ff8422b
+title: Nach Profilen suchen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqW2Cg'
+forumTopicId: 18259
+dashedName: profile-lookup
+---
+
+# --description--
+
+Wir haben eine Reihe von Objekten, die verschiedene Personen in unseren Kontaktlisten darstellen.
+
+Eine Funktion `lookUpProfile`, die `name` und eine Eigenschaft (`prop`) als Argumente nimmt, wurde bereits für dich geschrieben.
+
+Die Funktion sollte prüfen, ob `name` der `firstName` eines aktuellen Kontakts ist und die angegebene Eigenschaft (`prop`) eine Eigenschaft dieses Kontakts ist.
+
+Wenn beides wahr ist, wird der "Wert" der Eigenschaft zurückgegeben.
+
+Wenn `name` keinem Kontakt entspricht, wird der String `No such contact` zurückgegeben.
+
+Wenn `prop` keiner gültigen Eigenschaft eines Kontakts entspricht, der mit `name` übereinstimmt, wird der String `No such property` zurückgegeben.
+
+# --hints--
+
+`lookUpProfile("Kristian", "lastName")` sollte den String `Vos` zurückgeben
+
+```js
+assert(lookUpProfile('Kristian', 'lastName') === 'Vos');
+```
+
+`lookUpProfile("Sherlock", "likes")` sollte `["Intriguing Cases", "Violin"]` zurückgeben
+
+```js
+assert.deepEqual(lookUpProfile('Sherlock', 'likes'), [
+  'Intriguing Cases',
+  'Violin'
+]);
+```
+
+`lookUpProfile("Harry", "likes")` sollte ein Array zurückgeben
+
+```js
+assert(typeof lookUpProfile('Harry', 'likes') === 'object');
+```
+
+`lookUpProfile("Bob", "number")` sollte den String `No such contact` zurückgeben
+
+```js
+assert(lookUpProfile('Bob', 'number') === 'No such contact');
+```
+
+`lookUpProfile("Bob", "potato")` sollte den String `No such contact` zurückgeben
+
+```js
+assert(lookUpProfile('Bob', 'potato') === 'No such contact');
+```
+
+`lookUpProfile("Akira", "address")` sollte den String `No such property` zurückgeben
+
+```js
+assert(lookUpProfile('Akira', 'address') === 'No such property');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+
+function lookUpProfile(name, prop) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+lookUpProfile("Akira", "likes");
+```
+
+# --solutions--
+
+```js
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+function lookUpProfile(name, prop) {
+  for (let i in contacts) {
+    if (contacts[i].firstName === name) {
+      return contacts[i][prop] || "No such property";
+    }
+  }
+  return "No such contact";
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md

@@ -0,0 +1,81 @@
+---
+id: 56533eb9ac21ba0edf2244b4
+title: Zitierung von Strings mit einfachen Anführungszeichen
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmnhM'
+forumTopicId: 18260
+dashedName: quoting-strings-with-single-quotes
+---
+
+# --description--
+
+<dfn>String</dfn>-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 `<a>`-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 <dfn>goodStr</dfn> 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 `<a>`-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*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\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 = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
+```
+
+# --solutions--
+
+```js
+const myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
+```

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;
+}
+```

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 <dfn>Basisfall</dfn>, 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
+}
+```

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;
+}
+```

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 <dfn>Argumenten</dfn> 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 <dfn>Argument</dfn> 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);
+```

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 <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow"><code>undefined</code> ein Schlüsselwort</a> und kein String ist.
+
+# --hints--
+
+`abTest(2, 2)` sollte eine Zahl zurückgeben
+
+```js
+assert(typeof abTest(2, 2) === 'number');
+```
+
+`abTest(2, 2)` sollte `8` zurückgeben
+
+```js
+assert(abTest(2, 2) === 8);
+```
+
+`abTest(-2, 2)` sollte `undefined` zurückgeben
+
+```js
+assert(abTest(-2, 2) === undefined);
+```
+
+`abTest(2, -2)` sollte `undefined` zurückgeben
+
+```js
+assert(abTest(2, -2) === undefined);
+```
+
+`abTest(2, 8)` sollte `18` zurückgeben
+
+```js
+assert(abTest(2, 8) === 18);
+```
+
+`abTest(3, 3)` sollte `12` zurückgeben
+
+```js
+assert(abTest(3, 3) === 12);
+```
+
+`abTest(0, 0)` sollte `0` zurückgeben
+
+```js
+assert(abTest(0, 0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function abTest(a, b) {
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+
+abTest(2,2);
+```
+
+# --solutions--
+
+```js
+function abTest(a, b) {
+  if(a < 0 || b < 0) {
+    return undefined;
+  }
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+```

curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md

@@ -0,0 +1,82 @@
+---
+id: 5679ceb97cbaa8c51670a16b
+title: Boolesche Werte aus Funktionen zurückgeben
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp62qAQ'
+forumTopicId: 18273
+dashedName: returning-boolean-values-from-functions
+---
+
+# --description--
+
+Du erinnerst dich vielleicht aus dem <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank" rel="noopener noreferrer nofollow">Vergleich mit dem Gleichheitsoperator</a> 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;
+}
+```

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 <dfn>switch</dfn>-Anweisung. Eine `switch`-Anweisung testet einen Wert und kann viele <dfn>case</dfn>-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;
+}
+```

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]
+];
+```

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 <dfn>Warteschlange (Queue)</dfn> eine abstrakte <dfn>Datenstruktur</dfn>, 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();
+}
+```

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];
+```

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 <dfn>Zuweisungsoperator</dfn> (`=`) 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;
+```

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;
+```

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";
+  }
+}
+```

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 <dfn>unveränderlich</dfn>, 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 <dfn>String-Literal</dfn> 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";
+```

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 <dfn>Boolean</dfn>. 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
+}
+```

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 <dfn>camelCase</dfn>. Bei <dfn>camelCase</dfn> 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 <dfn>camelCase</dfn> 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;
+```

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();
+```

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 <dfn>"Not a Number"</dfn> (keine Zahl) bedeutet. Verkettest du den String einer `undefined`-Variablen, erhältst du den <dfn>String</dfn> `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!";
+```

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";
+```

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--
+
+<dfn>Die Klammer-Notation</dfn> 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 <dfn>nullbasierte</dfn> 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];
+```