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

2025-12-21 11:06:03 -05:00 · 2022-08-20 00:23:29 +05:30
parent 33548562b5
commit 7b23585ba9
870 changed files with 84864 additions and 551 deletions
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
@@ -0,0 +1,97 @@
+---
+id: a77dbc43c33f39daa4429b4f
+title: Boo wer?
+challengeType: 1
+forumTopicId: 16000
+dashedName: boo-who
+---
+
+# --description--
+
+Überprüfe, ob ein Wert als primitiver Boolean deklariert ist. Gib `true` (wahr) oder `false` (falsch) zurück.
+
+Primitive boolesche Werte umfassen `true` und `false`.
+
+# --hints--
+
+`booWho(true)` soll `true` zurückgeben.
+
+```js
+assert.strictEqual(booWho(true), true);
+```
+
+`booWho(false)` soll `true` zurückgeben.
+
+```js
+assert.strictEqual(booWho(false), true);
+```
+
+`booWho([1, 2, 3])` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho([1, 2, 3]), false);
+```
+
+`booWho([].slice)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho([].slice), false);
+```
+
+`booWho({ "a": 1 })` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho({ a: 1 }), false);
+```
+
+`booWho(1)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho(1), false);
+```
+
+`booWho(NaN)` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho(NaN), false);
+```
+
+`booWho("a")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('a'), false);
+```
+
+`booWho("true")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('true'), false);
+```
+
+`booWho("false")` soll `false` zurückgeben.
+
+```js
+assert.strictEqual(booWho('false'), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function booWho(bool) {
+  return bool;
+}
+
+booWho(null);
+```
+
+# --solutions--
+
+```js
+function booWho(bool) {
+  return typeof bool === "boolean";
+}
+
+booWho(null);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
@@ -0,0 +1,110 @@
+---
+id: a9bd25c716030ec90084d8a1
+title: Chunky Monkey
+challengeType: 1
+forumTopicId: 16005
+dashedName: chunky-monkey
+---
+
+# --description--
+
+Schreibe eine Funktion, die ein Array (erstes Argument) in Gruppen mit der Länge `size` (zweites Argument) aufteilt und sie als zweidimensionales Array zurückgibt.
+
+# --hints--
+
+`chunkArrayInGroups(["a", "b", "c", "d"], 2)` sollte `[["a", "b"], ["c", "d"]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [
+  ['a', 'b'],
+  ['c', 'd']
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` sollte `[[0, 1, 2], [3, 4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [
+  [0, 1, 2],
+  [3, 4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` sollte `[[0, 1], [2, 3], [4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` sollte `[[0, 1, 2, 3], [4, 5]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [
+  [0, 1, 2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` sollte`[[0, 1, 2], [3, 4, 5], [6]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [
+  [0, 1, 2],
+  [3, 4, 5],
+  [6]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` sollte `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [8]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` sollte `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]` zurückgeben.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5],
+  [6, 7],
+  [8]
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  return arr;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
+
+# --solutions--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  let out = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+
+  return out;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
@@ -0,0 +1,113 @@
+---
+id: acda2fb1324d9b0fa741e6b5
+title: Bestätige das Ende
+challengeType: 1
+forumTopicId: 16006
+dashedName: confirm-the-ending
+---
+
+# --description--
+
+Überprüfe, ob ein String (erstes Argument, `str`) mit einem gegebenen Target-String (zweites Argument, `target`) endet.
+
+Diese Aufgabe *kann* mit der Methode `.endsWith()` gelöst werden, die in ES2015 eingeführt wurde. Jedoch hätten wir für den Zweck dieser Aufgabe gerne, dass du stattdessen die JavaScript Substring-Methode verwendest.
+
+# --hints--
+
+`confirmEnding("Bastian", "n")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Bastian', 'n') === true);
+```
+
+`confirmEnding("Congratulation", "on")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Congratulation', 'on') === true);
+```
+
+`confirmEnding("Connor", "n")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Connor', 'n') === false);
+```
+
+`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` soll `false` zurückgeben.
+
+```js
+assert(
+  confirmEnding(
+    'Walking on water and developing software from a specification are easy if both are frozen',
+    'specification'
+  ) === false
+);
+```
+
+`confirmEnding("He has to give me a new name", "name")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('He has to give me a new name', 'name') === true);
+```
+
+`confirmEnding("Open sesame", "same")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'same') === true);
+```
+
+`confirmEnding("Open sesame", "sage")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'sage') === false);
+```
+
+`confirmEnding("Open sesame", "game")` soll `false` zurückgeben.
+
+```js
+assert(confirmEnding('Open sesame', 'game') === false);
+```
+
+`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` soll `false` zurückgeben.
+
+```js
+assert(
+  confirmEnding(
+    'If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing',
+    'mountain'
+  ) === false
+);
+```
+
+`confirmEnding("Abstraction", "action")` soll `true` zurückgeben.
+
+```js
+assert(confirmEnding('Abstraction', 'action') === true);
+```
+
+Dein Code sollte diese Aufgabe ohne die integrierte Methode `.endsWith()` lösen.
+
+```js
+assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function confirmEnding(str, target) {
+  return str;
+}
+
+confirmEnding("Bastian", "n");
+```
+
+# --solutions--
+
+```js
+function confirmEnding(str, target) {
+  return str.substring(str.length - target.length) === target;
+}
+
+confirmEnding("Bastian", "n");
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b3
+title: Umrechnung von Celsius in Fahrenheit
+challengeType: 1
+forumTopicId: 16806
+dashedName: convert-celsius-to-fahrenheit
+---
+
+# --description--
+
+Die Formel zur Umrechnung von Celsius in Fahrenheit lautet: Celsius mal `9/5`, plus `32`.
+
+Du erhältst eine vorgegebene Variable namens `celsius`, die für den Temperaturwert in Celsius steht. Verwende die vordefinierte Variable `fahrenheit` und weise ihr die Temperatur in Fahrenheit äquivalent zum gegebenen Temperaturwert in Celsius zu. Verwende die oben angegebene Formel um die Temperatur von Celsius in Fahrenheit umzurechnen.
+
+# --hints--
+
+`convertCtoF(0)` sollte eine Zahl zurückgeben
+
+```js
+assert(typeof convertCtoF(0) === 'number');
+```
+
+`convertCtoF(-30)` sollte den Wert `-22` zurückgeben
+
+```js
+assert(convertCtoF(-30) === -22);
+```
+
+`convertCtoF(-10)` sollte den Wert `14` zurückgeben
+
+```js
+assert(convertCtoF(-10) === 14);
+```
+
+`convertCtoF(0)` sollte den Wert `32` zurückgeben
+
+```js
+assert(convertCtoF(0) === 32);
+```
+
+`convertCtoF(20)` sollte den Wert `68` zurückgeben
+
+```js
+assert(convertCtoF(20) === 68);
+```
+
+`convertCtoF(30)` sollte den Wert `86` zurückgeben
+
+```js
+assert(convertCtoF(30) === 86);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertCtoF(celsius) {
+  let fahrenheit;
+  return fahrenheit;
+}
+
+convertCtoF(30);
+```
+
+# --solutions--
+
+```js
+function convertCtoF(celsius) {
+  let fahrenheit = celsius * 9/5 + 32;
+  return fahrenheit;
+}
+
+convertCtoF(30);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
@@ -0,0 +1,73 @@
+---
+id: a302f7aae1aa3152a5b413bc
+title: Faktorisierung einer Zahl
+challengeType: 1
+forumTopicId: 16013
+dashedName: factorialize-a-number
+---
+
+# --description--
+
+Gib die Fakultät der übergebenen ganzen Zahl zurück.
+
+Wenn die ganze Zahl mit dem Buchstaben `n` dargestellt wird, ist eine Fakultät das Produkt aller positiven ganzen Zahlen kleiner oder gleich `n`.
+
+Fakultäten werden häufig mit der Kurzschreibweise `n!` dargestellt.
+
+Zum Beispiel: `5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+Nur ganze Zahlen größer oder gleich null werden der Funktion übergeben.
+
+# --hints--
+
+`factorialize(5)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof factorialize(5) === 'number');
+```
+
+`factorialize(5)` sollte `120` zurückgeben.
+
+```js
+assert(factorialize(5) === 120);
+```
+
+`factorialize(10)` sollte `3628800` zurückgeben.
+
+```js
+assert(factorialize(10) === 3628800);
+```
+
+`factorialize(20)` sollte `2432902008176640000` zurückgeben.
+
+```js
+assert(factorialize(20) === 2432902008176640000);
+```
+
+`factorialize(0)` sollte `1` zurückgeben.
+
+```js
+assert(factorialize(0) === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function factorialize(num) {
+  return num;
+}
+
+factorialize(5);
+```
+
+# --solutions--
+
+```js
+function factorialize(num) {
+  return num < 1 ? 1 : num * factorialize(num - 1);
+}
+
+factorialize(5);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
@@ -0,0 +1,63 @@
+---
+id: adf08ec01beb4f99fc7a68f2
+title: Falsy Bouncer
+challengeType: 1
+forumTopicId: 16014
+dashedName: falsy-bouncer
+---
+
+# --description--
+
+Entferne alle fehlerhaften Werte aus einem Array.
+
+Folgendes sind fehlerhafte Werte in JavaScript: `false`, `null`, `0`, `""`, `undefined`, und `NaN`.
+
+Tipp: Versuche, jeden Wert in einen booleschen Wert zu konvertieren.
+
+# --hints--
+
+`bouncer([7, "ate", "", false, 9])` sollte `[7, "ate", 9]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]);
+```
+
+`bouncer(["a", "b", "c"])` sollte `["a", "b", "c"]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']);
+```
+
+`bouncer([false, null, 0, NaN, undefined, ""])` sollte `[]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []);
+```
+
+`bouncer([null, NaN, 1, 2, undefined])` sollte `[1, 2]` zurückgeben.
+
+```js
+assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function bouncer(arr) {
+  return arr;
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
+
+# --solutions--
+
+```js
+function bouncer(arr) {
+  return arr.filter(e => e);
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
@@ -0,0 +1,87 @@
+---
+id: a26cbbe9ad8655a977e1ceb5
+title: Finde das längste Wort in einem String
+challengeType: 1
+forumTopicId: 16015
+dashedName: find-the-longest-word-in-a-string
+---
+
+# --description--
+
+Gib die Länge des längsten Wortes im angegebenen Satz zurück.
+
+Deine Antwort sollte eine Zahl sein.
+
+# --hints--
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` sollte eine Zahl zurückgeben.
+
+```js
+assert(
+  typeof findLongestWordLength(
+    'The quick brown fox jumped over the lazy dog'
+  ) === 'number'
+);
+```
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` sollte `6` zurückgeben.
+
+```js
+assert(
+  findLongestWordLength('The quick brown fox jumped over the lazy dog') === 6
+);
+```
+
+`findLongestWordLength("May the force be with you")` sollte `5` zurückgeben.
+
+```js
+assert(findLongestWordLength('May the force be with you') === 5);
+```
+
+`findLongestWordLength("Google do a barrel roll")` sollte `6` zurückgeben.
+
+```js
+assert(findLongestWordLength('Google do a barrel roll') === 6);
+```
+
+`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` sollte `8` zurückgeben.
+
+```js
+assert(
+  findLongestWordLength(
+    'What is the average airspeed velocity of an unladen swallow'
+  ) === 8
+);
+```
+
+`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` sollte `19` zurückgeben.
+
+```js
+assert(
+  findLongestWordLength(
+    'What if we try a super-long word such as otorhinolaryngology'
+  ) === 19
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findLongestWordLength(str) {
+  return str.length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
+
+# --solutions--
+
+```js
+function findLongestWordLength(str) {
+  return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
@@ -0,0 +1,58 @@
+---
+id: a6e40f1041b06c996f7b2406
+title: Finders Keepers
+challengeType: 1
+forumTopicId: 16016
+dashedName: finders-keepers
+---
+
+# --description--
+
+Erstelle eine Funktion, die einen Array namens `arr` durchsucht und das erste Element zurückgibt, das einen "Wahrheitstest" besteht. Das bedeutet, dass ein Element `x` den "Wahrheitstest" bestanden hat, wenn `func(x)` gleich `true` (engl. wahr) ist. Wenn kein Element den Test besteht, gib `undefined` (engl. undefiniert) zurück.
+
+# --hints--
+
+`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` sollte `8` zurückgeben.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 8, 9, 10], function (num) {
+    return num % 2 === 0;
+  }),
+  8
+);
+```
+
+`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` sollte `undefined` zurückgeben.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 9], function (num) {
+    return num % 2 === 0;
+  }),
+  undefined
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findElement(arr, func) {
+  let num = 0;
+  return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
+
+# --solutions--
+
+```js
+function findElement(arr, func) {
+  return arr.filter(func)[0];
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
@@ -0,0 +1,117 @@
+---
+id: af2170cad53daa0770fabdea
+title: Mutations
+challengeType: 1
+forumTopicId: 16025
+dashedName: mutations
+---
+
+# --description--
+
+Gib `true` zurück, wenn der String im ersten Element des Arrays alle Buchstaben des Strings im zweiten Element des Arrays enthält.
+
+Zum Beispiel sollte `["hello", "Hello"]` den Wert `true` zurückgeben, weil unabhängig von der Groß- und Kleinschreibung, alle Buchstaben des zweiten Strings im ersten enthalten sind.
+
+Die Argumente `["hello", "hey"]` sollten `false` zurückgeben, weil der String `hello` kein `y` beinhaltet.
+
+Schließlich sollte `["Alien", "line"]` den Wert `true` zurückgeben, weil alle Buchstaben von `line` in `Alien` vorhanden sind.
+
+# --hints--
+
+`mutation(["hello", "hey"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['hello', 'hey']) === false);
+```
+
+`mutation(["hello", "Hello"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['hello', 'Hello']) === true);
+```
+
+`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true);
+```
+
+`mutation(["Mary", "Army"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Mary', 'Army']) === true);
+```
+
+`mutation(["Mary", "Aarmy"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Mary', 'Aarmy']) === true);
+```
+
+`mutation(["Alien", "line"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Alien', 'line']) === true);
+```
+
+`mutation(["floor", "for"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['floor', 'for']) === true);
+```
+
+`mutation(["hello", "neo"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['hello', 'neo']) === false);
+```
+
+`mutation(["voodoo", "no"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['voodoo', 'no']) === false);
+```
+
+`mutation(["ate", "date"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['ate', 'date']) === false);
+```
+
+`mutation(["Tiger", "Zebra"])` sollte `false` zurückgeben.
+
+```js
+assert(mutation(['Tiger', 'Zebra']) === false);
+```
+
+`mutation(["Noel", "Ole"])` sollte `true` zurückgeben.
+
+```js
+assert(mutation(['Noel', 'Ole']) === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mutation(arr) {
+  return arr;
+}
+
+mutation(["hello", "hey"]);
+```
+
+# --solutions--
+
+```js
+function mutation(arr) {
+  let hash = Object.create(null);
+
+  arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
+
+  return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
+}
+
+mutation(["hello", "hey"]);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
@@ -0,0 +1,84 @@
+---
+id: afcc8d540bea9ea2669306b6
+title: Repeat a String Repeat a String
+challengeType: 1
+forumTopicId: 16041
+dashedName: repeat-a-string-repeat-a-string
+---
+
+# --description--
+
+Wiederhole den vorgegeben String `str` (erstes Argument) für `num` male (zweites Argument). Gib einen leeren String zurück, falls `num` keine positive Zahl ist. Für den Zweck dieser Aufgabe sollte *nicht* die built-in Methode `.repeat()` verwendet werden.
+
+# --hints--
+
+`repeatStringNumTimes("*", 3)` sollte den String `***` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('*', 3) === '***');
+```
+
+`repeatStringNumTimes("abc", 3)` sollte den String `abcabcabc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
+```
+
+`repeatStringNumTimes("abc", 4)` sollte den String `abcabcabcabc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
+```
+
+`repeatStringNumTimes("abc", 1)` sollte den String `abc` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 1) === 'abc');
+```
+
+`repeatStringNumTimes("*", 8)` sollte den String `********` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('*', 8) === '********');
+```
+
+`repeatStringNumTimes("abc", -2)` sollte einen leeren String (`""`) zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', -2) === '');
+```
+
+Die built-in Methode `repeat()` sollte hier nicht verwendet werden.
+
+```js
+assert(!/\.repeat/g.test(code));
+```
+
+`repeatStringNumTimes("abc", 0)` sollte `""` zurückgeben.
+
+```js
+assert(repeatStringNumTimes('abc', 0) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function repeatStringNumTimes(str, num) {
+  return str;
+}
+
+repeatStringNumTimes("abc", 3);
+```
+
+# --solutions--
+
+```js
+function repeatStringNumTimes(str, num) {
+  if (num < 1) return '';
+  return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
+}
+
+repeatStringNumTimes("abc", 3);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
@@ -0,0 +1,92 @@
+---
+id: a789b3483989747d63b0e427
+title: Return Largest Numbers in Arrays
+challengeType: 1
+forumTopicId: 16042
+dashedName: return-largest-numbers-in-arrays
+---
+
+# --description--
+
+Gib ein Array zurück, das aus den größten Zahlen der Sub-Arrays besteht. Zur Vereinfachung wird das übergebene Array genau vier Sub-Arrays enthalten.
+
+Denk daran, dass du ein Array mit einem einfachen for-Loop durchlaufen kannst und auf jedes Element mit der Array-Syntax `arr[i]` zugreifen kannst.
+
+# --hints--
+
+`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` sollte ein Array zurückgeben.
+
+```js
+assert(
+  largestOfFour([
+    [4, 5, 1, 3],
+    [13, 27, 18, 26],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]).constructor === Array
+);
+```
+
+`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` sollte `[27, 5, 39, 1001]` zurückgeben.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [13, 27, 18, 26],
+    [4, 5, 1, 3],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]),
+  [27, 5, 39, 1001]
+);
+```
+
+`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` sollte `[9, 35, 97, 1000000]` zurückgeben.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [4, 9, 1, 3],
+    [13, 35, 18, 26],
+    [32, 35, 97, 39],
+    [1000000, 1001, 857, 1]
+  ]),
+  [9, 35, 97, 1000000]
+);
+```
+
+`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` sollte `[25, 48, 21, -3]` zurückgeben.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [17, 23, 25, 12],
+    [25, 7, 34, 48],
+    [4, -10, 18, 21],
+    [-72, -3, -17, -10]
+  ]),
+  [25, 48, 21, -3]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function largestOfFour(arr) {
+  return arr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
+
+# --solutions--
+
+```js
+function largestOfFour(arr) {
+  return arr.map(subArr => Math.max.apply(null, subArr));
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
@@ -0,0 +1,63 @@
+---
+id: a202eed8fc186c8434cb6d61
+title: Reverse a String
+challengeType: 1
+forumTopicId: 16043
+dashedName: reverse-a-string
+---
+
+# --description--
+
+Kehre den angegebenen String um.
+
+Möglicherweise musst du die Strings in ein Array umwandeln, bevor du sie umkehren kannst.
+
+Dein Ergebnis muss ein String sein.
+
+# --hints--
+
+`reverseString("hello")` sollte einen String zurückgeben.
+
+```js
+assert(typeof reverseString('hello') === 'string');
+```
+
+`reverseString("hello")` sollte den String `olleh` zurückgeben.
+
+```js
+assert(reverseString('hello') === 'olleh');
+```
+
+`reverseString("Howdy")` sollte den String `ydwoH` zurückgeben.
+
+```js
+assert(reverseString('Howdy') === 'ydwoH');
+```
+
+`reverseString("Greetings from Earth")` sollten den String `htraE morf sgniteerG` zurückgeben.
+
+```js
+assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function reverseString(str) {
+  return str;
+}
+
+reverseString("hello");
+```
+
+# --solutions--
+
+```js
+function reverseString(str) {
+  return str.split('').reverse().join('');
+}
+
+reverseString("hello");
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
@@ -0,0 +1,98 @@
+---
+id: 579e2a2c335b9d72dd32e05c
+title: Slice und Splice
+challengeType: 1
+forumTopicId: 301148
+dashedName: slice-and-splice
+---
+
+# --description--
+
+Du erhältst zwei Arrays und einen Index.
+
+Kopiere jedes Element des ersten Arrays in derselben Reihenfolge in das zweite Array.
+
+Füge die Elemente beginnend mit dem Index `n` des zweiten Arrays ein.
+
+Gib das resultierende Array zurück. Beide Input-Arrays sollten nach dem Ausführen der Funktion unverändert sein.
+
+# --hints--
+
+`frankenSplice([1, 2, 3], [4, 5], 1)` sollte `[4, 1, 2, 3, 5]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
+```
+
+`frankenSplice([1, 2], ["a", "b"], 1)` sollte `["a", 1, 2, "b"]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
+```
+
+`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` sollte `["head", "shoulders", "claw", "tentacle", "knees", "toes"]` zurückgeben.
+
+```js
+assert.deepEqual(
+  frankenSplice(
+    ['claw', 'tentacle'],
+    ['head', 'shoulders', 'knees', 'toes'],
+    2
+  ),
+  ['head', 'shoulders', 'claw', 'tentacle', 'knees', 'toes']
+);
+```
+
+Alle Elemente des ersten Arrays sollten in ihrer ursprünglichen Reihenfolgen zum zweiten Array hinzugefügt werden. `frankenSplice([1, 2, 3, 4], [], 0)` sollte `[1, 2, 3, 4]` zurückgeben.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
+```
+
+Das erste Array sollte nach dem Ausführen der Funktion unverändert bleiben.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr1, [1, 2]);
+```
+
+Das zweite Array sollte nach dem Ausführen der Funktion unverändert bleiben.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr2, ['a', 'b']);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+let testArr1 = [1, 2];
+let testArr2 = ["a", "b"];
+```
+
+## --seed-contents--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  return arr2;
+}
+
+frankenSplice([1, 2, 3], [4, 5, 6], 1);
+```
+
+# --solutions--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  // It's alive. It's alive!
+  let result = arr2.slice();
+  for (let i = 0; i < arr1.length; i++) {
+    result.splice(n+i, 0, arr1[i]);
+  }
+  return result;
+}
+
+frankenSplice([1, 2, 3], [4, 5], 1);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
@@ -0,0 +1,64 @@
+---
+id: ab6137d4e35944e21037b769
+title: Title Case a Sentence
+challengeType: 1
+forumTopicId: 16088
+dashedName: title-case-a-sentence
+---
+
+# --description--
+
+Gib den angegebenen String zurück, wobei der erste Buchstabe jeden Wortes groß geschrieben wird. Stelle sicher, dass der Rest der Wörter kleingeschrieben ist.
+
+Für den Zweck dieser Übung schreibe bitte auch Verbindungswörter wie `the` und `of` groß.
+
+# --hints--
+
+`titleCase("I'm a little tea pot")` soll einen String zurückgeben.
+
+```js
+assert(typeof titleCase("I'm a little tea pot") === 'string');
+```
+
+`titleCase("I'm a little tea pot")` soll den String `I'm A Little Tea Pot` zurückgeben.
+
+```js
+assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
+```
+
+`titleCase("sHoRt AnD sToUt")` soll den String `Short And Stout` zurückgeben.
+
+```js
+assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
+```
+
+`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` soll den String `Here Is My Handle Here Is My Spout` zurückgeben.
+
+```js
+assert(
+  titleCase('HERE IS MY HANDLE HERE IS MY SPOUT') ===
+    'Here Is My Handle Here Is My Spout'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function titleCase(str) {
+  return str;
+}
+
+titleCase("I'm a little tea pot");
+```
+
+# --solutions--
+
+```js
+function titleCase(str) {
+  return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
+}
+
+titleCase("I'm a little tea pot");
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
@@ -0,0 +1,91 @@
+---
+id: ac6993d51946422351508a41
+title: Truncate a String
+challengeType: 1
+forumTopicId: 16089
+dashedName: truncate-a-string
+---
+
+# --description--
+
+Kürze einen String (erstes Argument), wenn er länger als die angegebene maximale Stringlänge (zweites Argument) ist. Gib den gekürzten String mit `...` am Ende zurück.
+
+# --hints--
+
+`truncateString("A-tisket a-tasket A green and yellow basket", 8)` soll den String `A-tisket...` zurückgeben.
+
+```js
+assert(
+  truncateString('A-tisket a-tasket A green and yellow basket', 8) ===
+    'A-tisket...'
+);
+```
+
+`truncateString("Peter Piper picked a peck of pickled peppers", 11)` soll den String `Peter Piper...` zurückgeben.
+
+```js
+assert(
+  truncateString('Peter Piper picked a peck of pickled peppers', 11) ===
+    'Peter Piper...'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` soll den String `A-tisket a-tasket A green and yellow basket` zurückgeben.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` soll den String `A-tisket a-tasket A green and yellow basket` zurückgeben.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length + 2
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-", 1)` soll den String `A...` zurückgeben.
+
+```js
+assert(truncateString('A-', 1) === 'A...');
+```
+
+`truncateString("Absolutely Longer", 2)` soll den String `Ab...` zurückgeben.
+
+```js
+assert(truncateString('Absolutely Longer', 2) === 'Ab...');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truncateString(str, num) {
+  return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
+
+# --solutions--
+
+```js
+function truncateString(str, num) {
+  if (num >= str.length) {
+    return str;
+  }
+
+  return str.slice(0, num) + '...';
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
--- a/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
+++ b/curriculum/challenges/german/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
@@ -0,0 +1,143 @@
+---
+id: a24c1a4622e3c05097f71d67
+title: Where do I Belong
+challengeType: 1
+forumTopicId: 16094
+dashedName: where-do-i-belong
+---
+
+# --description--
+
+Gib den niedrigsten Index zurück, bei dem ein Wert (zweites Argument) in ein Array (erstes Argument) eingefügt werden sollte, nachdem es sortiert wurde. Der zurückgegebene Wert sollte eine Zahl sein.
+
+Zum Beispiel sollte `getIndexToIns([1,2,3,4], 1.5)` den Wert `1` zurückgeben, weil es größer als `1` (Index 0) ist, aber kleiner als `2` (Index 1).
+
+Ebenso sollte `getIndexToIns([20,3,5], 19)` den Wert `2` zurückgeben, denn wenn der Array geordnet ist, sieht er wie `[3,5,20]` aus und `19` ist weniger als `20` (Index 2) und größer als `5` (Index 1).
+
+# --hints--
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` sollte `3` zurückgeben.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number');
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` sollte `2` zurückgeben.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number');
+```
+
+`getIndexToIns([40, 60], 50)` sollte `1` zurückgeben.
+
+```js
+assert(getIndexToIns([40, 60], 50) === 1);
+```
+
+`getIndexToIns([40, 60], 50)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([40, 60], 50) === 'number');
+```
+
+`getIndexToIns([3, 10, 5], 3)` sollte `0` zurückgeben.
+
+```js
+assert(getIndexToIns([3, 10, 5], 3) === 0);
+```
+
+`getIndexToIns([3, 10, 5], 3)` sollte eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([3, 10, 5], 3) === 'number');
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` soll `2` zurückgeben.
+
+```js
+assert(getIndexToIns([5, 3, 20, 3], 5) === 2);
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number');
+```
+
+`getIndexToIns([2, 20, 10], 19)` soll `2` zurückgeben.
+
+```js
+assert(getIndexToIns([2, 20, 10], 19) === 2);
+```
+
+`getIndexToIns([2, 20, 10], 19)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([2, 20, 10], 19) === 'number');
+```
+
+`getIndexToIns([2, 5, 10], 15)` soll `3` zurückgeben.
+
+```js
+assert(getIndexToIns([2, 5, 10], 15) === 3);
+```
+
+`getIndexToIns([2, 5, 10], 15)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([2, 5, 10], 15) === 'number');
+```
+
+`getIndexToIns([], 1)` soll `0` zurückgeben.
+
+```js
+assert(getIndexToIns([], 1) === 0);
+```
+
+`getIndexToIns([], 1)` soll eine Zahl zurückgeben.
+
+```js
+assert(typeof getIndexToIns([], 1) === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getIndexToIns(arr, num) {
+  return num;
+}
+
+getIndexToIns([40, 60], 50);
+```
+
+# --solutions--
+
+```js
+function getIndexToIns(arr, num) {
+  arr = arr.sort((a, b) => a - b);
+
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= num) {
+      return i;
+    }
+  }
+
+  return arr.length;
+}
+
+getIndexToIns([40, 60], 50);
+```