diff --git a/curriculum/challenges/german/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-and-visualizations.md b/curriculum/challenges/german/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-and-visualizations.md index 6e0ec2cef1a..b7f2328453e 100644 --- a/curriculum/challenges/german/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-and-visualizations.md +++ b/curriculum/challenges/german/08-data-analysis-with-python/data-analysis-with-python-course/data-cleaning-and-visualizations.md @@ -31,7 +31,7 @@ plt.subplot(1, 2, 1) ## --answers-- -My figure will have one column, two rows, and I am going to start drawing in the first (left) plot. +Meine Abbildung wird eine Spalte und zwei Zeilen haben, und ich beginne in dem ersten ("linken") Plot zu zeichnen. --- @@ -39,7 +39,7 @@ I am going to start drawing in the first (left) plot, my figure will have two ro --- -My figure will have one row, two columns, and I am going to start drawing in the first (left) plot. +Meine Abbildung wird eine Spalte und zwei Zeilen haben, und ich beginne in dem ersten ("linken") Plot zu zeichnen. ## --video-solution-- diff --git a/curriculum/challenges/german/08-data-analysis-with-python/numpy/loading-data-and-advanced-indexing.md b/curriculum/challenges/german/08-data-analysis-with-python/numpy/loading-data-and-advanced-indexing.md index 5eb265a61fe..f8a2e93dc14 100644 --- a/curriculum/challenges/german/08-data-analysis-with-python/numpy/loading-data-and-advanced-indexing.md +++ b/curriculum/challenges/german/08-data-analysis-with-python/numpy/loading-data-and-advanced-indexing.md @@ -14,7 +14,7 @@ dashedName: loading-data-and-advanced-indexing ## --text-- -Given a file named `data.txt` with these contents: +Gegeben ist eine Datei namens `data.txt` mit folgenden Inhalten:
29,97,32,100,45
diff --git a/curriculum/challenges/german/09-information-security/information-security-projects/port-scanner.md b/curriculum/challenges/german/09-information-security/information-security-projects/port-scanner.md
index b3650398359..c1ea791aa90 100644
--- a/curriculum/challenges/german/09-information-security/information-security-projects/port-scanner.md
+++ b/curriculum/challenges/german/09-information-security/information-security-projects/port-scanner.md
@@ -16,7 +16,7 @@ Du wirst Videokurs: Python für jedermann (14 Stunden)
@@ -79,7 +79,7 @@ Schreibe deinen Code in `port_scanner.py`. Für die Entwicklung kannst du `main.
## Testen
-The unit tests for this project are in `test_module.py`. We imported the tests from `test_module.py` to `main.py` for your convenience. The tests will run automatically whenever you hit the "run" button.
+The unit tests for this project are in `test_module.py`. We imported the tests from `test_module.py` to `main.py` for your convenience. Die Tests werden automatisch ausgeführt, wenn du auf den "Run"-Button klickst.
## Submitting
diff --git a/curriculum/challenges/german/09-information-security/information-security-projects/sha-1-password-cracker.md b/curriculum/challenges/german/09-information-security/information-security-projects/sha-1-password-cracker.md
index 49108553bda..304ddc2ac47 100644
--- a/curriculum/challenges/german/09-information-security/information-security-projects/sha-1-password-cracker.md
+++ b/curriculum/challenges/german/09-information-security/information-security-projects/sha-1-password-cracker.md
@@ -16,7 +16,7 @@ Du wirst Python for Everybody Video Course (14 hours)
@@ -28,17 +28,17 @@ Wir sind noch dabei, den interaktiven Teil des Python-Kurses zu entwickeln. For
Passwords should never be stored in plain text. They should be stored as hashes, just in case the password list is discovered. Allerdings werden nicht alle Hashwerte gleich erstellt.
-For this project you will learn about the importance of good security by creating a password cracker to figure out passwords that were hashed using SHA-1.
+In diesem Projekt lernst du die Bedeutung guter Sicherheit kennen, indem du einen Passwort-Cracker erstellst, um Passwörter herauszufinden, die mit SHA-1 gehasht wurden.
-Create a function that takes in a SHA-1 hash of a password and returns the password if it is one of the top 10,000 passwords used. If the SHA-1 hash is NOT of a password in the database, return "PASSWORD NOT IN DATABASE".
+Create a function that takes in a SHA-1 hash of a password and returns the password if it is one of the top 10,000 passwords used. Wenn der SHA-1 Hash NICHT von einem Passwort in der Datenbank ist, gib "PASSWORT NICHT IN DATABASE" zurück.
-The function should hash each password from `top-10000-passwords.txt` and compare it to the hash passed into the function.
+Die Funktion sollte jedes Passwort mit `top-10000-passwords.txt` hashen und mit dem Hashwert vergleichen, der in die Funktion übergeben wurde.
-The function should take an optional second argument named `use_salts`. If set to true, each salt string from the file `known-salts.txt` should be appended AND prepended to each password from `top-10000-passwords.txt` before hashing and before comparing it to the hash passed into the function.
+Die Funktion sollte ein optionales zweites Argument mit dem Namen `use_salts` verwenden. If set to true, each salt string from the file `known-salts.txt` should be appended AND prepended to each password from `top-10000-passwords.txt` before hashing and before comparing it to the hash passed into the function.
Hier sind ein paar gehashte Passwörter, mit denen die Funktion getestet werden kann:
-- `b305921a3723cd5d70a375cd21a61e60aabb84ec` should return "sammy123"
+- `b305921a3723cd5d70a375cd21a61e60aabb84ec` sollte "sammy123" zurückgeben
- `c7ab388a5ebefbf4d550652f1eb4d833e5316e3e` should return "abacab"
- `5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8` sollte "Passwort" zurückgeben
@@ -48,7 +48,7 @@ Hier sind einige gehashte Passwörter, mit denen die Funktion getestet werden so
- `da5a4e8cf89539e66097acd2f8af128acae2f8ae` should return "q1w2e3r4t5"
- `ea3f62d498e3b98557f9f9cd0d905028b3b019e1` sollte "bubbles1" zurückgeben
-The `hashlib` library has been imported for you. You should consider using it in your code. Learn more about "hashlib" here.
+Die `hashlib`-Bibliothek wurde für dich importiert. You should consider using it in your code. Erfahre hier mehr über "hashlib" .
## Entwicklung
diff --git a/curriculum/challenges/german/09-information-security/information-security-projects/stock-price-checker.md b/curriculum/challenges/german/09-information-security/information-security-projects/stock-price-checker.md
index 32f644a0b92..7d2b57e2a95 100644
--- a/curriculum/challenges/german/09-information-security/information-security-projects/stock-price-checker.md
+++ b/curriculum/challenges/german/09-information-security/information-security-projects/stock-price-checker.md
@@ -82,7 +82,7 @@ async (getUserInput) => {
};
```
-The `stockData` property includes the `stock` symbol as a string, the `price` as a number, and `likes` as a number.
+Die `stockData`-Eigenschaft enthält das `stock`-Symbol als ein String, den `price` als eine Zahl und `likes` als eine Zahl.
```js
async (getUserInput) => {
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/ask-browsers-to-access-your-site-via-https-only-with-helmet.hsts.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/ask-browsers-to-access-your-site-via-https-only-with-helmet.hsts.md
index 46eb845e16e..e424ab698a9 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/ask-browsers-to-access-your-site-via-https-only-with-helmet.hsts.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/ask-browsers-to-access-your-site-via-https-only-with-helmet.hsts.md
@@ -14,7 +14,7 @@ HTTP Strict Transport Security (HSTS) ist eine Web-Sicherheitsrichtlinie, die da
# --instructions--
-Konfiguriere `helmet.hsts()`, um HTTPS für die nächsten 90 Tage zu verwenden. Übergib das Konfigurations-Objekt `{maxAge: timeInSeconds, force: true}`. You can create a variable `ninetyDaysInSeconds = 90*24*60*60;` to use for the `timeInSeconds`. Replit hat bereits Hsts aktiviert. Um seine Einstellungen zu überschreiben, musst du das Feld "force" auf true im Konfigurations-Objekt setzen. We will intercept and restore the Replit header, after inspecting it for testing.
+Konfiguriere `helmet.hsts()`, um HTTPS für die nächsten 90 Tage zu verwenden. Übergib das Konfigurations-Objekt `{maxAge: timeInSeconds, force: true}`. You can create a variable `ninetyDaysInSeconds = 90*24*60*60;` to use for the `timeInSeconds`. Replit hat bereits Hsts aktiviert. Um seine Einstellungen zu überschreiben, musst du das Feld "force" auf true im Konfigurations-Objekt setzen. Wir werden den Replit-Header abfangen und wiederherstellen, nachdem wir ihn zu Testzwecken genauer überprüft haben.
Hinweis: Die Konfiguration von HTTPS auf einer benutzerdefinierten Website erfordert den Erwerb einer Domain und eines SSL/TLS-Zertifikats.
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/configure-helmet-using-the-parent-helmet-middleware.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/configure-helmet-using-the-parent-helmet-middleware.md
index ebcf0d8e0aa..69b22168223 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/configure-helmet-using-the-parent-helmet-middleware.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/configure-helmet-using-the-parent-helmet-middleware.md
@@ -1,6 +1,6 @@
---
id: 587d8249367417b2b2512c40
-title: Configure Helmet Using the ‘parent’ helmet() Middleware
+title: Konfigurieren von Helmet unter Verwendung der 'parent' helmet()-Middleware
challengeType: 2
forumTopicId: 301575
dashedName: configure-helmet-using-the-parent-helmet-middleware
@@ -10,9 +10,9 @@ dashedName: configure-helmet-using-the-parent-helmet-middleware
As a reminder, this project is being built upon the following starter project on Replit, or cloned from GitHub.
-`app.use(helmet())` will automatically include all the middleware introduced above, except `noCache()`, and `contentSecurityPolicy()`, but these can be enabled if necessary. Du kannst auch jede andere Middleware einzeln deaktivieren oder konfigurieren, indem du ein Konfigurationsobjekt verwendest.
+`app.use(helmet())` enthält automatisch alle oben eingeführten Middlewares, außer `noCache()`, und `contentSecurityPolicy()`, aber diese können bei Bedarf aktiviert werden. Du kannst auch jede andere Middleware einzeln deaktivieren oder konfigurieren, indem du ein Konfigurationsobjekt verwendest.
-**Example:**
+**Beispiel:**
```js
app.use(helmet({
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-client-side-caching-with-helmet.nocache.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-client-side-caching-with-helmet.nocache.md
index e41d8a3d310..fc4dbf3fe89 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-client-side-caching-with-helmet.nocache.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-client-side-caching-with-helmet.nocache.md
@@ -1,6 +1,6 @@
---
id: 587d8249367417b2b2512c3e
-title: Disable Client-Side Caching with helmet.noCache()
+title: Client-Side Caching mit helmet.noCache() deaktivieren
challengeType: 2
forumTopicId: 301576
dashedName: disable-client-side-caching-with-helmet-nocache
@@ -10,7 +10,7 @@ dashedName: disable-client-side-caching-with-helmet-nocache
As a reminder, this project is being built upon the following starter project on Replit, or cloned from GitHub.
-If you are releasing an update for your website, and you want the users to always download the newer version, you can (try to) disable caching on client’s browser. It can be useful in development too. Caching has performance benefits, which you will lose, so only use this option when there is a real need.
+Wenn du ein Update für deine Website herausgibst und du möchtest, dass die Nutzer immer die neuere Version herunterladen, kannst du das Caching im Browser des Kunden deaktivieren (oder es versuchen). Es kann auch für die Entwicklung nützlich sein. Die Zwischenspeicherung hat Leistungsvorteile, die du verlieren wirst, daher solltest du diese Option nur nutzen, wenn es wirklich notwendig ist.
# --instructions--
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-dns-prefetching-with-helmet.dnsprefetchcontrol.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-dns-prefetching-with-helmet.dnsprefetchcontrol.md
index 10e742b96a1..e259b178727 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-dns-prefetching-with-helmet.dnsprefetchcontrol.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/disable-dns-prefetching-with-helmet.dnsprefetchcontrol.md
@@ -1,6 +1,6 @@
---
id: 587d8248367417b2b2512c3d
-title: Disable DNS Prefetching with helmet.dnsPrefetchControl()
+title: DNS Prefetching mit helmet.dnsPrefetchControl() deaktivieren
challengeType: 2
forumTopicId: 301577
dashedName: disable-dns-prefetching-with-helmet-dnsprefetchcontrol
@@ -8,9 +8,9 @@ dashedName: disable-dns-prefetching-with-helmet-dnsprefetchcontrol
# --description--
-As a reminder, this project is being built upon the following starter project on Replit, or cloned from GitHub.
+Zur Erinnerung: Dieses Projekt baut auf dem folgenden Starterprojekt auf: Replit oder geklont von GitHub.
-To improve performance, most browsers prefetch DNS records for the links in a page. Auf diese Weise ist die Ziel-IP bereits bekannt, wenn der Nutzer auf einen Link klickt. This may lead to over-use of the DNS service (if you own a big website, visited by millions people…), privacy issues (one eavesdropper could infer that you are on a certain page), or page statistics alteration (some links may appear visited even if they are not). Wenn du ein hohes Sicherheitsbedürfnis hast, kannst du das DNS-Prefetching deaktivieren, was allerdings mit Leistungseinbußen verbunden ist.
+Um die Leistung zu verbessern, rufen die meisten Browser DNS-Einträge für die Links auf einer Seite vorab ab. Auf diese Weise ist die Ziel-IP bereits bekannt, wenn der Nutzer auf einen Link klickt. This may lead to over-use of the DNS service (if you own a big website, visited by millions people…), privacy issues (one eavesdropper could infer that you are on a certain page), or page statistics alteration (some links may appear visited even if they are not). Wenn du ein hohes Sicherheitsbedürfnis hast, kannst du das DNS-Prefetching deaktivieren, was allerdings mit Leistungseinbußen verbunden ist.
# --instructions--
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hash-and-compare-passwords-synchronously.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hash-and-compare-passwords-synchronously.md
index 4bea45b0c6b..a6d3441ded0 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hash-and-compare-passwords-synchronously.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hash-and-compare-passwords-synchronously.md
@@ -26,13 +26,13 @@ with the result being a boolean true or false.
# --instructions--
-Add the function in and log the result to the console to see it working.
+Füge die Funktion ein und protokolliere das Ergebnis in der Konsole, um zu sehen, ob sie funktioniert.
Reiche deine Seite ein, wenn du davon ausgehst, alles richtig gemacht zu haben.
# --hints--
-Sync hash should be generated and correctly compared.
+Der Sync-Hash sollte generiert und korrekt verglichen werden.
```js
(getUserInput) =>
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hide-potentially-dangerous-information-using-helmet.hidepoweredby.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hide-potentially-dangerous-information-using-helmet.hidepoweredby.md
index c1cd789591e..52096df3037 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hide-potentially-dangerous-information-using-helmet.hidepoweredby.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/hide-potentially-dangerous-information-using-helmet.hidepoweredby.md
@@ -1,6 +1,6 @@
---
id: 587d8247367417b2b2512c37
-title: Hide Potentially Dangerous Information Using helmet.hidePoweredBy()
+title: Ausblenden potenziell gefährlicher Informationen mit helmet.hidePoweredBy()
challengeType: 2
forumTopicId: 301580
dashedName: hide-potentially-dangerous-information-using-helmet-hidepoweredby
@@ -10,7 +10,7 @@ dashedName: hide-potentially-dangerous-information-using-helmet-hidepoweredby
As a reminder, this project is being built upon the following starter project on Replit, or cloned from GitHub.
-Hackers can exploit known vulnerabilities in Express/Node if they see that your site is powered by Express. `X-Powered-By: Express` is sent in every request coming from Express by default. Use the `helmet.hidePoweredBy()` middleware to remove the X-Powered-By header.
+Hacker können bekannte Schwachstellen in Express/Node ausnutzen, wenn sie sehen, dass deine Website von Express betrieben wird. `X-Powered-By: Express` wird standardmäßig in jeder Anfrage von Express gesendet. Verwende die `helmet.hidePoweredBy()`-Middleware, um den X-Powered-By-Header zu entfernen.
# --hints--
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/install-and-require-helmet.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/install-and-require-helmet.md
index ac65357fc95..effb62f9213 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/install-and-require-helmet.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/install-and-require-helmet.md
@@ -22,7 +22,7 @@ If you use Replit, follow these steps to set up the project:
When you are done, make sure a working demo of your project is hosted somewhere public. Then submit the URL to it in the Solution Link field.
-Helmet helps you secure your Express apps by setting various HTTP headers.
+Helmet hilft dir, deine Express-Anwendungen durch die Einstellung verschiedener HTTP-Header zu sichern.
# --instructions--
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-clickjacking-with-helmet.frameguard.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-clickjacking-with-helmet.frameguard.md
index 2c6db890147..22f1f943a89 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-clickjacking-with-helmet.frameguard.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-clickjacking-with-helmet.frameguard.md
@@ -1,6 +1,6 @@
---
id: 587d8247367417b2b2512c38
-title: Mitigate the Risk of Clickjacking with helmet.frameguard()
+title: Minimiere das Risiko von Clickjacking mit helmet.frameguard()
challengeType: 2
forumTopicId: 301582
dashedName: mitigate-the-risk-of-clickjacking-with-helmet-frameguard
@@ -10,7 +10,7 @@ dashedName: mitigate-the-risk-of-clickjacking-with-helmet-frameguard
As a reminder, this project is being built upon the following starter project on Replit, or cloned from GitHub.
-Deine Seite könnte ohne deine Zustimmung in ein `` oder `
-Or:
+Oder:
g = b xor (b logically right shifted 1 time)@@ -40,55 +40,55 @@ Or: Decoding (MSB is bit 0, b is binary, g is Gray code):
b[0] = g[0]# --hints-- -`gray` should be a function. +`gray` sollte eine Funktion sein. ```js assert(typeof gray == 'function'); ``` -`gray(true,177)` should return a number. +`gray(true,177)` sollte eine Zahl zurückgeben. ```js assert(typeof gray(true, 177) == 'number'); ``` -`gray(true,177)` should return `233`. +`gray(true,177)` sollte `233` zurückgeben. ```js assert.equal(gray(true, 177), 233); ``` -`gray(true,425)` should return `381`. +`gray(true,425)` sollte `381` zurückgeben. ```js assert.equal(gray(true, 425), 381); ``` -`gray(true,870)` should return `725`. +`gray(true,870)` sollte `725` zurückgeben. ```js assert.equal(gray(true, 870), 725); ``` -`gray(false,233)` should return `177`. +`gray(false,233)` sollte `177` zurückgeben. ```js assert.equal(gray(false, 233), 177); ``` -`gray(false,381)` should return `425`. +`gray(false,381)` sollte `425` zurückgeben. ```js assert.equal(gray(false, 381), 425); ``` -`gray(false,725)` should return `870`. +`gray(false,725)` sollte `870` zurückgeben. ```js assert.equal(gray(false, 725), 870); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-common-divisor.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-common-divisor.md index 8e960936bb6..d79567c84a8 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-common-divisor.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-common-divisor.md @@ -12,49 +12,49 @@ Write a function that returns the greatest common divisor of two integers. # --hints-- -`gcd` should be a function. +`gcd` sollte eine Funktion sein. ```js assert(typeof gcd == 'function'); ``` -`gcd(24,36)` should return a number. +`gcd(24,36)` sollte eine Zahl zurückgeben. ```js assert(typeof gcd(24, 36) == 'number'); ``` -`gcd(24,36)` should return `12`. +`gcd(24,36)` sollte `12` zurückgeben. ```js assert.equal(gcd(24, 36), 12); ``` -`gcd(30,48)` should return `6`. +`gcd(30,48)` sollte `6` zurückgeben. ```js assert.equal(gcd(30, 48), 6); ``` -`gcd(10,15)` should return `5`. +`gcd(10,15)` sollte `5` zurückgeben. ```js assert.equal(gcd(10, 15), 5); ``` -`gcd(100,25)` should return `25`. +`gcd(100,25)` sollte `25` zurückgeben. ```js assert.equal(gcd(100, 25), 25); ``` -`gcd(13,250)` should return `1`. +`gcd(13,250)` sollte `1` zurückgeben. ```js assert.equal(gcd(13, 250), 1); ``` -`gcd(1300,250)` should return `50`. +`gcd(1300,250)` sollte `50` zurückgeben. ```js assert.equal(gcd(1300, 250), 50); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-subsequential-sum.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-subsequential-sum.md index 6b8eebaf0e8..18ddb4251e7 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-subsequential-sum.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/greatest-subsequential-sum.md @@ -14,25 +14,25 @@ An empty subsequence is considered to have the sum of \\( 0 \\); thus if all ele # --hints-- -`maximumSubsequence` should be a function. +`maximumSubsequence` sollte eine Funktion sein. ```js assert(typeof maximumSubsequence == 'function'); ``` -`maximumSubsequence([ 1, 2, -1, 3, 10, -10 ])` should return an array. +`maximumSubsequence([ 1, 2, -1, 3, 10, -10 ])` sollte ein Array zurückgeben. ```js assert(Array.isArray(maximumSubsequence([1, 2, -1, 3, 10, -10]))); ``` -`maximumSubsequence([ 1, 2, -1, 3, 10, -10 ])` should return `[ 1, 2, -1, 3, 10 ]`. +`maximumSubsequence([ 1, 2, -1, 3, 10, -10 ])` sollte `[ 1, 2, -1, 3, 10 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([1, 2, -1, 3, 10, -10]), [1, 2, -1, 3, 10]); ``` -`maximumSubsequence([ 0, 8, 10, -2, -4, -1, -5, -3 ])` should return `[ 0, 8, 10 ]`. +`maximumSubsequence([ 0, 8, 10, -2, -4, -1, -5, -3 ])` sollte `[ 0, 8, 10 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([0, 8, 10, -2, -4, -1, -5, -3]), [ @@ -42,25 +42,25 @@ assert.deepEqual(maximumSubsequence([0, 8, 10, -2, -4, -1, -5, -3]), [ ]); ``` -`maximumSubsequence([ 9, 9, -10, 1 ])` should return `[ 9, 9 ]`. +`maximumSubsequence([ 9, 9, -10, 1 ])` sollte `[ 9, 9 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([9, 9, -10, 1]), [9, 9]); ``` -`maximumSubsequence([ 7, 1, -5, -3, -8, 1 ])` should return `[ 7, 1 ]`. +`maximumSubsequence([ 7, 1, -5, -3, -8, 1 ])` sollte `[ 7, 1 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([7, 1, -5, -3, -8, 1]), [7, 1]); ``` -`maximumSubsequence([ -3, 6, -1, 4, -4, -6 ])` should return `[ 6, -1, 4 ]`. +`maximumSubsequence([ -3, 6, -1, 4, -4, -6 ])` sollte `[ 6, -1, 4 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([-3, 6, -1, 4, -4, -6]), [6, -1, 4]); ``` -`maximumSubsequence([ -1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1 ])` should return `[ 3, 5, 6, -2, -1, 4 ]`. +`maximumSubsequence([ -1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1 ])` sollte `[ 3, 5, 6, -2, -1, 4 ]` zurückgeben. ```js assert.deepEqual(maximumSubsequence([-1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1]), [ diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hailstone-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hailstone-sequence.md index 639f52b4998..5ee65027f38 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hailstone-sequence.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hailstone-sequence.md @@ -25,31 +25,31 @@ The hailstone sequence is also known as hailstone numbers (because the values ar # --hints-- -`hailstoneSequence` should be a function. +`hailstoneSequence` sollte eine Funktion sein. ```js assert(typeof hailstoneSequence === 'function'); ``` -`hailstoneSequence(30)` should return an array. +`hailstoneSequence(30)` sollte ein Array zurückgeben. ```js assert(Array.isArray(hailstoneSequence(30))); ``` -`hailstoneSequence(30)` should return `[27, 112]`. +`hailstoneSequence(30)` sollte `[27, 112]` zurückgeben. ```js assert.deepEqual(hailstoneSequence(30), [27, 112]); ``` -`hailstoneSequence(50000)` should return `[35655, 324]`. +`hailstoneSequence(50000)` sollte `[35655, 324]` zurückgeben. ```js assert.deepEqual(hailstoneSequence(50000), [35655, 324]); ``` -`hailstoneSequence(100000)` should return `[77031, 351]`. +`hailstoneSequence(100000)` sollte `[77031, 351]` zurückgeben. ```js assert.deepEqual(hailstoneSequence(100000), [77031, 351]); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/happy-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/happy-numbers.md index 43ab0ef8989..649bf6d126e 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/happy-numbers.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/happy-numbers.md @@ -18,79 +18,79 @@ Implement a function that returns true if the number is happy, or false if not. # --hints-- -`happy` should be a function. +`happy` sollte eine Funktion sein. ```js assert(typeof happy === 'function'); ``` -`happy(1)` should return a boolean. +`happy(1)` sollte einen Boolean zurückgeben. ```js assert(typeof happy(1) === 'boolean'); ``` -`happy(1)` should return `true`. +`happy(1)` sollte `true` zurückgeben. ```js assert(happy(1)); ``` -`happy(2)` should return `false`. +`happy(2)` sollte `false` zurückgeben. ```js assert(!happy(2)); ``` -`happy(7)` should return `true`. +`happy(7)` sollte `true` zurückgeben. ```js assert(happy(7)); ``` -`happy(10)` should return `true`. +`happy(10)` sollte `true` zurückgeben. ```js assert(happy(10)); ``` -`happy(13)` should return `true`. +`happy(13)` sollte `true` zurückgeben. ```js assert(happy(13)); ``` -`happy(19)` should return `true`. +`happy(19)` sollte `true` zurückgeben. ```js assert(happy(19)); ``` -`happy(23)` should return `true`. +`happy(23)` sollte `true` zurückgeben. ```js assert(happy(23)); ``` -`happy(28)` should return `true`. +`happy(28)` sollte `true` zurückgeben. ```js assert(happy(28)); ``` -`happy(31)` should return `true`. +`happy(31)` sollte `true` zurückgeben. ```js assert(happy(31)); ``` -`happy(32)` should return `true`. +`happy(32)` sollte `true` zurückgeben. ```js assert(happy(32)); ``` -`happy(33)` should return `false`. +`happy(33)` sollte `false` zurückgeben. ```js assert(!happy(33)); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/harshad-or-niven-series.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/harshad-or-niven-series.md index ff626d6671d..c68a3cc3213 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/harshad-or-niven-series.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/harshad-or-niven-series.md @@ -22,25 +22,25 @@ Use it to return an array with ten members of the sequence, starting with first # --hints-- -`isHarshadOrNiven` should be a function. +`isHarshadOrNiven` sollte eine Funktion sein. ```js assert(typeof isHarshadOrNiven === 'function'); ``` -`isHarshadOrNiven(10)` should return `[12, 18, 20, 21, 24, 27, 30, 36, 40, 42]` +`isHarshadOrNiven(10)` sollte `[12, 18, 20, 21, 24, 27, 30, 36, 40, 42]` zurückgeben ```js assert.deepEqual(isHarshadOrNiven(10), [12, 18, 20, 21, 24, 27, 30, 36, 40, 42]); ``` -`isHarshadOrNiven(400)` should return `[402, 405, 407, 408, 410, 414, 420, 423, 432, 440]` +`isHarshadOrNiven(400)` sollte `[402, 405, 407, 408, 410, 414, 420, 423, 432, 440]` zurückgeben ```js assert.deepEqual(isHarshadOrNiven(400), [402, 405, 407, 408, 410, 414, 420, 423, 432, 440]); ``` -`isHarshadOrNiven(1000)` should return `[1002, 1008, 1010, 1011, 1012, 1014, 1015, 1016, 1017, 1020]` +`isHarshadOrNiven(1000)` sollte `[1002, 1008, 1010, 1011, 1012, 1014, 1015, 1016, 1017, 1020]` zurückgeben ```js assert.deepEqual(isHarshadOrNiven(1000), [1002, 1008, 1010, 1011, 1012, 1014, 1015, 1016, 1017, 1020]); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-from-two-arrays.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-from-two-arrays.md index 75facd682ab..c2b32bbb0e8 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-from-two-arrays.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-from-two-arrays.md @@ -10,7 +10,7 @@ dashedName: hash-from-two-arrays Given two arrays, create a hash object where the elements from one array (the keys) are linked to the elements of the other (the values). -Example: +Beispiel: ```js const firstArr = [1, 2, 3]; @@ -22,43 +22,43 @@ The hash object created from the arrays above will be `{1: "a", 2: "b", 3: "c"}` # --hints-- -`arrToObj` should be a function. +`arrToObj` sollte eine Funktion sein. ```js assert(typeof arrToObj === 'function'); ``` -`arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])` should return `{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }` +`arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])` sollte `{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[0]), res[0]); ``` -`arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])` should return `{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }` +`arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])` sollte `{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[1]), res[1]); ``` -`arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])` should return `{ 1: "a", 2: "b", 3: "c" }` +`arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])` sollte `{ 1: "a", 2: "b", 3: "c" }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[2]), res[2]); ``` -`arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])` should return `{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }` +`arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])` sollte `{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[3]), res[3]); ``` -`arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])` should return `{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }` +`arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])` sollte `{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[4]), res[4]); ``` -`arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])` should return `{ "a": 1, "b": 2, "c": 3 }` +`arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])` sollte `{ "a": 1, "b": 2, "c": 3 }` zurückgeben ```js assert.deepEqual(arrToObj(...testCases[5]), res[5]); diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-join.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-join.md index 8eea55e1b3e..b9688c7220a 100644 --- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-join.md +++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hash-join.md @@ -113,13 +113,13 @@ Implement the "hash join" algorithm as a function and demonstrate that it passes jA =
-for other bits: +für andere Bits: b[i] = g[i] xor b[i-1]
Name (i.e. column 1)
+ Name (z.B. Spalte 1)
Character (i.e. column 0)
+ Character (z.B. Spalte 0)
n
# --hints--
-`heronianTriangle` should be a function.
+`heronianTriangle` sollte eine Funktion sein.
```js
assert(typeof heronianTriangle === 'function');
```
-`heronianTriangle(10)` should return `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]`
+`heronianTriangle(10)` sollte `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]` zurückgeben
```js
assert.deepEqual(heronianTriangle(testCases[0]), res[0]);
```
-`heronianTriangle(15)` should return `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],`
+`heronianTriangle(15)` sollte `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],` zurückgeben
```js
assert.deepEqual(heronianTriangle(testCases[1]), res[1]);
```
-`heronianTriangle(20)` should return `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],`
+`heronianTriangle(20)` sollte `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],` zurückgeben
```js
assert.deepEqual(heronianTriangle(testCases[2]), res[2]);
```
-`heronianTriangle(25)` should return `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]`
+`heronianTriangle(25)` sollte `[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]` zurückgeben
```js
assert.deepEqual(heronianTriangle(testCases[3]), res[3]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.md
index e05d87270f2..f5f35f604d1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.md
@@ -33,73 +33,73 @@ No maximum value for `n` should be assumed.
# --hints--
-`ffr` should be a function.
+`ffr` sollte eine Funktion sein.
```js
assert(typeof ffr === 'function');
```
-`ffs` should be a function.
+`ffs` sollte eine Funktion sein.
```js
assert(typeof ffs === 'function');
```
-`ffr` should return integer.
+`ffr` sollte Integer zurückgeben.
```js
assert(Number.isInteger(ffr(1)));
```
-`ffs` should return integer.
+`ffs` sollte Integer zurückgeben.
```js
assert(Number.isInteger(ffs(1)));
```
-`ffr(10)` should return `69`
+`ffr(10)` sollte `69` zurückgeben
```js
assert.equal(ffr(ffrParamRes[0][0]), ffrParamRes[0][1]);
```
-`ffr(50)` should return `1509`
+`ffr(50)` sollte `1509` zurückgeben
```js
assert.equal(ffr(ffrParamRes[1][0]), ffrParamRes[1][1]);
```
-`ffr(100)` should return `5764`
+`ffr(100)` sollte `5764` zurückgeben
```js
assert.equal(ffr(ffrParamRes[2][0]), ffrParamRes[2][1]);
```
-`ffr(1000)` should return `526334`
+`ffr(1000)` sollte `526334` zurückgeben
```js
assert.equal(ffr(ffrParamRes[3][0]), ffrParamRes[3][1]);
```
-`ffs(10)` should return `14`
+`ffs(10)` sollte `14` zurückgeben
```js
assert.equal(ffs(ffsParamRes[0][0]), ffsParamRes[0][1]);
```
-`ffs(50)` should return `59`
+`ffs(50)` sollte `59` zurückgeben
```js
assert.equal(ffs(ffsParamRes[1][0]), ffsParamRes[1][1]);
```
-`ffs(100)` should return `112`
+`ffs(100)` sollte `112` zurückgeben
```js
assert.equal(ffs(ffsParamRes[2][0]), ffsParamRes[2][1]);
```
-`ffs(1000)` should return `1041`
+`ffs(1000)` sollte `1041` zurückgeben
```js
assert.equal(ffs(ffsParamRes[3][0]), ffsParamRes[3][1]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-q-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-q-sequence.md
index 27c1bdb4dba..04eccc2b8c5 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-q-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/hofstadter-q-sequence.md
@@ -20,37 +20,37 @@ Implement the Hofstadter Q Sequence equation as a function. The function should
# --hints--
-`hofstadterQ` should be a function.
+`hofstadterQ` sollte eine Funktion sein.
```js
assert(typeof hofstadterQ === 'function');
```
-`hofstadterQ()` should return `integer`
+`hofstadterQ()` sollte `integer` zurückgeben
```js
assert(Number.isInteger(hofstadterQ(1000)));
```
-`hofstadterQ(1000)` should return `502`
+`hofstadterQ(1000)` sollte `502` zurückgeben
```js
assert.equal(hofstadterQ(testCase[0]), res[0]);
```
-`hofstadterQ(1500)` should return `755`
+`hofstadterQ(1500)` sollte `755` zurückgeben
```js
assert.equal(hofstadterQ(testCase[1]), res[1]);
```
-`hofstadterQ(2000)` should return `1005`
+`hofstadterQ(2000)` sollte `1005` zurückgeben
```js
assert.equal(hofstadterQ(testCase[2]), res[2]);
```
-`hofstadterQ(2500)` should return `1261`
+`hofstadterQ(2500)` sollte `1261` zurückgeben
```js
assert.equal(hofstadterQ(testCase[3]), res[3]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/i-before-e-except-after-c.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/i-before-e-except-after-c.md
index ba038c108bb..a47aa7f2548 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/i-before-e-except-after-c.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/i-before-e-except-after-c.md
@@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc7eb0
-title: I before E except after C
+title: I vor E außer nach C
challengeType: 1
forumTopicId: 302288
dashedName: i-before-e-except-after-c
@@ -25,53 +25,53 @@ If both sub-phrases are plausible then the original phrase can be said to be pla
# --instructions--
-Write a function that accepts a word and check if the word follows this rule. The function should return true if the word follows the rule and false if it does not.
+Write a function that accepts a word and check if the word follows this rule. Die Funktion sollte true zurückgeben, wenn das Wort der Regel folgt und false, wenn dies nicht der Fall ist.
# --hints--
-`IBeforeExceptC` should be a function.
+`IBeforeExceptC` sollte eine Funktion sein.
```js
assert(typeof IBeforeExceptC == 'function');
```
-`IBeforeExceptC("receive")` should return a boolean.
+`IBeforeExceptC("receive")` sollte einen Boolean zurückgeben.
```js
assert(typeof IBeforeExceptC('receive') == 'boolean');
```
-`IBeforeExceptC("receive")` should return `true`.
+`IBeforeExceptC("receive")` sollte `true` zurückgeben.
```js
assert.equal(IBeforeExceptC('receive'), true);
```
-`IBeforeExceptC("science")` should return `false`.
+`IBeforeExceptC("science")` sollte `false` zurückgeben.
```js
assert.equal(IBeforeExceptC('science'), false);
```
-`IBeforeExceptC("imperceivable")` should return `true`.
+`IBeforeExceptC("imperceivable")` sollte `true` zurückgeben.
```js
assert.equal(IBeforeExceptC('imperceivable'), true);
```
-`IBeforeExceptC("inconceivable")` should return `true`.
+`IBeforeExceptC("inconceivable")` sollte `true` zurückgeben.
```js
assert.equal(IBeforeExceptC('inconceivable'), true);
```
-`IBeforeExceptC("insufficient")` should return `false`.
+`IBeforeExceptC("insufficient")` sollte `false` zurückgeben.
```js
assert.equal(IBeforeExceptC('insufficient'), false);
```
-`IBeforeExceptC("omniscient")` should return `false`.
+`IBeforeExceptC("omniscient")` sollte `false` zurückgeben.
```js
assert.equal(IBeforeExceptC('omniscient'), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iban.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iban.md
index dde7926e041..71a18780089 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iban.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iban.md
@@ -26,43 +26,43 @@ Write a function that takes IBAN string as parameter. If it is valid return true
# --hints--
-`isValid` should be a function.
+`isValid` sollte eine Funktion sein.
```js
assert(typeof isValid == 'function');
```
-`isValid("GB82 WEST 1234 5698 7654 32")` should return a boolean.
+`isValid("GB82 WEST 1234 5698 7654 32")` sollte einen Boolean zurückgeben.
```js
assert(typeof isValid('GB82 WEST 1234 5698 7654 32') == 'boolean');
```
-`isValid("GB82 WEST 1234 5698 7654 32")` should return `true`.
+`isValid("GB82 WEST 1234 5698 7654 32")` sollte `true` zurückgeben.
```js
assert.equal(isValid('GB82 WEST 1234 5698 7654 32'), true);
```
-`isValid("GB82 WEST 1.34 5698 7654 32")` should return `false`.
+`isValid("GB82 WEST 1.34 5698 7654 32")` sollte `false` zurückgeben.
```js
assert.equal(isValid('GB82 WEST 1.34 5698 7654 32'), false);
```
-`isValid("GB82 WEST 1234 5698 7654 325")` should return `false`.
+`isValid("GB82 WEST 1234 5698 7654 325")` sollte `false` zurückgeben.
```js
assert.equal(isValid('GB82 WEST 1234 5698 7654 325'), false);
```
-`isValid("GB82 TEST 1234 5698 7654 32")` should return `false`.
+`isValid("GB82 TEST 1234 5698 7654 32")` sollte `false` zurückgeben.
```js
assert.equal(isValid('GB82 TEST 1234 5698 7654 32'), false);
```
-`isValid("SA03 8000 0000 6080 1016 7519")` should return `true`.
+`isValid("SA03 8000 0000 6080 1016 7519")` sollte `true` zurückgeben.
```js
assert.equal(isValid('SA03 8000 0000 6080 1016 7519'), true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/identity-matrix.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/identity-matrix.md
index dba37b7cafa..67b2d801540 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/identity-matrix.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/identity-matrix.md
@@ -20,7 +20,7 @@ Write a function that takes a number `n` as a parameter and returns the identity
# --hints--
-`idMatrix` should be a function.
+`idMatrix` sollte eine Funktion sein.
```js
assert(typeof idMatrix == 'function');
@@ -32,25 +32,25 @@ assert(typeof idMatrix == 'function');
assert(Array.isArray(idMatrix(1)));
```
-`idMatrix(1)` should return `[ [ 1 ] ]`.
+`idMatrix(1)` sollte `[ [ 1 ] ]` zurückgeben.
```js
assert.deepEqual(idMatrix(1), results[0]);
```
-`idMatrix(2)` should return `[ [ 1, 0 ], [ 0, 1 ] ]`.
+`idMatrix(2)` sollte `[ [ 1, 0 ], [ 0, 1 ] ]` zurückgeben.
```js
assert.deepEqual(idMatrix(2), results[1]);
```
-`idMatrix(3)` should return `[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]`.
+`idMatrix(3)` sollte `[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]` zurückgeben.
```js
assert.deepEqual(idMatrix(3), results[2]);
```
-`idMatrix(4)` should return `[ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ]`.
+`idMatrix(4)` sollte `[ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ]` zurückgeben.
```js
assert.deepEqual(idMatrix(4), results[3]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iterated-digits-squaring.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iterated-digits-squaring.md
index c64fdc125d7..0346e178c1a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iterated-digits-squaring.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/iterated-digits-squaring.md
@@ -20,49 +20,49 @@ Write a function that takes a number as a parameter and returns 1 or 89 after pe
# --hints--
-`iteratedSquare` should be a function.
+`iteratedSquare` sollte eine Funktion sein.
```js
assert(typeof iteratedSquare == 'function');
```
-`iteratedSquare(4)` should return a number.
+`iteratedSquare(4)` sollte eine Zahl zurückgeben.
```js
assert(typeof iteratedSquare(4) == 'number');
```
-`iteratedSquare(4)` should return `89`.
+`iteratedSquare(4)` sollte `89` zurückgeben.
```js
assert.equal(iteratedSquare(4), 89);
```
-`iteratedSquare(7)` should return `1`.
+`iteratedSquare(7)` sollte `1` zurückgeben.
```js
assert.equal(iteratedSquare(7), 1);
```
-`iteratedSquare(15)` should return `89`.
+`iteratedSquare(15)` sollte `89` zurückgeben.
```js
assert.equal(iteratedSquare(15), 89);
```
-`iteratedSquare(20)` should return `89`.
+`iteratedSquare(20)` sollte `89` zurückgeben.
```js
assert.equal(iteratedSquare(20), 89);
```
-`iteratedSquare(70)` should return `1`.
+`iteratedSquare(70)` sollte `1` zurückgeben.
```js
assert.equal(iteratedSquare(70), 1);
```
-`iteratedSquare(100)` should return `1`.
+`iteratedSquare(100)` sollte `1` zurückgeben.
```js
assert.equal(iteratedSquare(100), 1);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jaro-distance.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jaro-distance.md
index 2eaea26bbc4..615db0087de 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jaro-distance.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jaro-distance.md
@@ -27,7 +27,7 @@ Two characters from \\(s_1\\) and \\(s_2\\) respectively, are considered *matchi
Each character of \\(s_1\\) is compared with all its matching characters in \\(s_2\\) . The number of matching (but different sequence order) characters divided by 2 defines the number of *transpositions*.
-**Example**
+**Beispiel**
Given the strings \\(s_1\\) *DWAYNE* and \\(s_2\\) *DUANE* we find:
@@ -46,43 +46,43 @@ Write a function a that takes two strings as parameters and returns the associat
# --hints--
-`jaro` should be a function.
+`jaro` sollte eine Funktion sein.
```js
assert(typeof jaro == 'function');
```
-`jaro("MARTHA", "MARHTA")` should return a number.
+`jaro("MARTHA", "MARHTA")` sollte eine Zahl zurückgeben.
```js
assert(typeof jaro('MARTHA', 'MARHTA') == 'number');
```
-`jaro("MARTHA", "MARHTA")` should return `0.9444444444444445`.
+`jaro("MARTHA", "MARHTA")` sollte `0.9444444444444445` zurückgeben.
```js
assert.equal(jaro('MARTHA', 'MARHTA'), 0.9444444444444445);
```
-`jaro("DIXON", "DICKSONX")` should return `0.7666666666666666`.
+`jaro("DIXON", "DICKSONX")` sollte `0.7666666666666666` zurückgeben.
```js
assert.equal(jaro('DIXON', 'DICKSONX'), 0.7666666666666666);
```
-`jaro("JELLYFISH", "SMELLYFISH")` should return `0.8962962962962964`.
+`jaro("JELLYFISH", "SMELLYFISH")` sollte `0.8962962962962964` zurückgeben.
```js
assert.equal(jaro('JELLYFISH', 'SMELLYFISH'), 0.8962962962962964);
```
-`jaro("HELLOS", "CHELLO")` should return `0.888888888888889`.
+`jaro("HELLOS", "CHELLO")` sollte `0.888888888888889` zurückgeben.
```js
assert.equal(jaro('HELLOS', 'CHELLO'), 0.888888888888889);
```
-`jaro("ABCD", "BCDA")` should return `0.8333333333333334`.
+`jaro("ABCD", "BCDA")` sollte `0.8333333333333334` zurückgeben.
```js
assert.equal(jaro('ABCD', 'BCDA'), 0.8333333333333334);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jortsort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jortsort.md
index 1bb9d70e909..bce768b6a1c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jortsort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/jortsort.md
@@ -14,49 +14,49 @@ jortSort should be a function that takes a single array of comparable objects as
# --hints--
-`jortsort` should be a function.
+`jortsort` sollte eine Funktion sein.
```js
assert(typeof jortsort == 'function');
```
-`jortsort([1,2,3,4,5])` should return a boolean.
+`jortsort([1,2,3,4,5])` sollte einen Boolean zurückgeben.
```js
assert(typeof jortsort([1, 2, 3, 4, 5]) == 'boolean');
```
-`jortsort([1,2,3,4,5])` should return `true`.
+`jortsort([1,2,3,4,5])` sollte `true` zurückgeben.
```js
assert.equal(jortsort([1, 2, 3, 4, 5]), true);
```
-`jortsort([1,2,13,4,5])` should return `false`.
+`jortsort([1,2,13,4,5])` sollte `false` zurückgeben.
```js
assert.equal(jortsort([1, 2, 13, 4, 5]), false);
```
-`jortsort([12,4,51,2,4])` should return `false`.
+`jortsort([12,4,51,2,4])` sollte `false` zurückgeben.
```js
assert.equal(jortsort([12, 4, 51, 2, 4]), false);
```
-`jortsort([1,2])` should return `true`.
+`jortsort([1,2])` sollte `true` zurückgeben.
```js
assert.equal(jortsort([1, 2]), true);
```
-`jortsort([5,4,3,2,1])` should return `false`.
+`jortsort([5,4,3,2,1])` sollte `false` zurückgeben.
```js
assert.equal(jortsort([5, 4, 3, 2, 1]), false);
```
-`jortsort([1,1,1,1,1])` should return `true`.
+`jortsort([1,1,1,1,1])` sollte `true` zurückgeben.
```js
assert.equal(jortsort([1, 1, 1, 1, 1]), true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/josephus-problem.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/josephus-problem.md
index d7e28e5e0c4..6749d12e1b7 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/josephus-problem.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/josephus-problem.md
@@ -30,43 +30,43 @@ Write a function that takes the initial number of prisoners and `k` as parameter
# --hints--
-`josephus` should be a function.
+`josephus` sollte eine Funktion sein.
```js
assert(typeof josephus == 'function');
```
-`josephus(30,3)` should return a number.
+`josephus(30,3)` sollte eine Zahl zurückgeben.
```js
assert(typeof josephus(30, 3) == 'number');
```
-`josephus(30,3)` should return `28`.
+`josephus(30,3)` sollte `28` zurückgeben.
```js
assert.equal(josephus(30, 3), 28);
```
-`josephus(30,5)` should return `2`.
+`josephus(30,5)` sollte `2` zurückgeben.
```js
assert.equal(josephus(30, 5), 2);
```
-`josephus(20,2)` should return `8`.
+`josephus(20,2)` sollte `8` zurückgeben.
```js
assert.equal(josephus(20, 2), 8);
```
-`josephus(17,6)` should return `1`.
+`josephus(17,6)` sollte `1` zurückgeben.
```js
assert.equal(josephus(17, 6), 1);
```
-`josephus(29,4)` should return `1`.
+`josephus(29,4)` sollte `1` zurückgeben.
```js
assert.equal(josephus(29, 4), 1);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/k-d-tree.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/k-d-tree.md
index 9f038dd908d..93ada6e779f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/k-d-tree.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/k-d-tree.md
@@ -16,13 +16,13 @@ Write a function to perform a nearest neighbour search using k-d tree. The funct
# --hints--
-`kdNN` should be a function.
+`kdNN` sollte eine Funktion sein.
```js
assert(typeof kdNN == 'function');
```
-`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2])` should return an array.
+`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2])` sollte ein Array zurückgeben.
```js
assert(
@@ -42,7 +42,7 @@ assert(
);
```
-`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2])` should return `[ 8, 1 ]`.
+`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2])` sollte `[ 8, 1 ]` zurückgeben.
```js
assert.deepEqual(
@@ -61,7 +61,7 @@ assert.deepEqual(
);
```
-`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1])` should return `[ 8, 1 ]`.
+`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1])` sollte `[ 8, 1 ]` zurückgeben.
```js
assert.deepEqual(
@@ -80,7 +80,7 @@ assert.deepEqual(
);
```
-`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2])` should return `[ 2, 3 ]`.
+`kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2])` sollte `[ 2, 3 ]` zurückgeben.
```js
assert.deepEqual(
@@ -99,7 +99,7 @@ assert.deepEqual(
);
```
-`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3])` should return `[ 1, 2, 5 ]`.
+`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3])` sollte `[ 1, 2, 5 ]` zurückgeben.
```js
assert.deepEqual(
@@ -118,7 +118,7 @@ assert.deepEqual(
);
```
-`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6])` should return `[ 4, 6, 7 ]`.
+`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6])` sollte `[ 4, 6, 7 ]` zurückgeben.
```js
assert.deepEqual(
@@ -137,7 +137,7 @@ assert.deepEqual(
);
```
-`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8])` should return `[ 7, 8, 9 ]`.
+`kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8])` sollte `[ 7, 8, 9 ]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/kaprekar-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/kaprekar-numbers.md
index ffef92f7819..69729ebd452 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/kaprekar-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/kaprekar-numbers.md
@@ -30,55 +30,55 @@ Write a function that takes a number $n$, a base $bs$, and returns true if the n
# --hints--
-`isKaprekar` should be a function.
+`isKaprekar` sollte eine Funktion sein.
```js
assert(typeof isKaprekar == 'function');
```
-`isKaprekar(1, 10)` should return a boolean.
+`isKaprekar(1, 10)` sollte einen Boolean zurückgeben.
```js
assert(typeof isKaprekar(1, 10) == 'boolean');
```
-`isKaprekar(1, 10)` should return `true`.
+`isKaprekar(1, 10)` sollte `true` zurückgeben.
```js
assert.equal(isKaprekar(1, 10), true);
```
-`isKaprekar(9, 10)` should return `true`.
+`isKaprekar(9, 10)` sollte `true` zurückgeben.
```js
assert.equal(isKaprekar(9, 10), true);
```
-`isKaprekar(2223, 10)` should return `true`.
+`isKaprekar(2223, 10)` sollte `true` zurückgeben.
```js
assert.equal(isKaprekar(2223, 10), true);
```
-`isKaprekar(22823, 10)` should return `false`.
+`isKaprekar(22823, 10)` sollte `false` zurückgeben.
```js
assert.equal(isKaprekar(22823, 10), false);
```
-`isKaprekar(9, 17)` should return `false`.
+`isKaprekar(9, 17)` sollte `false` zurückgeben.
```js
assert.equal(isKaprekar(9, 17), false);
```
-`isKaprekar(225, 17)` should return `true`.
+`isKaprekar(225, 17)` sollte `true` zurückgeben.
```js
assert.equal(isKaprekar(225, 17), true);
```
-`isKaprekar(999, 17)` should return `false`.
+`isKaprekar(999, 17)` sollte `false` zurückgeben.
```js
assert.equal(isKaprekar(999, 17), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-0-1.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-0-1.md
index ab84dea2631..52ddb42a9d4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-0-1.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-0-1.md
@@ -18,7 +18,7 @@ Write a function to solve the knapsack problem. The function is given the array
# --hints--
-`knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100)` should return `405`.
+`knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100)` sollte `405` zurückgeben.
```js
assert.equal(
@@ -39,7 +39,7 @@ assert.equal(
);
```
-`knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200)` should return `510`.
+`knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200)` sollte `510` zurückgeben.
```js
assert.equal(
@@ -60,7 +60,7 @@ assert.equal(
);
```
-`knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100)` should return `145`.
+`knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100)` sollte `145` zurückgeben.
```js
assert.equal(
@@ -80,7 +80,7 @@ assert.equal(
);
```
-`knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200)` should return `185`.
+`knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200)` sollte `185` zurückgeben.
```js
assert.equal(
@@ -100,7 +100,7 @@ assert.equal(
);
```
-`knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100)` should return `237`.
+`knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100)` sollte `237` zurückgeben.
```js
assert.equal(
@@ -120,7 +120,7 @@ assert.equal(
);
```
-`knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200)` should return `317`.'
+`knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200)` sollte `317` zurückgeben.'
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-bounded.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-bounded.md
index 2af68ccd123..1f1a68b012e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-bounded.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-bounded.md
@@ -18,7 +18,7 @@ Write a function to solve the knapsack problem. The function is given the array
# --hints--
-`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300)` should return `755`.
+`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300)` sollte `755` zurückgeben.
```js
assert.equal(
@@ -44,7 +44,7 @@ assert.equal(
);
```
-`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400)` should return `875`.
+`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400)` sollte `875` zurückgeben.
```js
assert.equal(
@@ -70,7 +70,7 @@ assert.equal(
);
```
-`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500)` should return `1015`.
+`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500)` sollte `1015` zurückgeben.
```js
assert.equal(
@@ -96,7 +96,7 @@ assert.equal(
);
```
-`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600)` should return `1120`.
+`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600)` sollte `1120` zurückgeben.
```js
assert.equal(
@@ -122,7 +122,7 @@ assert.equal(
);
```
-`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700)` should return `1225`.
+`findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700)` sollte `1225` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-continuous.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-continuous.md
index cb6879ac2d9..b0ce489ee55 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-continuous.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-continuous.md
@@ -14,11 +14,11 @@ The thief knows the weights and prices of each items. Because he has a knapsack
# --instructions--
-Write a function that takes an array of objects representing the items available in the shop. Each object has 3 attributes: name, weight, and value. The function also takes the maximum weight as a parameter. The function should return the maximum value possible, and the total weight of the selected items should not exceed the maximum weight.
+Write a function that takes an array of objects representing the items available in the shop. Each object has 3 attributes: name, weight, and value. The function also takes the maximum weight as a parameter. Die Funktion sollte den höchstmöglichen Wert zurückgeben und das Gesamtgewicht der ausgewählten Artikel sollte das Höchstgewicht nicht überschreiten.
# --hints--
-`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10)` should return `257.875`.
+`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10)` sollte `257.875` zurückgeben.
```js
assert.equal(
@@ -40,7 +40,7 @@ assert.equal(
);
```
-`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12)` should return `295.05405405405406`.
+`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12)` sollte `295.05405405405406` zurückgeben.
```js
assert.equal(
@@ -62,7 +62,7 @@ assert.equal(
);
```
-`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15)` should return `349.3783783783784`.
+`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15)` sollte `349.3783783783784` zurückgeben.
```js
assert.equal(
@@ -84,7 +84,7 @@ assert.equal(
);
```
-`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22)` should return `459.5263157894737`.
+`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22)` sollte `459.5263157894737` zurückgeben.
```js
assert.equal(
@@ -106,7 +106,7 @@ assert.equal(
);
```
-`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24)` should return `478.4736842105263`.
+`knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24)` sollte `478.4736842105263` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.md
index 62bb6116126..7419fc3ea0c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.md
@@ -22,7 +22,7 @@ Write a function that takes an array of objects, maximum weight, and maximum vol
# --hints--
-`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25)` should return `54500`.
+`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25)` sollte `54500` zurückgeben.
```js
assert.equal(
@@ -39,7 +39,7 @@ assert.equal(
);
```
-`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25)` should return `88400`.
+`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25)` sollte `88400` zurückgeben.
```js
assert.equal(
@@ -56,7 +56,7 @@ assert.equal(
);
```
-`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15)` should return `42500`.
+`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15)` sollte `42500` zurückgeben.
```js
assert.equal(
@@ -73,7 +73,7 @@ assert.equal(
);
```
-`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35)` should return `75900`.
+`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35)` sollte `75900` zurückgeben.
```js
assert.equal(
@@ -90,7 +90,7 @@ assert.equal(
);
```
-`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25)` should return `43200`.
+`knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25)` sollte `43200` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knights-tour.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knights-tour.md
index 154df0c3ee4..82329a0f058 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knights-tour.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/knights-tour.md
@@ -16,43 +16,43 @@ Write a function that takes `width` and `height` as parameters and returns the n
# --hints--
-`knightTour` should be a function.
+`knightTour` sollte eine Funktion sein.
```js
assert(typeof knightTour == 'function');
```
-`knightTour(6, 6)` should return a number.
+`knightTour(6, 6)` sollte eine Zahl zurückgeben.
```js
assert(typeof knightTour(6, 6) == 'number');
```
-`knightTour(6, 6)` should return `36`.
+`knightTour(6, 6)` sollte `36` zurückgeben.
```js
assert.equal(knightTour(6, 6), 36);
```
-`knightTour(5, 6)` should return `30`.
+`knightTour(5, 6)` sollte `30` zurückgeben.
```js
assert.equal(knightTour(5, 6), 30);
```
-`knightTour(4, 6)` should return `12`.
+`knightTour(4, 6)` sollte `12` zurückgeben.
```js
assert.equal(knightTour(4, 6), 12);
```
-`knightTour(7, 3)` should return `10`.
+`knightTour(7, 3)` sollte `10` zurückgeben.
```js
assert.equal(knightTour(7, 3), 10);
```
-`knightTour(8, 6)` should return `48`.
+`knightTour(8, 6)` sollte `48` zurückgeben.
```js
assert.equal(knightTour(8, 6), 48);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/largest-int-from-concatenated-ints.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/largest-int-from-concatenated-ints.md
index 91f5ba030ba..299b67f39ab 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/largest-int-from-concatenated-ints.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/largest-int-from-concatenated-ints.md
@@ -12,43 +12,43 @@ Given a set of positive integers, write a function to order the integers in such
# --hints--
-`maxCombine` should be a function.
+`maxCombine` sollte eine Funktion sein.
```js
assert(typeof maxCombine == 'function');
```
-`maxCombine([1, 3, 3, 4, 55])` should return a number.
+`maxCombine([1, 3, 3, 4, 55])` sollte eine Zahl zurückgeben.
```js
assert(typeof maxCombine([1, 3, 3, 4, 55]) == 'number');
```
-`maxCombine([1, 3, 3, 4, 55])` should return `554331`.
+`maxCombine([1, 3, 3, 4, 55])` sollte `554331` zurückgeben.
```js
assert.equal(maxCombine([1, 3, 3, 4, 55]), 554331);
```
-`maxCombine([71, 45, 23, 4, 5])` should return `71545423`.
+`maxCombine([71, 45, 23, 4, 5])` sollte `71545423` zurückgeben.
```js
assert.equal(maxCombine([71, 45, 23, 4, 5]), 71545423);
```
-`maxCombine([14, 43, 53, 114, 55])` should return `55534314114`.
+`maxCombine([14, 43, 53, 114, 55])` sollte `55534314114` zurückgeben.
```js
assert.equal(maxCombine([14, 43, 53, 114, 55]), 55534314114);
```
-`maxCombine([1, 34, 3, 98, 9, 76, 45, 4])` should return `998764543431`.
+`maxCombine([1, 34, 3, 98, 9, 76, 45, 4])` sollte `998764543431` zurückgeben.
```js
assert.equal(maxCombine([1, 34, 3, 98, 9, 76, 45, 4]), 998764543431);
```
-`maxCombine([54, 546, 548, 60])` should return `6054854654`.
+`maxCombine([54, 546, 548, 60])` sollte `6054854654` zurückgeben.
```js
assert.equal(maxCombine([54, 546, 548, 60]), 6054854654);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-friday-of-each-month.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-friday-of-each-month.md
index 7ebd6a1b71a..1a18829f305 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-friday-of-each-month.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-friday-of-each-month.md
@@ -12,61 +12,61 @@ Write a function that returns the date of the last Friday of a given month for a
# --hints--
-`lastFriday` should be a function.
+`lastFriday` sollte eine Funktion sein.
```js
assert(typeof lastFriday == 'function');
```
-`lastFriday(2018, 1)` should return a number.
+`lastFriday(2018, 1)` sollte eine Zahl zurückgeben.
```js
assert(typeof lastFriday(2018, 1) == 'number');
```
-`lastFriday(2018, 1)` should return `26`.
+`lastFriday(2018, 1)` sollte `26` zurückgeben.
```js
assert.equal(lastFriday(2018, 1), 26);
```
-`lastFriday(2017, 2)` should return `24`.
+`lastFriday(2017, 2)` sollte `24` zurückgeben.
```js
assert.equal(lastFriday(2017, 2), 24);
```
-`lastFriday(2012, 3)` should return `30`.
+`lastFriday(2012, 3)` sollte `30` zurückgeben.
```js
assert.equal(lastFriday(2012, 3), 30);
```
-`lastFriday(1900, 4)` should return `27`.
+.`lastFriday(1900, 4)` sollte `27` zurückgeben.
```js
assert.equal(lastFriday(1900, 4), 27);
```
-`lastFriday(2000, 5)` should return `26`.
+`lastFriday(2000, 5)` sollte `26` zurückgeben.
```js
assert.equal(lastFriday(2000, 5), 26);
```
-`lastFriday(2006, 6)` should return `30`.
+`lastFriday(2006, 6)` sollte `30` zurückgeben.
```js
assert.equal(lastFriday(2006, 6), 30);
```
-`lastFriday(2010, 7)` should return `30`.
+`lastFriday(2010, 7)` sollte `30` zurückgeben.
```js
assert.equal(lastFriday(2010, 7), 30);
```
-`lastFriday(2005, 8)` should return `26`.
+`lastFriday(2005, 8)` sollte `26` zurückgeben.
```js
assert.equal(lastFriday(2005, 8), 26);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-letter-first-letter.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-letter-first-letter.md
index f6bb3eafe56..86e9134c31b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-letter-first-letter.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/last-letter-first-letter.md
@@ -25,13 +25,13 @@ Write a function that takes an input array of words. The function should return
# --hints--
-`findLongestChain` should be a function.
+`findLongestChain` sollte eine Funktion sein.
```js
assert(typeof findLongestChain == 'function');
```
-`findLongestChain(["certain", "each", "game", "involves", "starting", "with", "word"])` should return an array.
+`findLongestChain(["certain", "each", "game", "involves", "starting", "with", "word"])` sollte ein Array zurückgeben.
```js
assert(
@@ -49,7 +49,7 @@ assert(
);
```
-`findLongestChain(["certain", "each", "game", "involves", "starting", "with", "word"])` should return `["involves", "starting", "game", "each"]`.
+`findLongestChain(["certain", "each", "game", "involves", "starting", "with", "word"])` sollte `["involves", "starting", "game", "each"]` zurückgeben.
```js
assert.deepEqual(
@@ -66,7 +66,7 @@ assert.deepEqual(
);
```
-`findLongestChain(["audino", "bagon", "kangaskhan", "banette", "bidoof", "braviary", "exeggcute", "yamask"])` should return `["braviary", "yamask", "kangaskhan"]`
+`findLongestChain(["audino", "bagon", "kangaskhan", "banette", "bidoof", "braviary", "exeggcute", "yamask"])` sollte `["braviary", "yamask", "kangaskhan"]` zurückgeben
```js
assert.deepEqual(
@@ -84,7 +84,7 @@ assert.deepEqual(
);
```
-`findLongestChain(["harp", "poliwrath", "poochyena", "porygon2", "porygonz", "archana"])` should return `["poliwrath", "harp", "poochyena", "archana"]`.
+`findLongestChain(["harp", "poliwrath", "poochyena", "porygon2", "porygonz", "archana"])` sollte `["poliwrath", "harp", "poochyena", "archana"]` zurückgeben.
```js
assert.deepEqual(
@@ -100,7 +100,7 @@ assert.deepEqual(
);
```
-`findLongestChain(["scolipede", "elephant", "zeaking", "sealeo", "silcoon", "tigers"])` should return `["scolipede", "elephant", "tigers", "sealeo"]`.
+`findLongestChain(["scolipede", "elephant", "zeaking", "sealeo", "silcoon", "tigers"])` sollte `["scolipede", "elephant", "tigers", "sealeo"]` zurückgeben.
```js
assert.deepEqual(
@@ -116,7 +116,7 @@ assert.deepEqual(
);
```
-`findLongestChain(["loudred", "lumineon", "lunatone", "machamp", "magnezone", "nosepass", "petilil", "pidgeotto", "pikachu"])` should return `["machamp", "petilil", "lumineon", "nosepass"]`.
+`findLongestChain(["loudred", "lumineon", "lunatone", "machamp", "magnezone", "nosepass", "petilil", "pidgeotto", "pikachu"])` sollte `["machamp", "petilil", "lumineon", "nosepass"]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/leap-year.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/leap-year.md
index ae2f6773c80..2fb7f98e5ea 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/leap-year.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/leap-year.md
@@ -12,49 +12,49 @@ Determine whether a given year is a leap year in the Gregorian calendar.
# --hints--
-`isLeapYear` should be a function.
+`isLeapYear` sollte eine Funktion sein.
```js
assert(typeof isLeapYear == 'function');
```
-`isLeapYear()` should return a boolean.
+`isLeapYear()` sollte einen Boolean zurückgeben.
```js
assert(typeof isLeapYear(2018) == 'boolean');
```
-`isLeapYear(2018)` should return `false`.
+`isLeapYear(2018)` sollte `false` zurückgeben.
```js
assert.equal(isLeapYear(2018), false);
```
-`isLeapYear(2016)` should return `true`.
+`isLeapYear(2016)` sollte `true` zurückgeben.
```js
assert.equal(isLeapYear(2016), true);
```
-`isLeapYear(2000)` should return `true`.
+`isLeapYear(2000)` sollte `true` zurückgeben.
```js
assert.equal(isLeapYear(2000), true);
```
-`isLeapYear(1900)` should return `false`.
+`isLeapYear(1900)` sollte `false` zurückgeben.
```js
assert.equal(isLeapYear(1900), false);
```
-`isLeapYear(1996)` should return `true`.
+`isLeapYear(1996)` sollte `true` zurückgeben.
```js
assert.equal(isLeapYear(1996), true);
```
-`isLeapYear(1800)` should return `false`.
+`isLeapYear(1800)` sollte `false` zurückgeben.
```js
assert.equal(isLeapYear(1800), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/least-common-multiple.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/least-common-multiple.md
index d84da1b8b61..1cd38c96d6a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/least-common-multiple.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/least-common-multiple.md
@@ -18,43 +18,43 @@ Compute the least common multiple of an array of integers. Given *m* and *n*, th
# --hints--
-`LCM` should be a function.
+`LCM` sollte eine Funktion sein.
```js
assert(typeof LCM == 'function');
```
-`LCM([2, 4, 8])` should return a number.
+`LCM([2, 4, 8])` sollte eine Zahl zurückgeben.
```js
assert(typeof LCM([2, 4, 8]) == 'number');
```
-`LCM([2, 4, 8])` should return `8`.
+`LCM([2, 4, 8])` sollte `8` zurückgeben.
```js
assert.equal(LCM([2, 4, 8]), 8);
```
-`LCM([4, 8, 12])` should return `24`.
+`LCM([4, 8, 12])` sollte `24` zurückgeben.
```js
assert.equal(LCM([4, 8, 12]), 24);
```
-`LCM([3, 4, 5, 12, 40])` should return `120`.
+`LCM([3, 4, 5, 12, 40])` sollte `120` zurückgeben.
```js
assert.equal(LCM([3, 4, 5, 12, 40]), 120);
```
-`LCM([11, 33, 90])` should return `990`.
+`LCM([11, 33, 90])` sollte `990` zurückgeben.
```js
assert.equal(LCM([11, 33, 90]), 990);
```
-`LCM([-50, 25, -45, -18, 90, 447])` should return `67050`.
+`LCM([-50, 25, -45, -18, 90, 447])` sollte `67050` zurückgeben.
```js
assert.equal(LCM([-50, 25, -45, -18, 90, 447]), 67050);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/left-factorials.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/left-factorials.md
index 6f589d1f1e1..aa604f0839f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/left-factorials.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/left-factorials.md
@@ -28,55 +28,55 @@ Write a function to calculate the left factorial of a given number.
# --hints--
-`leftFactorial` should be a function.
+`leftFactorial` sollte eine Funktion sein.
```js
assert(typeof leftFactorial == 'function');
```
-`leftFactorial(0)` should return a number.
+`leftFactorial(0)` sollte eine Zahl zurückgeben.
```js
assert(typeof leftFactorial(0) == 'number');
```
-`leftFactorial(0)` should return `0`.
+`leftFactorial(0)` sollte `0` zurückgeben.
```js
assert.equal(leftFactorial(0), 0);
```
-`leftFactorial(1)` should return `1`.
+`leftFactorial(1)` sollte `1` zurückgeben.
```js
assert.equal(leftFactorial(1), 1);
```
-`leftFactorial(2)` should return `2`.
+`leftFactorial(2)` sollte `2` zurückgeben.
```js
assert.equal(leftFactorial(2), 2);
```
-`leftFactorial(3)` should return `4`.
+`leftFactorial(3)` sollte `4` zurückgeben.
```js
assert.equal(leftFactorial(3), 4);
```
-`leftFactorial(10)` should return `409114`.
+`leftFactorial(10)` sollte `409114` zurückgeben.
```js
assert.equal(leftFactorial(10), 409114);
```
-`leftFactorial(17)` should return `22324392524314`.
+`leftFactorial(17)` sollte `22324392524314` zurückgeben.
```js
assert.equal(leftFactorial(17), 22324392524314);
```
-`leftFactorial(19)` should return `6780385526348314`.
+`leftFactorial(19)` sollte `6780385526348314` zurückgeben.
```js
assert.equal(leftFactorial(19), 6780385526348314);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/letter-frequency.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/letter-frequency.md
index 1efeade3f64..e4ff2392eb3 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/letter-frequency.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/letter-frequency.md
@@ -22,19 +22,19 @@ For example, given the string "ab", your function should return `[['a', 1], ['b'
# --hints--
-`letterFrequency` should be a function.
+`letterFrequency` sollte eine Funktion sein.
```js
assert(typeof letterFrequency == 'function');
```
-`letterFrequency("Not all that Mrs. Bennet, however")` should return an array.
+`letterFrequency("Not all that Mrs. Bennet, however")` sollte ein Array zurückgeben.
```js
assert(Array.isArray(letterFrequency('Not all that Mrs. Bennet, however')));
```
-`letterFrequency("Not all that Mrs. Bennet, however")` should return `[[" ", 5], [",", 1], [".", 1], ["B", 1], ["M", 1], ["N", 1], ["a", 2], ["e", 4], ["h", 2], ["l", 2], ["n", 2], ["o", 2], ["r", 2], ["s", 1], ["t", 4], ["v", 1], ["w", 1]]`.
+`letterFrequency("Not all that Mrs. Bennet, however")` sollte `[[" ", 5], [",", 1], [".", 1], ["B", 1], ["M", 1], ["N", 1], ["a", 2], ["e", 4], ["h", 2], ["l", 2], ["n", 2], ["o", 2], ["r", 2], ["s", 1], ["t", 4], ["v", 1], ["w", 1]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('Not all that Mrs. Bennet, however'), [
@@ -58,7 +58,7 @@ assert.deepEqual(letterFrequency('Not all that Mrs. Bennet, however'), [
]);
```
-`letterFrequency("daughters, could ask on the ")` should return `[[" ", 5],[",", 1],["a", 2],["c", 1],["d", 2],["e", 2],["g", 1],["h", 2],["k", 1],["l", 1],["n", 1],["o", 2],["r", 1],["s", 2],["t", 2],["u", 2]]`.
+`letterFrequency("daughters, could ask on the ")` sollte `[[" ", 5],[",", 1],["a", 2],["c", 1],["d", 2],["e", 2],["g", 1],["h", 2],["k", 1],["l", 1],["n", 1],["o", 2],["r", 1],["s", 2],["t", 2],["u", 2]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('daughters, could ask on the '), [
@@ -81,7 +81,7 @@ assert.deepEqual(letterFrequency('daughters, could ask on the '), [
]);
```
-`letterFrequency("husband any satisfactory description")` should return `[[" ", 3], ["a", 4], ["b", 1], ["c", 2], ["d", 2], ["e", 1], ["f", 1], ["h", 1], ["i", 3], ["n", 3], ["o", 2], ["p", 1], ["r", 2], ["s", 4], ["t", 3], ["u", 1], ["y", 2]]`.
+`letterFrequency("husband any satisfactory description")` sollte `[[" ", 3], ["a", 4], ["b", 1], ["c", 2], ["d", 2], ["e", 1], ["f", 1], ["h", 1], ["i", 3], ["n", 3], ["o", 2], ["p", 1], ["r", 2], ["s", 4], ["t", 3], ["u", 1], ["y", 2]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('husband any satisfactory description'), [
@@ -105,7 +105,7 @@ assert.deepEqual(letterFrequency('husband any satisfactory description'), [
]);
```
-`letterFrequency("in various ways--with barefaced")` should return `[[" ", 3], ["-", 2], ["a", 4], ["b", 1], ["c", 1], ["d", 1], ["e", 2], ["f", 1], ["h", 1], ["i", 3], ["n", 1], ["o", 1], ["r", 2], ["s", 2], ["t", 1], ["u", 1], ["v", 1], ["w", 2], ["y", 1]]`.
+`letterFrequency("in various ways--with barefaced")` sollte `[[" ", 3], ["-", 2], ["a", 4], ["b", 1], ["c", 1], ["d", 1], ["e", 2], ["f", 1], ["h", 1], ["i", 3], ["n", 1], ["o", 1], ["r", 2], ["s", 2], ["t", 1], ["u", 1], ["v", 1], ["w", 2], ["y", 1]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('in various ways--with barefaced'), [
@@ -131,7 +131,7 @@ assert.deepEqual(letterFrequency('in various ways--with barefaced'), [
]);
```
-`letterFrequency("distant surmises; but he eluded")` should return `[[" ", 4], [";", 1], ["a", 1], ["b", 1], ["d", 3], ["e", 4], ["h", 1], ["i", 2], ["l", 1], ["m", 1], ["n", 1], ["r", 1], ["s", 4], ["t", 3], ["u", 3]]`.
+`letterFrequency("distant surmises; but he eluded")` sollte `[[" ", 4], [";", 1], ["a", 1], ["b", 1], ["d", 3], ["e", 4], ["h", 1], ["i", 2], ["l", 1], ["m", 1], ["n", 1], ["r", 1], ["s", 4], ["t", 3], ["u", 3]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('distant surmises; but he eluded'), [
@@ -153,7 +153,7 @@ assert.deepEqual(letterFrequency('distant surmises; but he eluded'), [
]);
```
-`letterFrequency("last obliged to accept the second-hand,")` should return `[[" ", 5], [",", 1], ["-", 1], ["a", 3], ["b", 1], ["c", 3], ["d", 3], ["e", 4], ["g", 1], ["h", 2], ["i", 1], ["l", 2], ["n", 2], ["o", 3], ["p", 1], ["s", 2], ["t", 4]]`.
+`letterFrequency("last obliged to accept the second-hand,")` sollte `[[" ", 5], [",", 1], ["-", 1], ["a", 3], ["b", 1], ["c", 3], ["d", 3], ["e", 4], ["g", 1], ["h", 2], ["i", 1], ["l", 2], ["n", 2], ["o", 3], ["p", 1], ["s", 2], ["t", 4]]` zurückgeben.
```js
assert.deepEqual(letterFrequency('last obliged to accept the second-hand,'), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/levenshtein-distance.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/levenshtein-distance.md
index 89e9379aff2..c48e639dc81 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/levenshtein-distance.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/levenshtein-distance.md
@@ -10,7 +10,7 @@ dashedName: levenshtein-distance
In information theory and computer science, the **Levenshtein distance** is a metric for measuring the amount of difference between two sequences (i.e. an edit distance). The Levenshtein distance between two strings is defined as the minimum number of edits needed to transform one string into the other, with the allowable edit operations being insertion, deletion, or substitution of a single character.
-Example:
+Beispiel:
The Levenshtein distance between "**kitten**" and "**sitting**" is 3, since the following three edits change one into the other, and there isn't a way to do it with fewer than three edits:
@@ -30,49 +30,49 @@ Write a function that returns the Levenshtein distance between two strings given
# --hints--
-`levenshtein` should be a function.
+`levenshtein` sollte eine Funktion sein.
```js
assert(typeof levenshtein == 'function');
```
-`levenshtein("mist", "dist")` should return a number.
+`levenshtein("mist", "dist")` sollte eine Zahl zurückgeben.
```js
assert(typeof levenshtein('mist', 'dist') == 'number');
```
-`levenshtein("mist", "dist")` should return `1`.
+`levenshtein("mist", "dist")` sollte `1` zurückgeben.
```js
assert.equal(levenshtein('mist', 'dist'), 1);
```
-`levenshtein("tier", "tor")` should return `2`.
+`levenshtein("tier", "tor")` sollte `2` zurückgeben.
```js
assert.equal(levenshtein('tier', 'tor'), 2);
```
-`levenshtein("kitten", "sitting")` should return `3`.
+`levenshtein("kitten", "sitting")` sollte `3` zurückgeben.
```js
assert.equal(levenshtein('kitten', 'sitting'), 3);
```
-`levenshtein("stop", "tops")` should return `2`.
+`levenshtein("stop", "tops")` sollte `2` zurückgeben.
```js
assert.equal(levenshtein('stop', 'tops'), 2);
```
-`levenshtein("rosettacode", "raisethysword")` should return `8`.
+`levenshtein("rosettacode", "raisethysword")` sollte `8` zurückgeben.
```js
assert.equal(levenshtein('rosettacode', 'raisethysword'), 8);
```
-`levenshtein("mississippi", "swiss miss")` should return `8`.
+`levenshtein("mississippi", "swiss miss")` sollte `8` zurückgeben.
```js
assert.equal(levenshtein('mississippi', 'swiss miss'), 8);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/linear-congruential-generator.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/linear-congruential-generator.md
index 9b7ff866168..26b8a6d1b70 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/linear-congruential-generator.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/linear-congruential-generator.md
@@ -30,43 +30,43 @@ Write a function that takes $r_0,a,c,m,n$ as parameters and returns $r_n$.
# --hints--
-`linearCongGenerator` should be a function.
+`linearCongGenerator` sollte eine Funktion sein.
```js
assert(typeof linearCongGenerator == 'function');
```
-`linearCongGenerator(324, 1145, 177, 2148, 3)` should return a number.
+`linearCongGenerator(324, 1145, 177, 2148, 3)` sollte eine Zahl zurückgeben.
```js
assert(typeof linearCongGenerator(324, 1145, 177, 2148, 3) == 'number');
```
-`linearCongGenerator(324, 1145, 177, 2148, 3)` should return `855`.
+`linearCongGenerator(324, 1145, 177, 2148, 3)` sollte `855` zurückgeben.
```js
assert.equal(linearCongGenerator(324, 1145, 177, 2148, 3), 855);
```
-`linearCongGenerator(234, 11245, 145, 83648, 4)` should return `1110`.
+`linearCongGenerator(234, 11245, 145, 83648, 4)` sollte `1110` zurückgeben.
```js
assert.equal(linearCongGenerator(234, 11245, 145, 83648, 4), 1110);
```
-`linearCongGenerator(85, 11, 1234, 214748, 5)` should return `62217`.
+`linearCongGenerator(85, 11, 1234, 214748, 5)` sollte `62217` zurückgeben.
```js
assert.equal(linearCongGenerator(85, 11, 1234, 214748, 5), 62217);
```
-`linearCongGenerator(0, 1103515245, 12345, 2147483648, 1)` should return `12345`.
+`linearCongGenerator(0, 1103515245, 12345, 2147483648, 1)` sollte `12345` zurückgeben.
```js
assert.equal(linearCongGenerator(0, 1103515245, 12345, 2147483648, 1), 12345);
```
-`linearCongGenerator(0, 1103515245, 12345, 2147483648, 2)` should return `1406932606`.
+`linearCongGenerator(0, 1103515245, 12345, 2147483648, 2)` sollte `1406932606` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/long-multiplication.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/long-multiplication.md
index 174bde82794..10f442727ad 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/long-multiplication.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/long-multiplication.md
@@ -20,19 +20,19 @@ Write a function that takes two strings of large numbers as parameters. Your fun
# --hints--
-`mult` should be a function.
+`mult` sollte eine Funktion sein.
```js
assert(typeof mult == 'function');
```
-`mult("18446744073709551616", "18446744073709551616")` should return a string.
+`mult("18446744073709551616", "18446744073709551616")` sollte einen String zurückgeben.
```js
assert(typeof mult('18446744073709551616', '18446744073709551616') == 'string');
```
-`mult("18446744073709551616", "18446744073709551616")` should return `"340282366920938463463374607431768211456"`.
+`mult("18446744073709551616", "18446744073709551616")` sollte `"340282366920938463463374607431768211456"` zurückgeben.
```js
assert.equal(
@@ -41,7 +41,7 @@ assert.equal(
);
```
-`mult("31844674073709551616", "1844674407309551616")` should return `"58743055272886011737990786529368211456"`.
+`mult("31844674073709551616", "1844674407309551616")` sollte `"58743055272886011737990786529368211456"` zurückgeben.
```js
assert.equal(
@@ -50,7 +50,7 @@ assert.equal(
);
```
-`mult("1846744073709551616", "44844644073709551616")` should return `"82816580680737279241781007431768211456"`.
+`mult("1846744073709551616", "44844644073709551616")` sollte `"82816580680737279241781007431768211456"` zurückgeben.
```js
assert.equal(
@@ -59,7 +59,7 @@ assert.equal(
);
```
-`mult("1844674407370951616", "1844674407709551616")` should return `"3402823669833978308014392742590611456"`.
+`mult("1844674407370951616", "1844674407709551616")` sollte `"3402823669833978308014392742590611456"` zurückgeben.
```js
assert.equal(
@@ -68,7 +68,7 @@ assert.equal(
);
```
-`mult("2844674407370951616", "1844674407370955616")` should return `"5247498076580334548376218009219475456"`.
+`mult("2844674407370951616", "1844674407370955616")` sollte `"5247498076580334548376218009219475456"` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
index 5b4f0d4c1d3..547e6b9f595 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-common-subsequence.md
@@ -24,43 +24,43 @@ Write a case-sensitive function that returns the LCS of two strings. You don't n
# --hints--
-`lcs` should be a function.
+`lcs` sollte eine Funktion sein.
```js
assert(typeof lcs == 'function');
```
-`lcs("thisisatest", "testing123testing")` should return a string.
+`lcs("thisisatest", "testing123testing")` sollte einen String zurückgeben.
```js
assert(typeof lcs('thisisatest', 'testing123testing') == 'string');
```
-`lcs("thisisatest", "testing123testing")` should return `"tsitest"`.
+`lcs("thisisatest", "testing123testing")` sollte `"tsitest"` zurückgeben.
```js
assert.equal(lcs('thisisatest', 'testing123testing'), 'tsitest');
```
-`lcs("ABCDGH", "AEDFHR")` should return `"ADH"`.
+`lcs("ABCDGH", "AEDFHR")` sollte `"ADH"` zurückgeben.
```js
assert.equal(lcs('ABCDGH', 'AEDFHR'), 'ADH');
```
-`lcs("AGGTAB", "GXTXAYB")` should return `"GTAB"`.
+`lcs("AGGTAB", "GXTXAYB")` sollte `"GTAB"` zurückgeben.
```js
assert.equal(lcs('AGGTAB', 'GXTXAYB'), 'GTAB');
```
-`lcs("BDACDB", "BDCB")` should return `"BDCB"`.
+`lcs("BDACDB", "BDCB")` sollte `"BDCB"` zurückgeben.
```js
assert.equal(lcs('BDACDB', 'BDCB'), 'BDCB');
```
-`lcs("ABAZDC", "BACBAD")` should return `"ABAD"`.
+`lcs("ABAZDC", "BACBAD")` sollte `"ABAD"` zurückgeben.
```js
assert.equal(lcs('ABAZDC', 'BACBAD'), 'ABAD');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
index 0cd96a6d6cc..976be8166fe 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-increasing-subsequence.md
@@ -8,7 +8,7 @@ dashedName: longest-increasing-subsequence
# --description--
-The longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in which the subsequence is as long as possible. An example:
+The longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in which the subsequence is as long as possible. Ein Beispiel:
For the following array:
@@ -28,37 +28,37 @@ It is guaranteed that every array will have a longest increasing subsequence.
# --hints--
-`findSequence` should be a function.
+`findSequence` sollte eine Funktion sein.
```js
assert(typeof findSequence == 'function');
```
-`findSequence([3, 10, 2, 1, 20])` should return a array.
+`findSequence([3, 10, 2, 1, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(findSequence([3, 10, 2, 1, 20])));
```
-`findSequence([3, 10, 2, 1, 20])` should return `[3, 10, 20]`.
+`findSequence([3, 10, 2, 1, 20])` sollte `[3, 10, 20]` zurückgeben.
```js
assert.deepEqual(findSequence([3, 10, 2, 1, 20]), [3, 10, 20]);
```
-`findSequence([2, 7, 3, 5, 8])` should return `[2, 3, 5, 8]`.
+`findSequence([2, 7, 3, 5, 8])` sollte `[2, 3, 5, 8]` zurückgeben.
```js
assert.deepEqual(findSequence([2, 7, 3, 5, 8]), [2, 3, 5, 8]);
```
-`findSequence([2, 6, 4, 5, 1])` should return `[2, 4, 5]`.
+`findSequence([2, 6, 4, 5, 1])` sollte `[2, 4, 5]` zurückgeben.
```js
assert.deepEqual(findSequence([2, 6, 4, 5, 1]), [2, 4, 5]);
```
-`findSequence([10, 22, 9, 33, 21, 50, 60, 80])` should return `[10, 22, 33, 50, 60, 80]`.
+`findSequence([10, 22, 9, 33, 21, 50, 60, 80])` sollte `[10, 22, 33, 50, 60, 80]` zurückgeben.
```js
assert.deepEqual(findSequence([10, 22, 9, 33, 21, 50, 60, 80]), [
@@ -71,7 +71,7 @@ assert.deepEqual(findSequence([10, 22, 9, 33, 21, 50, 60, 80]), [
]);
```
-`findSequence([0, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15])` should return `[0, 2, 6, 9, 11, 15`.
+`findSequence([0, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15])` sollte `[0, 2, 6, 9, 11, 15` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-string-challenge.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
index f4bedb96bcc..187ade1f89e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/longest-string-challenge.md
@@ -16,19 +16,19 @@ Write a function that takes an array of strings and returns the strings that hav
# --hints--
-`longestString` should be a function.
+`longestString` sollte eine Funktion sein.
```js
assert(typeof longestString == 'function');
```
-`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` should return a array.
+`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg'])));
```
-`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` should return `["ccc", "ggg"]`.
+`longestString(["a", "bb", "ccc", "ee", "f", "ggg"])` sollte `["ccc", "ggg"]` zurückgeben.
```js
assert.deepEqual(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg']), [
@@ -37,7 +37,7 @@ assert.deepEqual(longestString(['a', 'bb', 'ccc', 'ee', 'f', 'ggg']), [
]);
```
-`longestString(["afedg", "bb", "sdccc", "efdee", "f", "geegg"])` should return `["afedg", "sdccc", "efdee", "geegg"]`.
+`longestString(["afedg", "bb", "sdccc", "efdee", "f", "geegg"])` sollte `["afedg", "sdccc", "efdee", "geegg"]` zurückgeben.
```js
assert.deepEqual(
@@ -46,7 +46,7 @@ assert.deepEqual(
);
```
-`longestString(["a", "bhghgb", "ccc", "efde", "fssdrr", "ggg"])` should return `["bhghgb", "fssdrr"]`.
+`longestString(["a", "bhghgb", "ccc", "efde", "fssdrr", "ggg"])` sollte `["bhghgb", "fssdrr"]` zurückgeben.
```js
assert.deepEqual(
@@ -55,7 +55,7 @@ assert.deepEqual(
);
```
-`longestString(["ahgfhg", "bdsfsb", "ccc", "ee", "f", "ggdsfg"])` should return `["ahgfhg", "bdsfsb", "ggdsfg"]`.
+`longestString(["ahgfhg", "bdsfsb", "ccc", "ee", "f", "ggdsfg"])` sollte `["ahgfhg", "bdsfsb", "ggdsfg"]` zurückgeben.
```js
assert.deepEqual(
@@ -64,7 +64,7 @@ assert.deepEqual(
);
```
-`longestString(["a", "bbdsf", "ccc", "edfe", "gzzzgg"])` should return `["gzzzgg"]`.
+`longestString(["a", "bbdsf", "ccc", "edfe", "gzzzgg"])` sollte `["gzzzgg"]` zurückgeben.
```js
assert.deepEqual(longestString(['a', 'bbdsf', 'ccc', 'edfe', 'gzzzgg']), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
index 464d824a0c9..fd811080301 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/look-and-say-sequence.md
@@ -16,10 +16,10 @@ Sequence Definition
Look at the number, visually grouping consecutive runs of the same digit.
Say the number, from left to right, group by group; as how many of that digit there are - followed by the digit grouped. This becomes the next number of the sequence.
-An example:
+Ein Beispiel:
- Starting with the number 1, you have one 1 which produces 11
-- Starting with 11, you have two 1's. I.E.: 21
+- Starting with 11, you have two 1's. z.B.: 21
- Starting with 21, you have one 2, then one 1. I.E.: (12)(11) which becomes 1211
- Starting with 1211, you have one 1, one 2, then two 1's. I.E.: (11)(12)(21) which becomes 111221
@@ -29,43 +29,43 @@ Write a function that accepts a string as a parameter, processes it, and returns
# --hints--
-`lookAndSay` should be a function.
+`lookAndSay` sollte eine Funktion sein.
```js
assert(typeof lookAndSay == 'function');
```
-`lookAndSay("1")` should return a string.
+`lookAndSay("1")` sollte einen String zurückgeben.
```js
assert(typeof lookAndSay('1') == 'string');
```
-`lookAndSay("1")` should return `"11"`.
+`lookAndSay("1")` sollte `"11"` zurückgeben.
```js
assert.equal(lookAndSay('1'), '11');
```
-`lookAndSay("11")` should return `"21"`.
+`lookAndSay("11")` sollte `"21"` zurückgeben.
```js
assert.equal(lookAndSay('11'), '21');
```
-`lookAndSay("21")` should return `"1211"`.
+`lookAndSay("21")` sollte `"1211"` zurückgeben.
```js
assert.equal(lookAndSay('21'), '1211');
```
-`lookAndSay("1211")` should return `"111221"`.
+`lookAndSay("1211")` sollte `"111221"` zurückgeben.
```js
assert.equal(lookAndSay('1211'), '111221');
```
-`lookAndSay("3542")` should return `"13151412"`.
+`lookAndSay("3542")` sollte `"13151412"` zurückgeben.
```js
assert.equal(lookAndSay('3542'), '13151412');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/loop-over-multiple-arrays-simultaneously.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/loop-over-multiple-arrays-simultaneously.md
index d0bd62b8726..8d73a7f16fa 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/loop-over-multiple-arrays-simultaneously.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/loop-over-multiple-arrays-simultaneously.md
@@ -16,7 +16,7 @@ For this example, if you are given this array of arrays:
[ ["a", "b", "c"], ["A", "B", "C"], [1, 2, 3] ]
```
-the output should be:
+die Ausgabe sollte sein:
```js
["aA1","bB2","cC3"]
@@ -28,13 +28,13 @@ Write a function that takes an array of arrays as a parameter and returns an arr
# --hints--
-`loopSimult` should be a function.
+`loopSimult` sollte eine Funktion sein.
```js
assert(typeof loopSimult == 'function');
```
-`loopSimult([["a", "b", "c"], ["A", "B", "C"], [1, 2, 3]])` should return a array.
+`loopSimult([["a", "b", "c"], ["A", "B", "C"], [1, 2, 3]])` sollte ein Array zurückgeben.
```js
assert(
@@ -48,7 +48,7 @@ assert(
);
```
-`loopSimult([["a", "b", "c"], ["A", "B", "C"], [1, 2, 3]])` should return `["aA1", "bB2", "cC3"]`.
+`loopSimult([["a", "b", "c"], ["A", "B", "C"], [1, 2, 3]])` sollte `["aA1", "bB2", "cC3"]` zurückgeben.
```js
assert.deepEqual(
@@ -61,7 +61,7 @@ assert.deepEqual(
);
```
-`loopSimult([["c", "b", "c"], ["4", "5", "C"], [7, 7, 3]])` should return `["c47", "b57", "cC3"]`.
+`loopSimult([["c", "b", "c"], ["4", "5", "C"], [7, 7, 3]])` sollte `["c47", "b57", "cC3"]` zurückgeben.
```js
assert.deepEqual(
@@ -74,7 +74,7 @@ assert.deepEqual(
);
```
-`loopSimult([["a", "b", "c", "d"], ["A", "B", "C", "d"], [1, 2, 3, 4]])` should return `["aA1", "bB2", "cC3", "dd4"]`.
+`loopSimult([["a", "b", "c", "d"], ["A", "B", "C", "d"], [1, 2, 3, 4]])` sollte `["aA1", "bB2", "cC3", "dd4"]` zurückgeben.
```js
assert.deepEqual(
@@ -87,7 +87,7 @@ assert.deepEqual(
);
```
-`loopSimult([["a", "b"], ["A", "B"], [1, 2]])` should return `["aA1", "bB2"]`.
+`loopSimult([["a", "b"], ["A", "B"], [1, 2]])` sollte `["aA1", "bB2"]` zurückgeben.
```js
assert.deepEqual(
@@ -100,7 +100,7 @@ assert.deepEqual(
);
```
-`loopSimult([["b", "c"], ["B", "C"], [2, 3]])` should return `["bB2", "cC3"]`.
+`loopSimult([["b", "c"], ["B", "C"], [2, 3]])` sollte `["bB2", "cC3"]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lu-decomposition.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lu-decomposition.md
index 45759df22aa..a11dcb9df98 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lu-decomposition.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lu-decomposition.md
@@ -48,7 +48,7 @@ $u\_{23}=a\_{23} - u\_{13}l\_{21}$
$u\_{33}=a\_{33} - (u\_{13}l\_{31} + u\_{23}l\_{32})$
-and for $l$:
+und für $l$:
$l\_{21}=\\frac{1}{u\_{11}} a\_{21}$
@@ -70,7 +70,7 @@ The solution to this problem is *pivoting* $A$, which means rearranging the rows
$PA \\Rightarrow A'$
-Example:
+Beispiel:
\\begin{align} \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} 1 & 4 \\\\ 2 & 3 \\end{pmatrix} \\Rightarrow \\begin{pmatrix} 2 & 3 \\\\ 1 & 4 \\end{pmatrix} \\end{align}
@@ -84,13 +84,13 @@ The task is to implement a routine which will take a square nxn matrix $A$ and r
# --hints--
-`luDecomposition` should be a function.
+`luDecomposition` sollte eine Funktion sein.
```js
assert(typeof luDecomposition == 'function');
```
-`luDecomposition([[1, 3, 5], [2, 4, 7], [1, 1, 0]])` should return a array.
+`luDecomposition([[1, 3, 5], [2, 4, 7], [1, 1, 0]])` sollte ein Array zurückgeben.
```js
assert(
@@ -104,7 +104,7 @@ assert(
);
```
-`luDecomposition([[1, 3, 5], [2, 4, 7], [1, 1, 0]])` should return `[[[1, 0, 0], [0.5, 1, 0], [0.5, -1, 1]], [[2, 4, 7], [0, 1, 1.5], [0, 0, -2]], [[0, 1, 0], [1, 0, 0], [0, 0, 1]]]`.
+`luDecomposition([[1, 3, 5], [2, 4, 7], [1, 1, 0]])` sollte `[[[1, 0, 0], [0.5, 1, 0], [0.5, -1, 1]], [[2, 4, 7], [0, 1, 1.5], [0, 0, -2]], [[0, 1, 0], [1, 0, 0], [0, 0, 1]]]` zurückgeben.
```js
assert.deepEqual(
@@ -133,7 +133,7 @@ assert.deepEqual(
);
```
-`luDecomposition([[11, 9, 24, 2], [1, 5, 2, 6], [3, 17, 18, 1], [2, 5, 7, 1]])` should return `[[[1, 0, 0, 0], [0.2727272727272727, 1, 0, 0], [0.09090909090909091, 0.2875, 1, 0], [0.18181818181818182, 0.23124999999999996, 0.0035971223021580693, 1]], [[11, 9, 24, 2], [0, 14.545454545454547, 11.454545454545455, 0.4545454545454546], [0, 0, -3.4749999999999996, 5.6875], [0, 0, 0, 0.510791366906476]], [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]]`.
+`luDecomposition([[11, 9, 24, 2], [1, 5, 2, 6], [3, 17, 18, 1], [2, 5, 7, 1]])` sollte `[[[1, 0, 0, 0], [0.2727272727272727, 1, 0, 0], [0.09090909090909091, 0.2875, 1, 0], [0.18181818181818182, 0.23124999999999996, 0.0035971223021580693, 1]], [[11, 9, 24, 2], [0, 14.545454545454547, 11.454545454545455, 0.4545454545454546], [0, 0, -3.4749999999999996, 5.6875], [0, 0, 0, 0.510791366906476]], [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]]` zurückgeben.
```js
assert.deepEqual(
@@ -166,7 +166,7 @@ assert.deepEqual(
);
```
-`luDecomposition([[1, 1, 1], [4, 3, -1], [3, 5, 3]])` should return `[[[1, 0, 0], [0.75, 1, 0], [0.25, 0.09090909090909091, 1]], [[4, 3, -1], [0, 2.75, 3.75], [0, 0, 0.9090909090909091]], [[0, 1, 0], [0, 0, 1], [1, 0, 0]]]`.
+`luDecomposition([[1, 1, 1], [4, 3, -1], [3, 5, 3]])` sollte `[[[1, 0, 0], [0.75, 1, 0], [0.25, 0.09090909090909091, 1]], [[4, 3, -1], [0, 2.75, 3.75], [0, 0, 0.9090909090909091]], [[0, 1, 0], [0, 0, 1], [1, 0, 0]]]` zurückgeben.
```js
assert.deepEqual(
@@ -195,7 +195,7 @@ assert.deepEqual(
);
```
-`luDecomposition([[1, -2, 3], [2, -5, 12], [0, 2, -10]])` should return `[[[1, 0, 0], [0, 1, 0], [0.5, 0.25, 1]], [[2, -5, 12], [0, 2, -10], [0, 0, -0.5]], [[0, 1, 0], [0, 0, 1], [1, 0, 0]]]`.
+`luDecomposition([[1, -2, 3], [2, -5, 12], [0, 2, -10]])` sollte `[[[1, 0, 0], [0, 1, 0], [0.5, 0.25, 1]], [[2, -5, 12], [0, 2, -10], [0, 0, -0.5]], [[0, 1, 0], [0, 0, 1], [1, 0, 0]]]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lucas-lehmer-test.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lucas-lehmer-test.md
index e909f6b3f6a..602da536eab 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lucas-lehmer-test.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lucas-lehmer-test.md
@@ -16,49 +16,49 @@ Write a function that returns whether the given Mersenne number is prime or not.
# --hints--
-`lucasLehmer` should be a function.
+`lucasLehmer` sollte eine Funktion sein.
```js
assert(typeof lucasLehmer == 'function');
```
-`lucasLehmer(11)` should return a boolean.
+`lucasLehmer(11)` sollte einen Boolean zurückgeben.
```js
assert(typeof lucasLehmer(11) == 'boolean');
```
-`lucasLehmer(11)` should return `false`.
+`lucasLehmer(11)` sollte `false` zurückgeben.
```js
assert.equal(lucasLehmer(11), false);
```
-`lucasLehmer(15)` should return `false`.
+`lucasLehmer(15)` sollte `false` zurückgeben.
```js
assert.equal(lucasLehmer(15), false);
```
-`lucasLehmer(13)` should return `true`.
+`lucasLehmer(13)` sollte `true` zurückgeben.
```js
assert.equal(lucasLehmer(13), true);
```
-`lucasLehmer(17)` should return `true`.
+`lucasLehmer(17)` sollte `true` zurückgeben.
```js
assert.equal(lucasLehmer(17), true);
```
-`lucasLehmer(19)` should return `true`.
+`lucasLehmer(19)` sollte `true` zurückgeben.
```js
assert.equal(lucasLehmer(19), true);
```
-`lucasLehmer(21)` should return `false`.
+`lucasLehmer(21)` sollte `false` zurückgeben.
```js
assert.equal(lucasLehmer(21), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ludic-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ludic-numbers.md
index 1311dbd718a..1922e92b22b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ludic-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ludic-numbers.md
@@ -16,7 +16,7 @@ To generate succeeding ludic numbers create an array of increasing integers star
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...
-(Loop)
+(Schleife)
- Take the first member of the resultant array as the next ludic number 2.
@@ -56,43 +56,43 @@ Write a function that returns all the ludic numbers less than or equal to the gi
# --hints--
-`ludic` should be a function.
+`ludic` sollte eine Funktion sein.
```js
assert(typeof ludic === 'function', 'ludic should be a function.');
```
-`ludic(2)` should return a array.
+`ludic(2)` sollte ein Array zurückgeben.
```js
assert(Array.isArray(ludic(2)));
```
-`ludic(2)` should return `[1, 2]`.
+`ludic(2)` sollte `[1, 2]` zurückgeben.
```js
assert.deepEqual(ludic(2), [1, 2]);
```
-`ludic(3)` should return `[1, 2, 3]`.
+`ludic(3)` sollte `[1, 2, 3]` zurückgeben.
```js
assert.deepEqual(ludic(3), [1, 2, 3]);
```
-`ludic(5)` should return `[1, 2, 3, 5]`.
+`ludic(5)` sollte `[1, 2, 3, 5]` zurückgeben.
```js
assert.deepEqual(ludic(5), [1, 2, 3, 5]);
```
-`ludic(20)` should return `[1, 2, 3, 5, 7, 11, 13, 17]`.
+`ludic(20)` sollte `[1, 2, 3, 5, 7, 11, 13, 17]` zurückgeben.
```js
assert.deepEqual(ludic(20), [1, 2, 3, 5, 7, 11, 13, 17]);
```
-`ludic(26)` should return `[1, 2, 3, 5, 7, 11, 13, 17, 23, 25]`.
+`ludic(26)` sollte `[1, 2, 3, 5, 7, 11, 13, 17, 23, 25]` zurückgeben.
```js
assert.deepEqual(ludic(26), [1, 2, 3, 5, 7, 11, 13, 17, 23, 25]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
index 596dfd62879..001dd985da0 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/luhn-test-of-credit-card-numbers.md
@@ -18,7 +18,7 @@ Those companies using credit card numbers that can be validated by the Luhn test
- Taking the second, fourth ... and every other even digit in the reversed digits:
- Multiply each digit by two and sum the digits if the answer is greater than nine to form partial sums for the even digits.
- - Sum the partial sums of the even digits to form s2.
+ - Addiere die Teilsummen der geraden Ziffern, um s2 zu bilden.
- If s1 + s2 ends in zero then the original number is in the form of a valid credit card number as verified by the Luhn test.
@@ -48,49 +48,49 @@ Write a function that will validate a number with the Luhn test. Return true if
# --hints--
-`luhnTest` should be a function.
+`luhnTest` sollte eine Funktion sein.
```js
assert(typeof luhnTest === 'function');
```
-`luhnTest("4111111111111111")` should return a boolean.
+`luhnTest("4111111111111111")` sollte einen Boolean zurückgeben.
```js
assert(typeof luhnTest('4111111111111111') === 'boolean');
```
-`luhnTest("4111111111111111")` should return `true`.
+`luhnTest("4111111111111111")` sollte `true` zurückgeben.
```js
assert.equal(luhnTest('4111111111111111'), true);
```
-`luhnTest("4111111111111112")` should return `false`.
+`luhnTest("4111111111111112")` sollte `false` zurückgeben.
```js
assert.equal(luhnTest('4111111111111112'), false);
```
-`luhnTest("49927398716")` should return `true`.
+`luhnTest("49927398716")` sollte `true` zurückgeben.
```js
assert.equal(luhnTest('49927398716'), true);
```
-`luhnTest("49927398717")` should return `false`.
+`luhnTest("49927398717")` sollte `false` zurückgeben.
```js
assert.equal(luhnTest('49927398717'), false);
```
-`luhnTest("1234567812345678")` should return `false`.
+`luhnTest("1234567812345678")` sollte `false` zurückgeben.
```js
assert.equal(luhnTest('1234567812345678'), false);
```
-`luhnTest("1234567812345670")` should return `true`.
+`luhnTest("1234567812345670")` sollte `true` zurückgeben.
```js
assert.equal(luhnTest('1234567812345670'), true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lychrel-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lychrel-numbers.md
index be2d4482f9f..4c94e6f505d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lychrel-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lychrel-numbers.md
@@ -68,49 +68,49 @@ Write a function that takes a number as a parameter. Return true if the number i
# --hints--
-`isLychrel` should be a function.
+`isLychrel` sollte eine Funktion sein.
```js
assert(typeof isLychrel === 'function');
```
-`isLychrel(12)` should return a boolean.
+`isLychrel(12)` sollte einen Boolean zurückgeben.
```js
assert(typeof isLychrel(12) === 'boolean');
```
-`isLychrel(12)` should return `false`.
+`isLychrel(12)` sollte `false` zurückgeben.
```js
assert.equal(isLychrel(12), false);
```
-`isLychrel(55)` should return `false`.
+`isLychrel(55)` sollte `false` zurückgeben.
```js
assert.equal(isLychrel(55), false);
```
-`isLychrel(196)` should return `true`.
+`isLychrel(196)` sollte `true` zurückgeben.
```js
assert.equal(isLychrel(196), true);
```
-`isLychrel(879)` should return `true`.
+`isLychrel(879)` sollte `true` zurückgeben.
```js
assert.equal(isLychrel(879), true);
```
-`isLychrel(44987)` should return `false`.
+`isLychrel(44987)` sollte `false` zurückgeben.
```js
assert.equal(isLychrel(44987), false);
```
-`isLychrel(7059)` should return `true`.
+`isLychrel(7059)` sollte `true` zurückgeben.
```js
assert.equal(isLychrel(7059), true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lzw-compression.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lzw-compression.md
index e4aa0f6e571..df71a4ea369 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lzw-compression.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/lzw-compression.md
@@ -16,19 +16,19 @@ Write a function that takes two parameters. The first parameter is a boolean whe
# --hints--
-`LZW` should be a function.
+`LZW` sollte eine Funktion sein.
```js
assert(typeof LZW === 'function');
```
-`LZW(true, "TOBEORNOTTOBEORTOBEORNOT")` should return a array.
+`LZW(true, "TOBEORNOTTOBEORTOBEORNOT")` sollte ein Array zurückgeben.
```js
assert(Array.isArray(LZW(true, 'TOBEORNOTTOBEORTOBEORNOT')));
```
-`LZW(false, [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263])` should return a string.
+`LZW(false, [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263])` sollte einen String zurückgeben.
```js
assert(
@@ -53,7 +53,7 @@ assert(
);
```
-`LZW(true, "TOBEORNOTTOBEORTOBEORNOT")` should return `[84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263]`.
+`LZW(true, "TOBEORNOTTOBEORTOBEORNOT")` sollte `[84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263]` zurückgeben.
```js
assert.deepEqual(LZW(true, 'TOBEORNOTTOBEORTOBEORNOT'), [
@@ -76,7 +76,7 @@ assert.deepEqual(LZW(true, 'TOBEORNOTTOBEORTOBEORNOT'), [
]);
```
-`LZW(false, [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263])` should return `"TOBEORNOTTOBEORTOBEORNOT"`.
+`LZW(false, [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263])` sollte `"TOBEORNOTTOBEORTOBEORNOT"` zurückgeben.
```js
assert.equal(
@@ -102,7 +102,7 @@ assert.equal(
);
```
-`LZW(true, "0123456789")` should return `[48, 49, 50, 51, 52, 53, 54, 55, 56, 57]`.
+`LZW(true, "0123456789")` sollte `[48, 49, 50, 51, 52, 53, 54, 55, 56, 57]` zurückgeben.
```js
assert.deepEqual(LZW(true, '0123456789'), [
@@ -119,7 +119,7 @@ assert.deepEqual(LZW(true, '0123456789'), [
]);
```
-`LZW(false, [48, 49, 50, 51, 52, 53, 54, 55, 56, 57])` should return `"0123456789"`.
+`LZW(false, [48, 49, 50, 51, 52, 53, 54, 55, 56, 57])` sollte `"0123456789"` zurückgeben.
```js
assert.equal(
@@ -128,13 +128,13 @@ assert.equal(
);
```
-`LZW(true, "BABAABAAA")` should return `[66, 65, 256, 257, 65, 260]`.
+`LZW(true, "BABAABAAA")` sollte `[66, 65, 256, 257, 65, 260]` zurückgeben.
```js
assert.deepEqual(LZW(true, 'BABAABAAA'), [66, 65, 256, 257, 65, 260]);
```
-`LZW(false, [66, 65, 256, 257, 65, 260])` should return `"BABAABAAA"`.
+`LZW(false, [66, 65, 256, 257, 65, 260])` sollte `"BABAABAAA"` zurückgeben.
```js
assert.equal(LZW(false, [66, 65, 256, 257, 65, 260]), 'BABAABAAA');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/s-expressions.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/s-expressions.md
index df583d4cb2a..54cfd562dc2 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/s-expressions.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/s-expressions.md
@@ -36,19 +36,19 @@ and turn it into a native data structure.
# --hints--
-`parseSexpr` should be a function.
+`parseSexpr` sollte eine Funktion sein.
```js
assert(typeof parseSexpr === 'function');
```
-`parseSexpr('(data1 data2 data3)')` should return `['data1', 'data2', 'data3']`
+`parseSexpr('(data1 data2 data3)')` sollte `['data1', 'data2', 'data3']` zurückgeben
```js
assert.deepEqual(parseSexpr(simpleSExpr), simpleSolution);
```
-`parseSexpr('((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))')` should return `[['data', '"quoted data"', 123, 4.5], ['data', ['!@#', [4.5], '"(more"', '"data)"']]]`.
+`parseSexpr('((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))')` sollte `[['data', '"quoted data"', 123, 4.5], ['data', ['!@#', [4.5], '"(more"', '"data)"']]]` zurückgeben.
```js
assert.deepEqual(parseSexpr(basicSExpr), basicSolution);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md
index 8117215835e..9e8ee318deb 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.md
@@ -22,25 +22,25 @@ Create a function that returns the minimum possible size of the initial pile of
# --hints--
-`splitCoconuts` should be a function.
+`splitCoconuts` sollte eine Funktion sein.
```js
assert(typeof splitCoconuts === 'function');
```
-`splitCoconuts(5)` should return 3121.
+`splitCoconuts(5)` sollte 3121 zurückgeben.
```js
assert(splitCoconuts(5) === 3121);
```
-`splitCoconuts(6)` should return 233275.
+`splitCoconuts(6)` sollte 233275 zurückgeben.
```js
assert(splitCoconuts(6) === 233275);
```
-`splitCoconuts(7)` should return 823537.
+`splitCoconuts(7)` sollte 823537 zurückgeben.
```js
assert(splitCoconuts(7) === 823537);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/search-a-list-of-records.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/search-a-list-of-records.md
index 439ece2740e..ebefbaa35ec 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/search-a-list-of-records.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/search-a-list-of-records.md
@@ -16,43 +16,43 @@ Write a function that takes a string as a parameter. The function should return
# --hints--
-`searchCity` should be a function.
+`searchCity` sollte eine Funktion sein.
```js
assert(typeof searchCity === 'function');
```
-`searchCity("Dar Es Salaam")` should return a number.
+`searchCity("Dar Es Salaam")` sollte eine Zahl zurückgeben.
```js
assert(typeof searchCity('Dar Es Salaam') === 'number');
```
-`searchCity("Dar Es Salaam")` should return `6`.
+`searchCity("Dar Es Salaam")` sollte `6` zurückgeben.
```js
assert.equal(searchCity('Dar Es Salaam'), 6);
```
-`searchCity("Casablanca")` should return `9`.
+`searchCity("Casablanca")` sollte `9` zurückgeben.
```js
assert.equal(searchCity('Casablanca'), 9);
```
-`searchCity("Cairo")` should return `1`.
+`searchCity("Cairo")` sollte `1` zurückgeben.
```js
assert.equal(searchCity('Cairo'), 1);
```
-`searchCity("Mogadishu")` should return `4`.
+`searchCity("Mogadishu")` sollte `4` zurückgeben.
```js
assert.equal(searchCity('Mogadishu'), 4);
```
-`searchCity("Lagos")` should return `0`.
+`searchCity("Lagos")` sollte `0` zurückgeben.
```js
assert.equal(searchCity('Lagos'), 0);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sedols.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sedols.md
index 9ace124614e..3f19d15e42a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sedols.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sedols.md
@@ -30,31 +30,31 @@ Check that each input is correctly formed, especially with respect to valid char
# --hints--
-`sedol` should be a function.
+`sedol` sollte eine Funktion sein.
```js
assert(typeof sedol === 'function');
```
-`sedol('a')` should return null.
+`sedol('a')` sollte null zurückgeben.
```js
assert(sedol('a') === null);
```
-`sedol('710889')` should return '7108899'.
+`sedol('710889')` sollte '7108899' zurückgeben.
```js
assert(sedol('710889') === '7108899');
```
-`sedol('BOATER')` should return null.
+`sedol('BOATER')` sollte null zurückgeben.
```js
assert(sedol('BOATER') === null);
```
-`sedol('228276')` should return '2282765'.
+`sedol('228276')` sollte '2282765' zurückgeben.
```js
assert(sedol('228276') === '2282765');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-describing-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-describing-numbers.md
index dc5318141ce..91913317aaa 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-describing-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-describing-numbers.md
@@ -29,31 +29,31 @@ Write a function that takes a positive integer as a parameter. If it is self-des
# --hints--
-`isSelfDescribing` should be a function.
+`isSelfDescribing` sollte eine Funktion sein.
```js
assert(typeof isSelfDescribing == 'function');
```
-`isSelfDescribing()` should return a boolean.
+`isSelfDescribing()` sollte einen Boolean zurückgeben.
```js
assert(typeof isSelfDescribing(2020) == 'boolean');
```
-`isSelfDescribing(2020)` should return `true`.
+`isSelfDescribing(2020)` sollte `true` zurückgeben.
```js
assert.equal(isSelfDescribing(2020), true);
```
-`isSelfDescribing(3021)` should return `false`.
+`isSelfDescribing(3021)` sollte `false` zurückgeben.
```js
assert.equal(isSelfDescribing(3021), false);
```
-`isSelfDescribing(3211000)` should return `true`.
+`isSelfDescribing(3211000)` sollte `true` zurückgeben.
```js
assert.equal(isSelfDescribing(3211000), true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-referential-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-referential-sequence.md
index 086840b687f..337e2d34dbd 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-referential-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/self-referential-sequence.md
@@ -30,19 +30,19 @@ Write a function that takes the seed value as parameter, generates a self refere
# --hints--
-`selfReferential` should be a function.
+`selfReferential` sollte eine Funktion sein.
```js
assert(typeof selfReferential === 'function');
```
-`selfReferential(40)` should return a array.
+`selfReferential(40)` sollte ein Array zurückgeben.
```js
assert(Array.isArray(selfReferential(40)));
```
-`selfReferential(40)` should return `["40", "1410", "142110", "14123110", "1413124110", "2413125110", "151413224110", "152413225110", "251413324110", "152423224110", "152413423110"]`.
+`selfReferential(40)` sollte `["40", "1410", "142110", "14123110", "1413124110", "2413125110", "151413224110", "152413225110", "251413324110", "152423224110", "152413423110"]` zurückgeben.
```js
assert.deepEqual(selfReferential(40), [
@@ -60,7 +60,7 @@ assert.deepEqual(selfReferential(40), [
]);
```
-`selfReferential(132110)` should return `["132110", "13123110", "23124110", "1413223110", "1423224110", "2413323110", "1433223110"]`.
+`selfReferential(132110)` sollte `["132110", "13123110", "23124110", "1413223110", "1423224110", "2413323110", "1433223110"]` zurückgeben.
```js
assert.deepEqual(selfReferential(132110), [
@@ -74,7 +74,7 @@ assert.deepEqual(selfReferential(132110), [
]);
```
-`selfReferential(132211)` should return `["132211", "132231", "232221", "134211", "14131231", "14231241", "24132231", "14233221"]`.
+`selfReferential(132211)` sollte `["132211", "132231", "232221", "134211", "14131231", "14231241", "24132231", "14233221"]` zurückgeben.
```js
assert.deepEqual(selfReferential(132211), [
@@ -89,7 +89,7 @@ assert.deepEqual(selfReferential(132211), [
]);
```
-`selfReferential(1413223110)` should return `["1413223110", "1423224110", "2413323110", "1433223110"]`.
+`selfReferential(1413223110)` sollte `["1413223110", "1423224110", "2413323110", "1433223110"]` zurückgeben.
```js
assert.deepEqual(selfReferential(1413223110), [
@@ -100,7 +100,7 @@ assert.deepEqual(selfReferential(1413223110), [
]);
```
-`selfReferential(251413126110)` should return `["251413126110", "16151413225110", "16251413226110", "26151413325110", "16251423225110", "16251413424110", "16153413225110"]`.
+`selfReferential(251413126110)` sollte `["251413126110", "16151413225110", "16251413226110", "26151413325110", "16251423225110", "16251413424110", "16153413225110"]` zurückgeben.
```js
assert.deepEqual(selfReferential(251413126110), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/semiprime.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/semiprime.md
index 590e77332ef..7e40f3499ee 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/semiprime.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/semiprime.md
@@ -18,73 +18,73 @@ Write a function that returns true if a number is semiprime, or false if it is n
# --hints--
-`isSemiPrime` should be a function.
+`isSemiPrime` sollte eine Funktion sein.
```js
assert(typeof isSemiPrime === 'function');
```
-`isSemiPrime(100)` should return a boolean.
+`isSemiPrime(100)` sollte einen Boolean zurückgeben.
```js
assert(typeof isSemiPrime(100) === 'boolean');
```
-`isSemiPrime(100)` should return `false`.
+`isSemiPrime(100)` sollte `false` zurückgeben.
```js
assert.equal(isSemiPrime(100), false);
```
-`isSemiPrime(504)` should return `false`.
+`isSemiPrime(504)` sollte `false` zurückgeben.
```js
assert.equal(isSemiPrime(504), false);
```
-`isSemiPrime(4)` should return `true`.
+`isSemiPrime(4)` sollte `true` zurückgeben.
```js
assert.equal(isSemiPrime(4), true);
```
-`isSemiPrime(46)` should return `true`.
+`isSemiPrime(46)` sollte `true` zurückgeben.
```js
assert.equal(isSemiPrime(46), true);
```
-`isSemiPrime(13)` should return `false`.
+`isSemiPrime(13)` sollte `false` zurückgeben.
```js
assert.equal(isSemiPrime(13), false);
```
-`isSemiPrime(74)` should return `true`.
+`isSemiPrime(74)` sollte `true` zurückgeben.
```js
assert.equal(isSemiPrime(74), true);
```
-`isSemiPrime(1679)` should return `true`.
+`isSemiPrime(1679)` sollte `true` zurückgeben.
```js
assert.equal(isSemiPrime(1679), true);
```
-`isSemiPrime(2)` should return `false`.
+`isSemiPrime(2)` sollte `false` zurückgeben.
```js
assert.equal(isSemiPrime(2), false);
```
-`isSemiPrime(95)` should return `true`.
+`isSemiPrime(95)` sollte `true` zurückgeben.
```js
assert.equal(isSemiPrime(95), true);
```
-`isSemiPrime(124)` should return `false`.
+`isSemiPrime(124)` sollte `false` zurückgeben.
```js
assert.equal(isSemiPrime(124), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-consolidation.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-consolidation.md
index 07a585e0875..e216493e733 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-consolidation.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-consolidation.md
@@ -17,29 +17,29 @@ Given two sets of items then if any item is common to any set then the result of
Given N sets of items where N > 2 then the result is the same as repeatedly replacing all combinations of two sets by their consolidation until no further consolidation between set pairs is possible. If N < 2 then consolidation has no strict meaning and the input can be returned.
-Here are some examples:
+Hier sind ein paar Beispiele:
-**Example 1:**
+**Beispiel 1:**
Given the two sets `{A,B}` and `{C,D}` then there is no common element between the sets and the result is the same as the input.
-**Example 2:**
+**Beispiel 2:**
Given the two sets `{A,B}` and `{B,D}` then there is a common element `B` between the sets and the result is the single set `{B,D,A}`. (Note that order of items in a set is immaterial: `{A,B,D}` is the same as `{B,D,A}` and `{D,A,B}`, etc).
-**Example 3:**
+**Beispiel 3:**
Given the three sets `{A,B}` and `{C,D}` and `{D,B}` then there is no common element between the sets `{A,B}` and `{C,D}` but the sets `{A,B}` and `{D,B}` do share a common element that consolidates to produce the result `{B,D,A}`. On examining this result with the remaining set, `{C,D}`, they share a common element and so consolidate to the final output of the single set `{A,B,C,D}`
-**Example 4:**
+**Beispiel 4:**
The consolidation of the five sets:
-`{H,I,K}`, `{A,B}`, `{C,D}`, `{D,B}`, and `{F,G,H}`
+`{H,I,K}`, `{A,B}`, `{C,D}`, `{D,B}` und `{F,G,H}`
Is the two sets:
-`{A, C, B, D}`, and `{G, F, I, H, K}`
+`{A, C, B, D}` und `{G, F, I, H, K}`
# --instructions--
@@ -47,19 +47,19 @@ Write a function that takes an array of strings as a parameter. Each string is r
# --hints--
-`setConsolidation` should be a function.
+`setConsolidation` sollte eine Funktion sein.
```js
assert(typeof setConsolidation === 'function');
```
-`setConsolidation(["AB", "CD"])` should return a array.
+`setConsolidation(["AB", "CD"])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(setConsolidation(['AB', 'CD'])));
```
-`setConsolidation(["AB", "CD"])` should return `[["C", "D"], ["A", "B"]]`.
+`setConsolidation(["AB", "CD"])` sollte `[["C", "D"], ["A", "B"]]` zurückgeben.
```js
assert.deepEqual(setConsolidation(['AB', 'CD']), [
@@ -68,19 +68,19 @@ assert.deepEqual(setConsolidation(['AB', 'CD']), [
]);
```
-`setConsolidation(["AB", "BD"])` should return `[["A", "B", "D"]]`.
+`setConsolidation(["AB", "BD"])` sollte `[["A", "B", "D"]]` zurückgeben.
```js
assert.deepEqual(setConsolidation(['AB', 'BD']), [['A', 'B', 'D']]);
```
-`setConsolidation(["AB", "CD", "DB"])` should return `[["A", "B", "C", "D"]]`.
+`setConsolidation(["AB", "CD", "DB"])` sollte `[["A", "B", "C", "D"]]` zurückgeben.
```js
assert.deepEqual(setConsolidation(['AB', 'CD', 'DB']), [['A', 'B', 'C', 'D']]);
```
-`setConsolidation(["HIK", "AB", "CD", "DB", "FGH"])` should return `[["F", "G", "H", "I", "K"], ["A", "B", "C", "D"]]`.
+`setConsolidation(["HIK", "AB", "CD", "DB", "FGH"])` sollte `[["F", "G", "H", "I", "K"], ["A", "B", "C", "D"]]` zurückgeben.
```js
assert.deepEqual(setConsolidation(['HIK', 'AB', 'CD', 'DB', 'FGH']), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-of-real-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-of-real-numbers.md
index addfc4c751b..064d2d3ada1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-of-real-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/set-of-real-numbers.md
@@ -11,10 +11,10 @@ dashedName: set-of-real-numbers
All real numbers form the uncountable set ℝ. Among its subsets, relatively simple are the convex sets, each expressed as a range between two real numbers *a* and *b* where *a* ≤ *b*. There are actually four cases for the meaning of "between", depending on open or closed boundary:
- - [a, b]: {x | a ≤ x and x ≤ b }
- - (a, b): {x | a < x and x < b }
- - [a, b): {x | a ≤ x and x < b }
- - (a, b]: {x | a < x and x ≤ b }
+ - [a, b]: {x | a ≤ x und x ≤ b }
+ - (a, b): {x | a < x und x < b }
+ - [a, b): {x | a ≤ x und x < b }
+ - (a, b]: {x | a < x und x ≤ b }
Note that if *a* = *b*, of the four only \[*a*, *a*] would be non-empty.
@@ -50,19 +50,19 @@ Write a function that takes 2 objects, a string and an array as parameters. The
The `rangeType` can have values 0, 1, 2 and 3 for `CLOSED`, `BOTH_OPEN`, `LEFT_OPEN` and `RIGHT_OPEN`, respectively. The function should implement a set using this information.
-The string represents the operation to be performed on the sets. It can be: `"union"`, `"intersect"` and `"subtract"` (difference).
+The string represents the operation to be performed on the sets. Es kann Folgendes sein: `"union"`, `"intersect"` und `"subtract"` (Differenz).
-After performing the operation, the function should check if the values in the array are present in the resultant set and store a corresponding boolean value to an array. The function should return this array.
+After performing the operation, the function should check if the values in the array are present in the resultant set and store a corresponding boolean value to an array. Die Funktion sollte dieses Array zurückgeben.
# --hints--
-`realSet` should be a function.
+`realSet` sollte eine Funktion sein.
```js
assert(typeof realSet == 'function');
```
-`realSet({"low":0, "high":1, "rangeType":2}, {"low":0, "high":2, "rangeType":3}, "union", [1, 2, 3])` should return a array.
+`realSet({"low":0, "high":1, "rangeType":2}, {"low":0, "high":2, "rangeType":3}, "union", [1, 2, 3])` sollte ein Array zurückgeben.
```js
assert(
@@ -77,7 +77,7 @@ assert(
);
```
-`realSet({"low":0, "high":1, "rangeType":2}, {"low":0, "high":2, "rangeType":3}, "union", [1, 2, 3])` should return `[true, false, false]`.
+`realSet({"low":0, "high":1, "rangeType":2}, {"low":0, "high":2, "rangeType":3}, "union", [1, 2, 3])` sollte `[true, false, false]` zurückgeben.
```js
assert.deepEqual(
@@ -91,7 +91,7 @@ assert.deepEqual(
);
```
-`realSet({"low":0, "high":2, "rangeType":3}, {"low":1, "high":2, "rangeType":2}, "intersect", [0, 1, 2])` should return `[false, false, false]`.
+`realSet({"low":0, "high":2, "rangeType":3}, {"low":1, "high":2, "rangeType":2}, "intersect", [0, 1, 2])` sollte `[false, false, false]` zurückgeben.
```js
assert.deepEqual(
@@ -105,7 +105,7 @@ assert.deepEqual(
);
```
-`realSet({"low":0, "high":3, "rangeType":3}, {"low":0, "high":1, "rangeType":1}, "subtract", [0, 1, 2])` should return `[true, true, true]`.
+`realSet({"low":0, "high":3, "rangeType":3}, {"low":0, "high":1, "rangeType":1}, "subtract", [0, 1, 2])` sollte `[true, true, true]` zurückgeben.
```js
assert.deepEqual(
@@ -119,7 +119,7 @@ assert.deepEqual(
);
```
-`realSet({"low":0, "high":3, "rangeType":3}, {"low":0, "high":1, "rangeType":0}, "subtract", [0, 1, 2])` should return `[false, false, true]`.
+`realSet({"low":0, "high":3, "rangeType":3}, {"low":0, "high":1, "rangeType":0}, "subtract", [0, 1, 2])` sollte `[false, false, true]` zurückgeben.
```js
assert.deepEqual(
@@ -133,7 +133,7 @@ assert.deepEqual(
);
```
-`realSet({"low":0, "high":33, "rangeType":1}, {"low":30, "high":31, "rangeType":0}, "intersect", [30, 31, 32])` should return `[true, true, false]`.
+`realSet({"low":0, "high":33, "rangeType":1}, {"low":30, "high":31, "rangeType":0}, "intersect", [30, 31, 32])` sollte `[true, true, false]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-1.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-1.md
index 3ac65ad9604..790096116c8 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-1.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-1.md
@@ -24,43 +24,43 @@ Write a function that returns the SHA-1 message digest for a given string.
# --hints--
-`SHA1` should be a function.
+`SHA1` sollte eine Funktion sein.
```js
assert(typeof SHA1 === 'function');
```
-`SHA1("abc")` should return a string.
+`SHA1("abc")` sollte einen String zurückgeben.
```js
assert(typeof SHA1('abc') === 'string');
```
-`SHA1("abc")` should return `"a9993e364706816aba3e25717850c26c9cd0d89d"`.
+`SHA1("abc")` sollte `"a9993e364706816aba3e25717850c26c9cd0d89d"` zurückgeben.
```js
assert.equal(SHA1('abc'), 'a9993e364706816aba3e25717850c26c9cd0d89d');
```
-`SHA1("Rosetta Code")` should return `"48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"`.
+`SHA1("Rosetta Code")` sollte `"48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"` zurückgeben.
```js
assert.equal(SHA1('Rosetta Code'), '48c98f7e5a6e736d790ab740dfc3f51a61abe2b5');
```
-`SHA1("Hello world")` should return `"7b502c3a1f48c8609ae212cdfb639dee39673f5e"`.
+`SHA1("Hello world")` sollte `"7b502c3a1f48c8609ae212cdfb639dee39673f5e"` zurückgeben.
```js
assert.equal(SHA1('Hello world'), '7b502c3a1f48c8609ae212cdfb639dee39673f5e');
```
-`SHA1("Programming")` should return `"d1a946bf8b2f2a7292c250063ee28989d742cd4b"`.
+`SHA1("Programming")` sollte `"d1a946bf8b2f2a7292c250063ee28989d742cd4b"` zurückgeben.
```js
assert.equal(SHA1('Programming'), 'd1a946bf8b2f2a7292c250063ee28989d742cd4b');
```
-`SHA1("is Awesome")` should return `"6537205da59c72b57ed3881843c2d24103d683a3"`.
+`SHA1("is Awesome")` sollte `"6537205da59c72b57ed3881843c2d24103d683a3"` zurückgeben.
```js
assert.equal(SHA1('is Awesome'), '6537205da59c72b57ed3881843c2d24103d683a3');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-256.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-256.md
index c0ef963ee80..231872cda8d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-256.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sha-256.md
@@ -16,19 +16,19 @@ Research implementation details and write a function that takes a string as the
# --hints--
-`SHA256` should be a function.
+`SHA256` sollte eine Funktion sein.
```js
assert(typeof SHA256 === 'function');
```
-`SHA256("Rosetta code")` should return a string.
+`SHA256("Rosetta code")` sollte einen String zurückgeben.
```js
assert(typeof SHA256('Rosetta code') === 'string');
```
-`SHA256("Rosetta code")` should return `"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"`.
+`SHA256("Rosetta code")` sollte `"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"` zurückgeben.
```js
assert.equal(
@@ -37,7 +37,7 @@ assert.equal(
);
```
-`SHA256("SHA-256 Hash")` should return `"bee8c0cabdcf8c7835f40217dd35a8b0dba9134520e633f1c57285f35ca7ee3e"`.
+`SHA256("SHA-256 Hash")` sollte `"bee8c0cabdcf8c7835f40217dd35a8b0dba9134520e633f1c57285f35ca7ee3e"` zurückgeben.
```js
assert.equal(
@@ -46,7 +46,7 @@ assert.equal(
);
```
-`SHA256("implementation")` should return `"da31012c40330e7e21538e7dd57503b16e8a0839159e96137090cccc9910b171"`.
+`SHA256("implementation")` sollte `"da31012c40330e7e21538e7dd57503b16e8a0839159e96137090cccc9910b171"` zurückgeben.
```js
assert.equal(
@@ -55,7 +55,7 @@ assert.equal(
);
```
-`SHA256("algorithm")` should return `"b1eb2ec8ac9f31ff7918231e67f96e6deda83a9ff33ed2c67443f1df81e5ed14"`.
+`SHA256("algorithm")` sollte `"b1eb2ec8ac9f31ff7918231e67f96e6deda83a9ff33ed2c67443f1df81e5ed14"` zurückgeben.
```js
assert.equal(
@@ -64,7 +64,7 @@ assert.equal(
);
```
-`SHA256("language")` should return `"a4ef304ba42a200bafd78b046e0869af9183f6eee5524aead5dcb3a5ab5f8f3f"`.
+`SHA256("language")` sollte `"a4ef304ba42a200bafd78b046e0869af9183f6eee5524aead5dcb3a5ab5f8f3f"` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-an-array-of-composite-structures.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-an-array-of-composite-structures.md
index 124644791f7..c0025923551 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-an-array-of-composite-structures.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-an-array-of-composite-structures.md
@@ -12,13 +12,13 @@ Write a function that takes an array of objects as a parameter. The function sho
# --hints--
-`sortByKey` should be a function.
+`sortByKey` sollte eine Funktion sein.
```js
assert(typeof sortByKey == 'function');
```
-`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` should return an array.
+`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` sollte ein Array zurückgeben.
```js
assert(
@@ -34,7 +34,7 @@ assert(
);
```
-`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` should return `[{key: 1, value: 42}, {key: 2, value: "bar"}, {key: 3, value: "foo"}, {key: 4, value: "baz"}, {key: 5, value: "another string"}]`.
+`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` sollte `[{key: 1, value: 42}, {key: 2, value: "bar"}, {key: 3, value: "foo"}, {key: 4, value: "baz"}, {key: 5, value: "another string"}]` zurückgeben.
```js
assert.deepEqual(
@@ -55,7 +55,7 @@ assert.deepEqual(
);
```
-`sortByKey([{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 20, name: "Alice"}, {key: 5, name: "Harry"}])` should return `[{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 5, name: "Harry"}, {key: 20, name: "Alice"}]`.
+`sortByKey([{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 20, name: "Alice"}, {key: 5, name: "Harry"}])` sollte `[{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 5, name: "Harry"}, {key: 20, name: "Alice"}]` zurückgeben.
```js
assert.deepEqual(
@@ -74,7 +74,7 @@ assert.deepEqual(
);
```
-`sortByKey([{key: 2341, name: "Adam"}, {key: 122, name: "Bernie"}, {key: 19, name: "David"}, {key: 5531, name: "Joe"}, {key: 1234, name: "Walter"}])` should return `[{key: 19, name: "David"}, {key: 122, name: "Bernie"}, {key: 1234, name: "Walter"}, {key: 2341, name: "Adam"}, {key: 5531, name: "Joe"}]`.
+`sortByKey([{key: 2341, name: "Adam"}, {key: 122, name: "Bernie"}, {key: 19, name: "David"}, {key: 5531, name: "Joe"}, {key: 1234, name: "Walter"}])` sollte `[{key: 19, name: "David"}, {key: 122, name: "Bernie"}, {key: 1234, name: "Walter"}, {key: 2341, name: "Adam"}, {key: 5531, name: "Joe"}]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-disjoint-sublist.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-disjoint-sublist.md
index 8f1ef877e53..a3e12a1e55f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-disjoint-sublist.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-disjoint-sublist.md
@@ -24,19 +24,19 @@ Where the correct result would be:
# --hints--
-`sortDisjoint` should be a function.
+`sortDisjoint` sollte eine Funktion sein.
```js
assert(typeof sortDisjoint == 'function');
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return an array.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])));
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return `[7, 0, 5, 4, 3, 2, 1, 6]`.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` sollte `[7, 0, 5, 4, 3, 2, 1, 6]` zurückgeben.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
@@ -51,7 +51,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
]);
```
-`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` should return `[7, 1, 2, 4, 3, 5, 6, 0]`.
+`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` sollte `[7, 1, 2, 4, 3, 5, 6, 0]` zurückgeben.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
@@ -66,7 +66,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
]);
```
-`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` should return `[8, 1, 6, 5, 4, 3, 2, 7]`.
+`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` sollte `[8, 1, 6, 5, 4, 3, 2, 7]` zurückgeben.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
@@ -81,7 +81,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
]);
```
-`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` should return `[8, 2, 6, 3, 4, 5, 7, 1]`.
+`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` sollte `[8, 2, 6, 3, 4, 5, 7, 1]` zurückgeben.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
@@ -96,7 +96,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
]);
```
-`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` should return `[6, 1, 7, 1, 3, 5, 6]`.
+`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` sollte `[6, 1, 7, 1, 3, 5, 6]` zurückgeben.
```js
assert.deepEqual(sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-stability.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-stability.md
index 0820e0c2d77..66d8ffcf3d5 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-stability.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-stability.md
@@ -26,13 +26,13 @@ Write a function that takes a 2D array as a parameter. Each element has 2 elemen
# --hints--
-`stableSort` should be a function.
+`stableSort` sollte eine Funktion sein.
```js
assert(typeof stableSort == 'function');
```
-`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return an array.
+`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` sollte ein Array zurückgeben.
```js
assert(
@@ -47,7 +47,7 @@ assert(
);
```
-`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]`.
+`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` sollte `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]` zurückgeben.
```js
assert.deepEqual(
@@ -66,7 +66,7 @@ assert.deepEqual(
);
```
-`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` should return `[[2, 2], [1, 2], [1, 4], [1, 5]]`.
+`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` sollte `[[2, 2], [1, 2], [1, 4], [1, 5]]` zurückgeben.
```js
assert.deepEqual(
@@ -85,7 +85,7 @@ assert.deepEqual(
);
```
-`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` should return `[[12, 45], [11, 45], [32, 45], [11, 55]]`.
+`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` sollte `[[12, 45], [11, 45], [32, 45], [11, 55]]` zurückgeben.
```js
assert.deepEqual(
@@ -104,7 +104,7 @@ assert.deepEqual(
);
```
-`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` should return `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]`.
+`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` sollte `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]` zurückgeben.
```js
assert.deepEqual(
@@ -125,7 +125,7 @@ assert.deepEqual(
);
```
-`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` should return `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]`.
+`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` sollte `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md
index 175dd475233..d17907a2e67 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md
@@ -12,13 +12,13 @@ Write a function to sort an array (or list) of strings in order of descending le
# --hints--
-`lengthSorter` should be a function.
+`lengthSorter` sollte eine Funktion sein.
```js
assert(typeof lengthSorter == 'function');
```
-`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return an array.
+`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` sollte ein Array zurückgeben.
```js
assert(
@@ -37,7 +37,7 @@ assert(
);
```
-`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return `["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]`.
+`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` sollte `["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]` zurückgeben.
```js
assert.deepEqual(
@@ -55,7 +55,7 @@ assert.deepEqual(
);
```
-`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` should return `["going", "good", "hope", "your", "day", "is", "?","I"]`.
+`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` sollte `["going", "good", "hope", "your", "day", "is", "?","I"]` zurückgeben.
```js
assert.deepEqual(
@@ -64,7 +64,7 @@ assert.deepEqual(
);
```
-`lengthSorter(["Mine", "is", "going", "great"])` should return `["going", "great", "Mine", "is"]`.
+`lengthSorter(["Mine", "is", "going", "great"])` sollte `["going", "great", "Mine", "is"]` zurückgeben.
```js
assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [
@@ -75,7 +75,7 @@ assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [
]);
```
-`lengthSorter(["Have", "fun", "sorting", "!!"])` should return `["sorting", "Have", "fun", "!!"]`.
+`lengthSorter(["Have", "fun", "sorting", "!!"])` sollte `["sorting", "Have", "fun", "!!"]` zurückgeben.
```js
assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [
@@ -86,7 +86,7 @@ assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [
]);
```
-`lengthSorter(["Everything", "is", "good", "!!"])` should return `["Everything", "good", "!!", "is"]`.
+`lengthSorter(["Everything", "is", "good", "!!"])` sollte `["Everything", "good", "!!", "is"]` zurückgeben.
```js
assert.deepEqual(lengthSorter(['Everything', 'is', 'good', '!!']), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md
index 302bb1e6654..1b0f78ac110 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md
@@ -18,7 +18,7 @@ Sort an array of positive integers using the Bead Sort Algorithm.
# --hints--
-`beadSort` should be a function.
+`beadSort` sollte eine Funktion sein.
```js
assert(typeof beadSort == 'function');
@@ -30,25 +30,25 @@ assert(typeof beadSort == 'function');
assert(Array.isArray(beadSort([25, 32, 12, 7, 20])));
```
-`beadSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`beadSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(beadSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`beadSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`beadSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(beadSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`beadSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`beadSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(beadSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`beadSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`beadSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -62,7 +62,7 @@ assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`beadSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`beadSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(beadSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md
index a8b51f55fac..e06dd6db696 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md
@@ -27,37 +27,37 @@ Pseudocode:
# --hints--
-`bogosort` should be a function.
+`bogosort` sollte eine Funktion sein.
```js
assert(typeof bogosort == 'function');
```
-`bogosort([25, 32, 12, 7, 20])` should return an array.
+`bogosort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(bogosort([25, 32, 12, 7, 20])));
```
-`bogosort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`bogosort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(bogosort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`bogosort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`bogosort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(bogosort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`bogosort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`bogosort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(bogosort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`bogosort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`bogosort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
@@ -71,7 +71,7 @@ assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`bogosort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`bogosort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(bogosort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
index 9f8a3bcb821..74e64093844 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
@@ -16,37 +16,37 @@ Write a function that sorts a given array using cocktail sort.
# --hints--
-`cocktailSort` should be a function.
+`cocktailSort` sollte eine Funktion sein.
```js
assert(typeof cocktailSort == 'function');
```
-`cocktailSort([25, 32, 12, 7, 20])` should return an array.
+`cocktailSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(cocktailSort([25, 32, 12, 7, 20])));
```
-`cocktailSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`cocktailSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(cocktailSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`cocktailSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`cocktailSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(cocktailSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`cocktailSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`cocktailSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(cocktailSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`cocktailSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`cocktailSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -60,7 +60,7 @@ assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`cocktailSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`cocktailSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(cocktailSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
index 5f19360a31f..1121301279b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
@@ -57,7 +57,7 @@ Write a function that sorts a given array using Comb sort.
# --hints--
-`combSort` should be a function.
+`combSort` sollte eine Funktion sein.
```js
assert(typeof combSort == 'function');
@@ -69,25 +69,25 @@ assert(typeof combSort == 'function');
assert(Array.isArray(combSort([25, 32, 12, 7, 20])));
```
-`combSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`combSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(combSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`combSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`combSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(combSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`combSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`combSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(combSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`combSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`combSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -101,7 +101,7 @@ assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`combSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`combSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(combSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md
index c0315d5275f..fff632aad8d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md
@@ -37,37 +37,37 @@ Write a function to implement the above pseudo code. The function should return
# --hints--
-`gnomeSort` should be a function.
+`gnomeSort` sollte eine Funktion sein.
```js
assert(typeof gnomeSort == 'function');
```
-`gnomeSort([25, 32, 12, 7, 20])` should return an array.
+`gnomeSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(gnomeSort([25, 32, 12, 7, 20])));
```
-`gnomeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`gnomeSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(gnomeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`gnomeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`gnomeSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(gnomeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`gnomeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`gnomeSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(gnomeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`gnomeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`gnomeSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -81,7 +81,7 @@ assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`gnomeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`gnomeSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(gnomeSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md
index f93ad1aac07..dc9f7a6a60c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md
@@ -12,9 +12,9 @@ Write a function to sort an array of integers (of any convenient size) into asce
In short, instead of individual elements being sorted, the only operation allowed is to "flip" one end of the list, like so:
-
Before:
+Vorher:
6 7 8 9 2 5 3 4 1
-After:
+Nachher:
9 8 7 6 2 5 3 4 1
@@ -22,7 +22,7 @@ Only one end of the list can be flipped; this should be the low end, but the hig
# --hints--
-`pancakeSort` should be a function.
+`pancakeSort` sollte eine Funktion sein.
```js
assert(typeof pancakeSort == 'function');
@@ -34,25 +34,25 @@ assert(typeof pancakeSort == 'function');
assert(Array.isArray(pancakeSort([25, 32, 12, 7, 20])));
```
-`pancakeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`pancakeSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(pancakeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`pancakeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`pancakeSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(pancakeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`pancakeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`pancakeSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(pancakeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`pancakeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`pancakeSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -66,7 +66,7 @@ assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`pancakeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`pancakeSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(pancakeSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md
index f6bd959a068..d8a8fb3fb67 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md
@@ -19,37 +19,37 @@ Pseudocode:
# --hints--
-`permutationSort` should be a function.
+`permutationSort` sollte eine Funktion sein.
```js
assert(typeof permutationSort == 'function');
```
-`permutationSort([25, 32, 12, 7, 20])` should return an array.
+`permutationSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(permutationSort([25, 32, 12, 7, 20])));
```
-`permutationSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`permutationSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(permutationSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`permutationSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`permutationSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(permutationSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`permutationSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`permutationSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(permutationSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`permutationSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`permutationSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -63,7 +63,7 @@ assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`permutationSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`permutationSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(permutationSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md
index 53f76a0a3a2..1a29842b5a6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md
@@ -22,37 +22,37 @@ Empirical studies have shown a geometric increment sequence with a ratio of abou
# --hints--
-`shellSort` should be a function.
+`shellSort` sollte eine Funktion sein.
```js
assert(typeof shellSort == 'function');
```
-`shellSort([25, 32, 12, 7, 20])` should return an array.
+`shellSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(shellSort([25, 32, 12, 7, 20])));
```
-`shellSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`shellSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(shellSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`shellSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`shellSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(shellSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`shellSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`shellSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(shellSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`shellSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`shellSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -66,7 +66,7 @@ assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`shellSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`shellSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(shellSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md
index 23819a80eb9..3758ceac5e4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md
@@ -25,37 +25,37 @@ The Stooge Sort algorithm is as follows:
# --hints--
-`stoogeSort` should be a function.
+`stoogeSort` sollte eine Funktion zurückgeben.
```js
assert(typeof stoogeSort == 'function');
```
-`stoogeSort([25, 32, 12, 7, 20])` should return an array.
+`stoogeSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(stoogeSort([25, 32, 12, 7, 20])));
```
-`stoogeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`stoogeSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(stoogeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`stoogeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`stoogeSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(stoogeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`stoogeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`stoogeSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(stoogeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`stoogeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`stoogeSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -69,7 +69,7 @@ assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`stoogeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`stoogeSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(stoogeSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md
index af66009395b..d305cce94f4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md
@@ -26,37 +26,37 @@ Write a function to sort an array using the **Strand sort**. The function should
# --hints--
-`strandSort` should be a function.
+`strandSort` sollte eine Funktion sein.
```js
assert(typeof strandSort == 'function');
```
-`strandSort([25, 32, 12, 7, 20])` should return an array.
+`strandSort([25, 32, 12, 7, 20])` sollte ein Array zurückgeben.
```js
assert(Array.isArray(strandSort([25, 32, 12, 7, 20])));
```
-`strandSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
+`strandSort([25, 32, 12, 7, 20])` sollte `[7, 12, 20, 25, 32]` zurückgeben.
```js
assert.deepEqual(strandSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
-`strandSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
+`strandSort([38, 45, 35, 8, 13])` sollte `[8, 13, 35, 38, 45]` zurückgeben.
```js
assert.deepEqual(strandSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
-`strandSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
+`strandSort([43, 36, 20, 34, 24])` sollte `[20, 24, 34, 36, 43]` zurückgeben.
```js
assert.deepEqual(strandSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
-`strandSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
+`strandSort([12, 33, 26, 18, 1, 16, 38])` sollte `[1, 12, 16, 18, 26, 33, 38]` zurückgeben.
```js
assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [
@@ -70,7 +70,7 @@ assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
-`strandSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
+`strandSort([3, 39, 48, 16, 1, 4, 29])` sollte `[1, 3, 4, 16, 29, 39, 48]` zurückgeben.
```js
assert.deepEqual(strandSort([3, 39, 48, 16, 1, 4, 29]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/soundex.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/soundex.md
index b51c5bc6b71..8194d6e955d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/soundex.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/soundex.md
@@ -12,13 +12,13 @@ dashedName: soundex
It is used for searching names and addresses. This means that the person who filled in the name, can focus on how it sounds instead of correcting the spelling of names.
-For example:
+Zum Beispiel:
If you are hearing the name `Quenci` for the first time, and misspelled it, you will get **Soundex** code `Q520`.
When you spell the name `Quincy` correctly next time, you will still get the same code `Q520`, which means you can link multiple name pronunciations into the same person without the need for adding every spelling.
-Here is the rules:
+Hier sind die Regeln:
- If a vowel (A, E, I, O, U) separates two consonants that have the same soundex code, the consonant to the right of the vowel is coded. Tymczak is coded as T-522 (T, 5 for the M, 2 for the C, Z ignored (see "Side-by-Side" rule above), 2 for the K). Since the vowel "A" separates the Z and K, the K is coded.
@@ -31,73 +31,73 @@ Write a function that takes a string as a parameter and returns the encoded stri
# --hints--
-`soundex` should be a function.
+`soundex` sollte eine Funktion sein.
```js
assert(typeof soundex == 'function');
```
-`soundex("Soundex")` should return a string.
+`soundex("Soundex")` sollte einen String zurückgeben.
```js
assert(typeof soundex('Soundex') == 'string');
```
-`soundex("Soundex")` should return `"S532"`.
+`soundex("Soundex")` sollte `"S532"` zurückgeben.
```js
assert.equal(soundex('Soundex'), 'S532');
```
-`soundex("Example")` should return `"E251"`.
+`soundex("Example")` sollte `"E251"` zurückgeben.
```js
assert.equal(soundex('Example'), 'E251');
```
-`soundex("Sownteks")` should return `"S532"`.
+`soundex("Sownteks")` sollte `"S532"` zurückgeben.
```js
assert.equal(soundex('Sownteks'), 'S532');
```
-`soundex("Ekzampul")` should return `"E251"`.
+`soundex("Ekzampul")` sollte `"E251"` zurückgeben.
```js
assert.equal(soundex('Ekzampul'), 'E251');
```
-`soundex("Euler")` should return `"E460"`.
+`soundex("Euler")` sollte `"E460"` zurückgeben.
```js
assert.equal(soundex('Euler'), 'E460');
```
-`soundex("Gauss")` should return `"G200"`.
+`soundex("Gauss")` sollte `"G200"` zurückgeben.
```js
assert.equal(soundex('Gauss'), 'G200');
```
-`soundex("Hilbert")` should return `"H416"`.
+`soundex("Hilbert")` sollte `"H416"` zurückgeben.
```js
assert.equal(soundex('Hilbert'), 'H416');
```
-`soundex("Knuth")` should return `"K530"`.
+`soundex("Knuth")` sollte `"K530"` zurückgeben.
```js
assert.equal(soundex('Knuth'), 'K530');
```
-`soundex("Lloyd")` should return `"L300"`.
+`soundex("Lloyd")` sollte `"L300"` zurückgeben.
```js
assert.equal(soundex('Lloyd'), 'L300');
```
-`soundex("Lukasiewicz")` should return `"L222"`.
+`soundex("Lukasiewicz")` sollte `"L222"` zurückgeben.
```js
assert.equal(soundex('Lukasiewicz'), 'L222');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/spiral-matrix.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/spiral-matrix.md
index fbdd024181b..04b0c638060 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/spiral-matrix.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/spiral-matrix.md
@@ -20,19 +20,19 @@ Produce a spiral array. A *spiral array* is a square arrangement of the first N<
# --hints--
-`spiralArray` should be a function.
+`spiralArray` sollte eine Funktion sein.
```js
assert(typeof spiralArray == 'function');
```
-`spiralArray(3)` should return an array.
+`spiralArray(3)` sollte ein Array zurückgeben.
```js
assert(Array.isArray(spiralArray(3)));
```
-`spiralArray(3)` should return `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]`.
+`spiralArray(3)` sollte `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]` zurückgeben.
```js
assert.deepEqual(spiralArray(3), [
@@ -42,7 +42,7 @@ assert.deepEqual(spiralArray(3), [
]);
```
-`spiralArray(4)` should return `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]`.
+`spiralArray(4)` sollte `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]` zurückgeben.
```js
assert.deepEqual(spiralArray(4), [
@@ -53,7 +53,7 @@ assert.deepEqual(spiralArray(4), [
]);
```
-`spiralArray(5)` should return `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]`.
+`spiralArray(5)` sollte `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]` zurückgeben.
```js
assert.deepEqual(spiralArray(5), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md
index 5a7cd85889d..12e77dccdf1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md
@@ -22,25 +22,25 @@ should be split as:
# --hints--
-`split` should be a function.
+`split` sollte eine Funktion sein.
```js
assert(typeof split == 'function');
```
-`split("hello")` should return an array.
+`split("hello")` sollte ein Array zurückgeben.
```js
assert(Array.isArray(split('hello')));
```
-`split("hello")` should return `["h", "e", "ll", "o"]`.
+`split("hello")` sollte `["h", "e", "ll", "o"]` zurückgeben.
```js
assert.deepEqual(split('hello'), ['h', 'e', 'll', 'o']);
```
-`split("commission")` should return `["c", "o", "mm", "i", "ss", "i", "o", "n"]`.
+`split("commission")` sollte `["c", "o", "mm", "i", "ss", "i", "o", "n"]` zurückgeben.
```js
assert.deepEqual(split('commission'), [
@@ -55,7 +55,7 @@ assert.deepEqual(split('commission'), [
]);
```
-`split("ssss----====llloooo")` should return `["ssss", "----", "====", "lll", "oooo"]`.
+`split("ssss----====llloooo")` sollte `["ssss", "----", "====", "lll", "oooo"]` zurückgeben.
```js
assert.deepEqual(split('ssss----====llloooo'), [
@@ -67,7 +67,7 @@ assert.deepEqual(split('ssss----====llloooo'), [
]);
```
-`split("sssmmmaaammmaaat")` should return `["sss", "mmm", "aaa", "mmm", "aaa", "t"]`.
+`split("sssmmmaaammmaaat")` sollte `["sss", "mmm", "aaa", "mmm", "aaa", "t"]` zurückgeben.
```js
assert.deepEqual(split('sssmmmaaammmaaat'), [
@@ -80,7 +80,7 @@ assert.deepEqual(split('sssmmmaaammmaaat'), [
]);
```
-`split("gHHH5YY++///\\")` should return `["g", "HHH", "5", "YY", "++", "///", "\\"]`.
+`split("gHHH5YY++///\\")` sollte `["g", "HHH", "5", "YY", "++", "///", "\\"]` zurückgeben.
```js
assert.deepEqual(split('gHHH5YY++///\\'), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/state-name-puzzle.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
index 6ae83d11ec1..faf7e74f9a1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
@@ -15,17 +15,17 @@ dashedName: state-name-puzzle
Write a function to solve the challenge for a given array of actual U.S. state names, and for fictional state names.
-The function should return an array. Each element should be an object in this form: `{"from":[],"to":[]}`. The `from` array should contain the original names and the `to` array should contain the resultant names.
+Die Funktion sollte ein Array zurückgeben. Each element should be an object in this form: `{"from":[],"to":[]}`. The `from` array should contain the original names and the `to` array should contain the resultant names.
# --hints--
-`solve` should be a function.
+`solve` sollte eine Funktion sein.
```js
assert(typeof solve == 'function');
```
-`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return an array.
+`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` sollte ein Array zurückgeben.
```js
assert(
@@ -47,7 +47,7 @@ assert(
);
```
-`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]`.
+`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` sollte `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]` zurückgeben.
```js
assert.deepEqual(
@@ -73,7 +73,7 @@ assert.deepEqual(
);
```
-`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` should return `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]`.
+`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` sollte `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md
index a0030994da2..d8408963e12 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stern-brocot-sequence.md
@@ -40,43 +40,43 @@ Create a function that returns the position in the Stern-Brocot sequence at whic
# --hints--
-`sternBrocot` should be a function.
+`sternBrocot` sollte eine Funktion sein.
```js
assert(typeof sternBrocot == 'function');
```
-`sternBrocot(2)` should return a number.
+`sternBrocot(2)` sollte eine Zahl zurückgeben.
```js
assert(typeof sternBrocot(2) == 'number');
```
-`sternBrocot(2)` should return `3`.
+`sternBrocot(2)` sollte `3` zurückgeben.
```js
assert.equal(sternBrocot(2), 3);
```
-`sternBrocot(3)` should return `5`.
+`sternBrocot(3)` sollte `5` zurückgeben.
```js
assert.equal(sternBrocot(3), 5);
```
-`sternBrocot(5)` should return `11`.
+`sternBrocot(5)` sollte `11` zurückgeben.
```js
assert.equal(sternBrocot(5), 11);
```
-`sternBrocot(7)` should return `19`.
+`sternBrocot(7)` sollte `19` zurückgeben.
```js
assert.equal(sternBrocot(7), 19);
```
-`sternBrocot(10)` should return `39`.
+`sternBrocot(10)` sollte `39` zurückgeben.
```js
assert.equal(sternBrocot(10), 39);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md
index 6181ad81245..b54daada999 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md
@@ -18,13 +18,13 @@ This should be reversed for decryption with the `unstraddle()` function.
# --hints--
-`straddle` should be a function.
+`straddle` sollte eine Funktion sein.
```js
assert(typeof straddle == 'function');
```
-`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string.
+`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` sollte einen String zurückgeben.
```js
assert(
@@ -35,7 +35,7 @@ assert(
);
```
-`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"34045747525284613427502840425027537379697175891898898898584619028294547488"`.
+`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` sollte `"34045747525284613427502840425027537379697175891898898898584619028294547488"` zurückgeben.
```js
assert.equal(
@@ -47,7 +47,7 @@ assert.equal(
);
```
-`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"`.
+`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` sollte `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"` zurückgeben.
```js
assert.equal(
@@ -60,7 +60,7 @@ assert.equal(
);
```
-`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"`.
+`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` sollte `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"` zurückgeben.
```js
assert.equal(
@@ -73,13 +73,13 @@ assert.equal(
);
```
-`unstraddle` should be a function.
+`unstraddle` sollte eine Funktion sein.
```js
assert(typeof unstraddle == 'function');
```
-`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string.
+`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` sollte einen String zurückgeben.
```js
assert(
@@ -90,7 +90,7 @@ assert(
);
```
-`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."`.
+`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` sollte `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."` zurückgeben.
```js
assert.equal(
@@ -102,7 +102,7 @@ assert.equal(
);
```
-`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"`.
+`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` sollte `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"` zurückgeben.
```js
assert.equal(
@@ -114,7 +114,7 @@ assert.equal(
);
```
-`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."`.
+`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` sollte `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stream-merge.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stream-merge.md
index 9e2c93138d7..b5a0e0dcdbb 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stream-merge.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/stream-merge.md
@@ -12,13 +12,13 @@ Write a function that takes multiple sorted arrays of items, and returns one arr
# --hints--
-`mergeLists` should be a function.
+`mergeLists` sollte eine Funktion sein.
```js
assert(typeof mergeLists == 'function');
```
-`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return an array.
+`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` sollte ein Array zurückgeben.
```js
assert(
@@ -31,7 +31,7 @@ assert(
);
```
-`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`.
+`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` sollte `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` zurückgeben.
```js
assert.deepEqual(
@@ -43,7 +43,7 @@ assert.deepEqual(
);
```
-`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`.
+`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` sollte `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]` zurückgeben.
```js
assert.deepEqual(
@@ -56,7 +56,7 @@ assert.deepEqual(
);
```
-`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` should return `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]`.
+`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` sollte `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]` zurückgeben.
```js
assert.deepEqual(
@@ -69,7 +69,7 @@ assert.deepEqual(
);
```
-`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` should return `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]`.
+`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` sollte `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]` zurückgeben.
```js
assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [
@@ -86,7 +86,7 @@ assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [
]);
```
-`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` should return `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]`.
+`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` sollte `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md
index 5207f260b42..c1acac2e2f7 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md
@@ -12,43 +12,43 @@ The task is to strip control codes and extended characters from a string. The so
# --hints--
-`strip` should be a function.
+`strip` sollte eine Funktion sein.
```js
assert(typeof strip == 'function');
```
-`strip("abc")` should return a string.
+`strip("abc")` sollte einen String zurückgeben.
```js
assert(typeof strip('abc') == 'string');
```
-`strip("\ba\x00b\n\rc\fd\xc3")` should return `"abcd"`.
+`strip("\ba\x00b\n\rc\fd\xc3")` sollte `"abcd"` zurückgeben.
```js
assert.equal(strip('\ba\x00b\n\rc\fd\xc3'), 'abcd');
```
-`strip("\u0000\n abc\u00E9def\u007F")` should return `" abcdef"`.
+`strip("\u0000\n abc\u00E9def\u007F")` sollte `" abcdef"` zurückgeben.
```js
assert.equal(strip('\u0000\n abc\u00E9def\u007F'), ' abcdef');
```
-`strip("a\n\tb\u2102d\u2147f")` should return `"abdf"`.
+`strip("a\n\tb\u2102d\u2147f")` sollte `"abdf"` zurückgeben.
```js
assert.equal(strip('a\n\tb\u2102d\u2147f'), 'abdf');
```
-`strip("Français.")` should return `"Franais."`.
+`strip("Français.")` sollte `"Franais."` zurückgeben.
```js
assert.equal(strip('Français.'), 'Franais.');
```
-`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` should return `"123abcDEF+-*/"`.
+`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` sollte `"123abcDEF+-*/"` zurückgeben.
```js
assert.equal(strip('123\tabc\u0007DEF\u007F+-*/€æŧðłþ'), '123abcDEF+-*/');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/subleq.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/subleq.md
index 1dc7987cf77..62eeee911a9 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/subleq.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/subleq.md
@@ -54,13 +54,13 @@ Write a function that takes an array of integers as a parameter. This represents
# --hints--
-`Subleq` should be a function.
+`Subleq` sollte eine Funktion sein.
```js
assert(typeof Subleq == 'function');
```
-`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return a string.
+`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` sollte einen String zurückgeben.
```js
assert(
@@ -100,7 +100,7 @@ assert(
);
```
-`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return `"Hello, world!"`.
+`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` sollte `"Hello, world!"` zurückgeben.
```js
assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sudoku.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sudoku.md
index 01bdc0854df..b5816f2aac2 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sudoku.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sudoku.md
@@ -12,13 +12,13 @@ Write a function to solve a partially filled-in normal 9x9 Sudoku grid and retur
# --hints--
-`solveSudoku` should be a function.
+`solveSudoku` sollte eine Funktion sein.
```js
assert(typeof solveSudoku == 'function');
```
-`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return an array.
+`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` sollte einen Array zurückgeben.
```js
assert(
@@ -38,7 +38,7 @@ assert(
);
```
-`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`.
+`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` sollte folgendes Ergebnis zurückgeben: `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`.
```js
assert.deepEqual(
@@ -67,7 +67,7 @@ assert.deepEqual(
);
```
-`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` should return `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`.
+`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` sollte folgendes Ergebnis zurückgeben `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`.
```js
assert.deepEqual(
@@ -96,7 +96,7 @@ assert.deepEqual(
);
```
-`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` should return `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`.
+`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` sollte folgendes Ergebnis zurückgeben `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md
index 077d606d4c7..37862662096 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md
@@ -19,49 +19,49 @@ Write a function that takes a string as a parameter. This string represents a nu
# --hints--
-`sumDigits` should be a function.
+`sumDigits` sollte eine Funktion sein.
```js
assert(typeof sumDigits == 'function');
```
-`sumDigits("1")` should return a number.
+`sumDigits("1")` sollte eine Zahl zurückgeben.
```js
assert(typeof sumDigits('1') == 'number');
```
-`sumDigits("1")` should return `1`.
+`sumDigits("1")` sollte `1` zurückgeben.
```js
assert.equal(sumDigits('1'), 1);
```
-`sumDigits("12345")` should return `15`.
+`sumDigits("12345")` sollte `15` zurückgeben.
```js
assert.equal(sumDigits('12345'), 15);
```
-`sumDigits("254")` should return `11`.
+`sumDigits("254")` sollte `11` zurückgeben.
```js
assert.equal(sumDigits('254'), 11);
```
-`sumDigits("fe")` should return `29`.
+`sumDigits("fe")` sollte `29` zurückgeben.
```js
assert.equal(sumDigits('fe'), 29);
```
-`sumDigits("f0e")` should return `29`.
+`sumDigits("f0e")` sollte `29` zurückgeben.
```js
assert.equal(sumDigits('f0e'), 29);
```
-`sumDigits("999ABCXYZ")` should return `162`.
+`sumDigits("999ABCXYZ")` sollte `162` zurückgeben.
```js
assert.equal(sumDigits('999ABCXYZ'), 162);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md
index d5f7e93da8f..0a629c0b33b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md
@@ -12,43 +12,43 @@ The objective is to write a function that finds the sum of all positive multiple
# --hints--
-`sumMults` should be a function.
+`sumMults` sollte eine Funktion sein.
```js
assert(typeof sumMults == 'function');
```
-`sumMults(10)` should return a number.
+`sumMults(10)` sollte eine Zahl zurückgeben.
```js
assert(typeof sumMults(10) == 'number');
```
-`sumMults(10)` should return `23`.
+`sumMults(10)` sollte `23` zurückgeben.
```js
assert.equal(sumMults(10), 23);
```
-`sumMults(100)` should return `2318`.
+`sumMults(100)` sollte `2318` zurückgeben.
```js
assert.equal(sumMults(100), 2318);
```
-`sumMults(1000)` should return `233168`.
+`sumMults(1000)` sollte `233168` zurückgeben.
```js
assert.equal(sumMults(1000), 233168);
```
-`sumMults(10000)` should return `23331668`.
+`sumMults(10000)` sollte `23331668` zurückgeben.
```js
assert.equal(sumMults(10000), 23331668);
```
-`sumMults(100000)` should return `2333316668`.
+`sumMults(100000)` sollte `2333316668` zurückgeben.
```js
assert.equal(sumMults(100000), 2333316668);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-a-series.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-a-series.md
index 7d649eee959..f3de04dd732 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-a-series.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-a-series.md
@@ -16,43 +16,43 @@ Write a function that take $a$ and $b$ as parameters and returns the sum of $a^{
# --hints--
-`sum` should be a function.
+`sum` sollte eine Funktion sein.
```js
assert(typeof sum == 'function');
```
-`sum(1, 100)` should return a number.
+`sum(1, 100)` sollte eine Zahl zurückgeben.
```js
assert(typeof sum(1, 100) == 'number');
```
-`sum(1, 100)` should return `1.6349839001848923`.
+`sum(1, 100)` sollte `1.6349839001848923` zurückgeben.
```js
assert.equal(sum(1, 100), 1.6349839001848923);
```
-`sum(33, 46)` should return `0.009262256361481223`.
+`sum(33, 46)` sollte `0.009262256361481223` zurückgeben.
```js
assert.equal(sum(33, 46), 0.009262256361481223);
```
-`sum(21, 213)` should return `0.044086990748706555`.
+`sum(21, 213)` sollte `0.044086990748706555` zurückgeben.
```js
assert.equal(sum(21, 213), 0.044086990748706555);
```
-`sum(11, 111)` should return `0.08619778593108679`.
+`sum(11, 111)` sollte `0.08619778593108679` zurückgeben.
```js
assert.equal(sum(11, 111), 0.08619778593108679);
```
-`sum(1, 10)` should return `1.5497677311665408`.
+`sum(1, 10)` sollte `1.5497677311665408` zurückgeben.
```js
assert.equal(sum(1, 10), 1.5497677311665408);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-squares.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-squares.md
index ee55a5bfea5..04f26804bf1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-squares.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-of-squares.md
@@ -12,43 +12,43 @@ Write a function to find the sum of squares of an array of integers.
# --hints--
-`sumsq` should be a function.
+`sumsq` sollte eine Funktion sein.
```js
assert(typeof sumsq == 'function');
```
-`sumsq([1, 2, 3, 4, 5])` should return a number.
+`sumsq([1, 2, 3, 4, 5])` sollte eine Zahl zurückgeben.
```js
assert(typeof sumsq([1, 2, 3, 4, 5]) == 'number');
```
-`sumsq([1, 2, 3, 4, 5])` should return `55`.
+`sumsq([1, 2, 3, 4, 5])` sollte `55` zurückgeben.
```js
assert.equal(sumsq([1, 2, 3, 4, 5]), 55);
```
-`sumsq([25, 32, 12, 7, 20])` should return `2242`.
+`sumsq([25, 32, 12, 7, 20])` sollte `2242` zurückgeben.
```js
assert.equal(sumsq([25, 32, 12, 7, 20]), 2242);
```
-`sumsq([38, 45, 35, 8, 13])` should return `4927`.
+`sumsq([38, 45, 35, 8, 13])` sollte `4927` zurückgeben.
```js
assert.equal(sumsq([38, 45, 35, 8, 13]), 4927);
```
-`sumsq([43, 36, 20, 34, 24])` should return `5277`.
+`sumsq([43, 36, 20, 34, 24])` sollte `5277` zurückgeben.
```js
assert.equal(sumsq([43, 36, 20, 34, 24]), 5277);
```
-`sumsq([12, 33, 26, 18, 1, 16, 3])` should return `2499`.
+`sumsq([12, 33, 26, 18, 1, 16, 3])` sollte `2499` zurückgeben.
```js
assert.equal(sumsq([12, 33, 26, 18, 1, 16, 3]), 2499);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-to-100.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-to-100.md
index e616195233d..ed3c212a729 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-to-100.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sum-to-100.md
@@ -12,29 +12,29 @@ Find solutions to the *sum to one hundred* puzzle.
Add (insert) the mathematical operators **+** or **─** (plus or minus) before any of the digits in the decimal numeric string **123456789** such that the resulting mathematical expression adds up to a particular sum (in this iconic case, **100**).
-Example:
+Beispiel:
123 + 4 - 5 + 67 - 89 = 100
# --instructions--
-Write a function that takes a number as parameter. The function should return an array containing all solutions for the given number. The solutions should be strings representing the expressions. For example: "1+23-456+78-9". Sort the array before returning it.
+Write a function that takes a number as parameter. The function should return an array containing all solutions for the given number. The solutions should be strings representing the expressions. Zum Beispiel: "1+23-456+78-9". Sort the array before returning it.
# --hints--
-`sumTo100` should be a function.
+`sumTo100` sollte eine Funktion sein.
```js
assert(typeof sumTo100 == 'function');
```
-`sumTo100(199)` should return an array.
+`sumTo100(199)` sollte ein Array zurückgeben.
```js
assert(Array.isArray(sumTo100(199)));
```
-`sumTo100(199)` should return `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]`.
+`sumTo100(199)` sollte `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]` zurückgeben.
```js
assert.deepEqual(sumTo100(199), [
@@ -44,13 +44,13 @@ assert.deepEqual(sumTo100(199), [
]);
```
-`sumTo100(209)` should return `["1+234+56+7-89"]`.
+`sumTo100(209)` sollte `["1+234+56+7-89"]` zurückgeben.
```js
assert.deepEqual(sumTo100(209), ['1+234+56+7-89']);
```
-`sumTo100(243)` should return `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]`.
+`sumTo100(243)` sollte `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]` zurückgeben.
```js
assert.deepEqual(sumTo100(243), [
@@ -60,7 +60,7 @@ assert.deepEqual(sumTo100(243), [
]);
```
-`sumTo100(197)` should return `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]`.
+`sumTo100(197)` sollte `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]` zurückgeben.
```js
assert.deepEqual(sumTo100(197), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md
index 50ad887d282..5cfb7eb4499 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md
@@ -22,13 +22,13 @@ Write a function that takes 2 arrays as parameters. The first array contains the
# --hints--
-`clip` should be a function.
+`clip` sollte eine Funktion sein.
```js
assert(typeof clip == 'function');
```
-`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return an array.
+`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` sollte ein Array zurückgeben.
```js
assert(
@@ -56,7 +56,7 @@ assert(
);
```
-`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]`.
+`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` sollte `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]` zurückgeben.
```js
assert.deepEqual(
@@ -94,7 +94,7 @@ assert.deepEqual(
);
```
-`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` should return `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]`.
+`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` sollte `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]` zurückgeben.
```js
assert.deepEqual(
@@ -120,7 +120,7 @@ assert.deepEqual(
);
```
-`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` should return `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]`.
+`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` sollte `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]` zurückgeben.
```js
assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/symmetric-difference.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/symmetric-difference.md
index bf8d98a2c7f..24f2b7ee05c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/symmetric-difference.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/symmetric-difference.md
@@ -10,7 +10,7 @@ dashedName: symmetric-difference
Given two sets *A* and *B*, compute $(A \\setminus B) \\cup (B \\setminus A).$ That is, enumerate the items that are in *A* or *B* but not both. This set is called the symmetric difference of *A* and *B*. In other words: $(A \\cup B) \\setminus (A \\cap B)$ (the set of items that are in at least one of *A* or *B* minus the set of items that are in both *A* and *B*).
-Example:
+Beispiel:
For sets `A = [1, 2, 3]`, and `B = [1, 3, 4]`, the symmetric difference of *A* and *B* is `[2, 4]`.
@@ -20,13 +20,13 @@ Write a function that takes two arrays as parameters and returns the symmetric d
# --hints--
-`symmetricDifference` should be a function.
+`symmetricDifference` sollte eine Funktion sein.
```js
assert(typeof symmetricDifference == 'function');
```
-`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return an array.
+`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` sollte ein Array zurückgeben.
```js
assert(
@@ -39,7 +39,7 @@ assert(
);
```
-`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return `["Jim", "Serena"]`.
+`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` sollte `["Jim", "Serena"]` zurückgeben.
```js
assert.deepEqual(
@@ -51,13 +51,13 @@ assert.deepEqual(
);
```
-`symmetricDifference([1, 2, 3], [3, 4])` should return `[1, 2, 4]`.
+`symmetricDifference([1, 2, 3], [3, 4])` sollte `[1, 2, 4]` zurückgeben.
```js
assert.deepEqual(symmetricDifference([1, 2, 3], [3, 4]), [1, 2, 4]);
```
-`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` should return `[1, 2, 5, 7, 8]`.
+`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` sollte `[1, 2, 5, 7, 8]` zurückgeben.
```js
assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [
@@ -69,7 +69,7 @@ assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [
]);
```
-`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` should return `[2, 4, 9]`.
+`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` sollte `[2, 4, 9]` zurückgeben.
```js
assert.deepEqual(
@@ -78,7 +78,7 @@ assert.deepEqual(
);
```
-`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` should return `[1, 3, 4, 8]`.
+`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` sollte `[1, 3, 4, 8]` zurückgeben.
```js
assert.deepEqual(symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/taxicab-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/taxicab-numbers.md
index e968d091577..b081c04948e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/taxicab-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/taxicab-numbers.md
@@ -12,7 +12,7 @@ A taxicab number (the definition that is being used here) is a positive integer
The first taxicab number is `1729`, which is:
-13 + 123 and
+13 + 123 und
93 + 103.
@@ -31,13 +31,13 @@ Write a function that returns the lowest `n` taxicab numbers. For each of the ta
# --hints--
-`taxicabNumbers` should be a function.
+`taxicabNumbers` sollte eine Funktion sein.
```js
assert(typeof taxicabNumbers === 'function');
```
-`taxicabNumbers` should return an array.
+`taxicabNumbers` sollte ein Array zurückgeben.
```js
assert(typeof taxicabNumbers(2) === 'object');
@@ -49,13 +49,13 @@ assert(typeof taxicabNumbers(2) === 'object');
assert(typeof taxicabNumbers(100)[0] === 'number');
```
-`taxicabNumbers(4)` should return [1729, 4104, 13832, 20683].
+`taxicabNumbers(4)` sollte [1729, 4104, 13832, 20683] zurückgeben.
```js
assert.deepEqual(taxicabNumbers(4), res4);
```
-`taxicabNumbers(25)` should return [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597]
+`taxicabNumbers(25)` sollte [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597] zurückgeben
```js
assert.deepEqual(taxicabNumbers(25), res25);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.md
index a95d3927542..8bbf459cca6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.md
@@ -48,25 +48,25 @@ and using `|` as a separator and `^` as escape character, your function should o
# --hints--
-`tokenize` should be a function.
+`tokenize` sollte eine Funktion sein.
```js
assert(typeof tokenize === 'function');
```
-`tokenize` should return an array.
+`tokenize` sollte ein Array zurückgeben.
```js
assert(typeof tokenize('a', 'b', 'c') === 'object');
```
-`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` should return `['one|uno', '', 'three^^', 'four^|cuatro', '']`
+`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` sollte `['one|uno', '', 'three^^', 'four^|cuatro', '']` zurückgeben
```js
assert.deepEqual(tokenize(testStr1, '|', '^'), res1);
```
-`tokenize('a@&bcd&ef&&@@hi', '&', '@')` should return `['a&bcd', 'ef', '', '@hi']`
+`tokenize('a@&bcd&ef&&@@hi', '&', '@')` sollte `['a&bcd', 'ef', '', '@hi']` zurückgeben
```js
assert.deepEqual(tokenize(testStr2, '&', '@'), res2);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/top-rank-per-group.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/top-rank-per-group.md
index b32c3f2a2a6..a5de683b951 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/top-rank-per-group.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/top-rank-per-group.md
@@ -10,7 +10,7 @@ dashedName: top-rank-per-group
Find the top `n` ranked data in each group, where `n` is provided as a parameter. Name of the rank and the group are also provided as parameter.
-Given the following data:
+Gegeben sind die folgenden Daten:
```js
testData1 = [
@@ -80,7 +80,7 @@ Top two ranking employees in each department by salary would be:
# --hints--
-`topRankPerGroup` should be a function.
+`topRankPerGroup` sollte eine Funktion sein.
```js
assert(typeof topRankPerGroup === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/topological-sort.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/topological-sort.md
index 8b9939feb29..8a56aea473f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/topological-sort.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/topological-sort.md
@@ -43,7 +43,7 @@ The compiling of a library in the VHDL language has the constraint that a librar
The input of the function will be a multiline string, each line will consist of the name of the library, followed by its dependencies (if exist).
-For example:
+Zum Beispiel:
```js
const libsSimple =
@@ -53,31 +53,31 @@ const libsSimple =
# --hints--
-`topologicalSort` should be a function.
+`topologicalSort` sollte eine Funktion sein.
```js
assert(typeof topologicalSort === 'function');
```
-`topologicalSort(libsSimple)` should return an array.
+`topologicalSort(libsSimple)` sollte ein Array zurückgeben.
```js
assert(Array.isArray(topologicalSort(libsSimple)));
```
-`topologicalSort(libsSimple)` should return `['bbb', 'aaa']`.
+`topologicalSort(libsSimple)` sollte `['bbb', 'aaa']` zurückgeben.
```js
assert.deepEqual(topologicalSort(libsSimple), ['bbb', 'aaa']);
```
-`topologicalSort(libsVHDL)` should return `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']`.
+`topologicalSort(libsVHDL)` sollte `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']` zurückgeben.
```js
assert.deepEqual(topologicalSort(libsVHDL), ['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']);
```
-`topologicalSort(libsCustom)` should return `['base', 'c', 'd', 'b', 'a']`.
+`topologicalSort(libsCustom)` sollte `['base', 'c', 'd', 'b', 'a']` zurückgeben.
```js
assert.deepEqual(topologicalSort(libsCustom), ['base', 'c', 'd', 'b', 'a']);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md
index 596164f14b5..3d302f465b4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/towers-of-hanoi.md
@@ -18,7 +18,7 @@ Write a function that returns the moves to stack the objects in a nested array.
# --hints--
-`towerOfHanoi` should be a function.
+`towerOfHanoi` sollte eine Funktion sein.
```js
assert(typeof towerOfHanoi === 'function');
@@ -30,7 +30,7 @@ assert(typeof towerOfHanoi === 'function');
assert(res3.length === 7);
```
-`towerOfHanoi(3, 'A', 'B', 'C')` should return `[['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B']]`.
+`towerOfHanoi(3, 'A', 'B', 'C')` sollte `[['A','B'], ['A','C'], ['B','C'], ['A','B'], ['C','A'], ['C','B'], ['A','B']]` zurückgeben.
```js
assert.deepEqual(towerOfHanoi(3, 'A', 'B', 'C'), res3Moves);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-cross-product.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-cross-product.md
index 20dff2183d4..2863999fc51 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-cross-product.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-cross-product.md
@@ -16,19 +16,19 @@ Write a function that takes two vectors (arrays) as input and computes their cro
# --hints--
-`crossProduct` should be a function.
+`crossProduct` sollte eine Funktion sein.
```js
assert.equal(typeof crossProduct, 'function');
```
-`crossProduct()` should return null.
+`crossProduct()` sollte null zurückgeben.
```js
assert.equal(crossProduct(), null);
```
-`crossProduct([1, 2, 3], [4, 5, 6])` should return `[-3, 6, -3]`.
+`crossProduct([1, 2, 3], [4, 5, 6])` sollte `[-3, 6, -3]` zurückgeben.
```js
assert.deepEqual(res12, exp12);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-dot-product.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-dot-product.md
index 447edc27d7f..2574d2cbaed 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-dot-product.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/vector-dot-product.md
@@ -8,7 +8,7 @@ dashedName: vector-dot-product
# --description--
-A vector can have one or more values represented by an ordered collection. Examples could be (x), (x, y), or (x, y, z).
+A vector can have one or more values represented by an ordered collection. Beispiele könnten (x), (x, y) oder (x, y, z) sein.
# --instructions--
@@ -16,43 +16,43 @@ Write a function that takes two vectors (represented as one-dimensional arrays)
# --hints--
-`dotProduct` should be a function.
+`dotProduct` sollte eine Funktion sein.
```js
assert.equal(typeof dotProduct, 'function');
```
-`dotProduct()` should return `null`.
+`dotProduct()` sollte `null` zurückgeben.
```js
assert.equal(dotProduct(), null);
```
-`dotProduct([1], [1])` should return `1`.
+`dotProduct([1], [1])` sollte `1` zurückgeben.
```js
assert.equal(dotProduct([1], [1]), 1);
```
-`dotProduct([1], [1, 2])` should return `null`.
+`dotProduct([1], [1, 2])` sollte `null` zurückgeben.
```js
assert.equal(dotProduct([1], [1, 2]), null);
```
-`dotProduct([1, 3, -5], [4, -2, -1])` should return `3`.
+`dotProduct([1, 3, -5], [4, -2, -1])` sollte `3` zurückgeben.
```js
assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3);
```
-`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` should return `null`.
+`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` sollte `null` zurückgeben.
```js
assert.equal(dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1]), null);
```
-`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` should return `360`.
+`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` sollte `360` zurückgeben.
```js
assert.equal(dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ]), 360);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-frequency.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-frequency.md
index aff883e5d51..6b93fe63758 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-frequency.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-frequency.md
@@ -26,50 +26,50 @@ For example, given the string "Hello hello goodbye", your function should return
# --hints--
-`wordFrequency` should be a function.
+`wordFrequency` sollte eine Funktion sein.
```js
assert(typeof wordFrequency == 'function');
```
-`wordFrequency` should return an array.
+`wordFrequency` sollte ein Array zurückgeben.
```js
assert(Array.isArray(wordFrequency('test')));
```
-`wordFrequency("Hello hello world", 2)` should return `[['hello', 2], ['world', 1]]`
+`wordFrequency("Hello hello world", 2)` sollte `[['hello', 2], ['world', 1]]` zurückgeben
```js
assert.deepEqual(wordFrequency(example_1, 2), example_1_solution);
```
-`wordFrequency("The quick brown fox jumped over the lazy dog", 1)` should return `[['the', 2]]`
+`wordFrequency("The quick brown fox jumped over the lazy dog", 1)` sollte `[['the', 2]]` zurückgeben
```js
assert.deepEqual(wordFrequency(example_2, 1), example_2_solution);
```
-`wordFrequency("Opensource opensource open-source open source", 1)` should return `[['opensource', 2]]`
+`wordFrequency("Opensource opensource open-source open source", 1)` sollte `[['opensource', 2]]` zurückgeben
```js
assert.deepEqual(wordFrequency(example_3, 1), example_3_solution);
```
-`wordFrequency("Apple App apply aPP aPPlE", 3)` should return `[['app', 2], ['apple', 2], ['apply', 1]]` or `[['apple', 2], ['app', 2], ['apply', 1]]`
+`wordFrequency("Apple App apply aPP aPPlE", 3)` sollte `[['app', 2], ['apple', 2], ['apply', 1]]` oder `[['apple', 2], ['app', 2], ['apply', 1]]` zurückgeben
```js
const arr = JSON.stringify(wordFrequency(example_4, 3));
assert(arr === example_4_solution_a || arr === example_4_solution_b);
```
-`wordFrequency("c d a d c a b d d c", 4)` should return `[['d', 4], ['c', 3], ['a', 2], ['b', 1]]`
+`wordFrequency("c d a d c a b d d c", 4)` sollte `[['d', 4], ['c', 3], ['a', 2], ['b', 1]]` zurückgeben
```js
assert.deepEqual(wordFrequency(example_5, 4), example_5_solution);
```
-`wordFrequency("", 5)` should return `[]`
+`wordFrequency("", 5)` sollte `[]` zurückgeben
```js
assert.deepEqual(wordFrequency(example_6, 5), example_6_solution);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-wrap.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-wrap.md
index 5ea8d8161da..ba1dadb2443 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-wrap.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/word-wrap.md
@@ -29,25 +29,25 @@ wrap should be a function.
assert.equal(typeof wrap, 'function');
```
-wrap should return a string.
+wrap sollte einen String zurückgeben.
```js
assert.equal(typeof wrap('abc', 10), 'string');
```
-wrap(80) should return 4 lines.
+wrap(80) sollte 4 Zeilen zurückgeben.
```js
assert(wrapped80.split('\n').length === 4);
```
-Your `wrap` function should return our expected text.
+Deine `wrap` Funktion sollte unseren erwarteten Text zurückgeben.
```js
assert.equal(wrapped80.split('\n')[0], firstRow80);
```
-wrap(42) should return 7 lines.
+wrap(42) sollte 7 Zeilen zurückgeben.
```js
assert(wrapped42.split('\n').length === 7);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/y-combinator.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/y-combinator.md
index 0c867176bc4..45b387955c3 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/y-combinator.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/y-combinator.md
@@ -18,37 +18,37 @@ Define the stateless Y combinator function and use it to compute the factorials.
# --hints--
-Y should return a function.
+Y sollte eine Funktion zurückgeben.
```js
assert.equal(typeof Y((f) => (n) => n), 'function');
```
-factorial(1) should return 1.
+factorial(1) sollte 1 zurückgeben.
```js
assert.equal(factorial(1), 1);
```
-factorial(2) should return 2.
+factorial(2) sollte 2 zurückgeben.
```js
assert.equal(factorial(2), 2);
```
-factorial(3) should return 6.
+factorial(3) sollte 6 zurückgeben.
```js
assert.equal(factorial(3), 6);
```
-factorial(4) should return 24.
+factorial(4) sollte 24 zurückgeben.
```js
assert.equal(factorial(4), 24);
```
-factorial(10) should return 3628800.
+factorial(10) sollte 3628800 zurückgeben.
```js
assert.equal(factorial(10), 3628800);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md
index 27ab1af3d3c..e6ad8113b6c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md
@@ -8,7 +8,7 @@ dashedName: zeckendorf-number-representation
# --description--
-Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series. Recall that the first six distinct Fibonacci numbers are: `1, 2, 3, 5, 8, 13`.
+Genauso wie Zahlen in einer Positionsnotation als Summen von Vielfachen von Zehnerpotenzen (dezimal) oder Zweierpotenzen (binär) dargestellt werden können, lassen sich alle positiven ganzen Zahlen als Summe von Eins oder Null mal die einzelnen Glieder der Fibonacci-Reihe darstellen. Recall that the first six distinct Fibonacci numbers are: `1, 2, 3, 5, 8, 13`.
The decimal number eleven can be written as `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` or `010100` in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that 11 decimal becomes `10100`. 10100 is not the only way to make 11 from the Fibonacci numbers however `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that *no two consecutive Fibonacci numbers can be used* which leads to the former unique solution.
@@ -18,134 +18,134 @@ Write a function that generates and returns the Zeckendorf number representation
# --hints--
-`zeckendorf` should be a function.
+`zeckendorf` sollte eine Funktion sein.
```js
assert.equal(typeof zeckendorf, 'function');
```
-`zeckendorf(0)` should return `0`.
+`zeckendorf(0)` sollte `0` zurückgeben.
```js
assert.equal(zeckendorf(0), 0);
```
-`zeckendorf(1)` should return `1`.
+`zeckendorf(1)` sollte `1` zurückgeben.
```js
assert.equal(zeckendorf(1), 1);
```
-`zeckendorf(2)` should return `10`.
+`zeckendorf(2)` sollte `10` zurückgeben.
```js
assert.equal(zeckendorf(2), 10);
```
-`zeckendorf(3)` should return `100`.
+`zeckendorf(3)` sollte `100` zurückgeben.
```js
assert.equal(zeckendorf(3), 100);
```
-`zeckendorf(4)` should return `101`.
+`zeckendorf(4)` sollte `101` zurückgeben.
```js
assert.equal(zeckendorf(4), 101);
```
-`zeckendorf(5)` should return `1000`.
+`zeckendorf(5)` sollte `1000` zurückgeben.
```js
assert.equal(zeckendorf(5), 1000);
```
-`zeckendorf(6)` should return `1001`.
+`zeckendorf(6)` sollte `1001` zurückgeben.
```js
assert.equal(zeckendorf(6), 1001);
```
-`zeckendorf(7)` should return `1010`.
+`zeckendorf(7)` sollte `1010` zurückgeben.
```js
assert.equal(zeckendorf(7), 1010);
```
-`zeckendorf(8)` should return `10000`.
+`zeckendorf(8)` sollte `10000` zurückgeben.
```js
assert.equal(zeckendorf(8), 10000);
```
-`zeckendorf(9)` should return `10001`.
+`zeckendorf(9)` sollte `10001` zurückgeben.
```js
assert.equal(zeckendorf(9), 10001);
```
-`zeckendorf(10)` should return `10010`.
+`zeckendorf(10)` sollte `10010` zurückgeben.
```js
assert.equal(zeckendorf(10), 10010);
```
-`zeckendorf(11)` should return `10100`.
+`zeckendorf(11)` sollte `10100` zurückgeben.
```js
assert.equal(zeckendorf(11), 10100);
```
-`zeckendorf(12)` should return `10101`.
+`zeckendorf(12)` sollte `10101` zurückgeben.
```js
assert.equal(zeckendorf(12), 10101);
```
-`zeckendorf(13)` should return `100000`.
+`zeckendorf(13)` sollte `100000` zurückgeben.
```js
assert.equal(zeckendorf(13), 100000);
```
-`zeckendorf(14)` should return `100001`.
+`zeckendorf(14)` sollte `100001` zurückgeben.
```js
assert.equal(zeckendorf(14), 100001);
```
-`zeckendorf(15)` should return `100010`.
+`zeckendorf(15)` sollte `100010` zurückgeben.
```js
assert.equal(zeckendorf(15), 100010);
```
-`zeckendorf(16)` should return `100100`.
+`zeckendorf(16)` sollte `100100` zurückgeben.
```js
assert.equal(zeckendorf(16), 100100);
```
-`zeckendorf(17)` should return `100101`.
+`zeckendorf(17)` sollte `100101` zurückgeben.
```js
assert.equal(zeckendorf(17), 100101);
```
-`zeckendorf(18)` should return `101000`.
+`zeckendorf(18)` sollte `101000` zurückgeben.
```js
assert.equal(zeckendorf(18), 101000);
```
-`zeckendorf(19)` should return `101001`.
+`zeckendorf(19)` sollte `101001` zurückgeben.
```js
assert.equal(zeckendorf(19), 101001);
```
-`zeckendorf(20)` should return `101010`.
+`zeckendorf(20)` sollte `101010` zurückgeben.
```js
assert.equal(zeckendorf(20), 101010);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md
index 16b17783ed3..f5d0d6ae4cf 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md
@@ -40,7 +40,7 @@ It produces the thinned output:
' ' ];
```
-## Algorithm
+## Algorithmus
Assume black pixels are one and white pixels zero, and that the input image is a rectangular N by M array of ones and zeroes. The algorithm operates on all black pixels P1 that can have eight neighbours. The neighbours are, in order, arranged as:
@@ -51,7 +51,7 @@ Obviously the boundary pixels of the image cannot have the full eight neighbours
- Define $A(P1)$ = the number of transitions from white to black, ($0 \to 1$) in the sequence P2, P3, P4, P5, P6, P7, P8, P9, P2. (Note the extra P2 at the end - it is circular).
- Define $B(P1)$ = the number of black pixel neighbours of P1. ($= \\sum(P2 \ldots P9)$)
-**Step 1:**
+**Schritt 1:**
All pixels are tested and pixels satisfying all the following conditions (simultaneously) are just noted at this stage.
@@ -63,7 +63,7 @@ All pixels are tested and pixels satisfying all the following conditions (simult
After iterating over the image and collecting all the pixels satisfying all step 1 conditions, all these condition satisfying pixels are set to white.
-**Step 2:**
+**Schritt 2:**
All pixels are again tested and pixels satisfying all the following conditions are just noted at this stage.
@@ -85,13 +85,13 @@ Write a routine to perform Zhang-Suen thinning on the provided `image`, an array
# --hints--
-`thinImage` should be a function.
+`thinImage` sollte eine Funktion sein.
```js
assert.equal(typeof thinImage, 'function');
```
-`thinImage` should return an array.
+`thinImage` sollte ein Array zurückgeben.
```js
assert(Array.isArray(thinImage(_testImage1)));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/build-a-tic-tac-toe-game.md b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/build-a-tic-tac-toe-game.md
index fdc3bd21ba6..36e64a7750e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/build-a-tic-tac-toe-game.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/build-a-tic-tac-toe-game.md
@@ -8,7 +8,7 @@ dashedName: build-a-tic-tac-toe-game
# --description--
-**Objective:** Build an app that is functionally similar to this: https://codepen.io/freeCodeCamp/full/KzXQgy/.
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie https://codepen.io/freeCodeCamp/full/KzXQgy/ aufweist.
Fulfill the below user stories and get all of the tests to pass. Use whichever libraries or APIs you need. Gib dem Ganzen deinen persönlichen Stil.
diff --git a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/chart-the-stock-market.md b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/chart-the-stock-market.md
index 8cbf3ce48ab..b800b546411 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/chart-the-stock-market.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/chart-the-stock-market.md
@@ -20,7 +20,7 @@ Here are the specific user stories you should implement for this project:
**User Story:** You can see changes in real-time when any other user adds or removes a stock. For this you will need to use Web Sockets.
-Wenn du fertig bist, stelle sicher, dass dein Projekt öffentlich zugänglich gehostet ist. Then submit the URL to it in the Solution Link field. Optionally, also submit a link to your project's source code in the GitHub Link field.
+Wenn du fertig bist, stelle sicher, dass dein Projekt öffentlich zugänglich gehostet ist. Gib anschließend die URL dazu in das Solution Link-Feld ein. Optionally, also submit a link to your project's source code in the GitHub Link field.
# --solutions--
diff --git a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/p2p-video-chat-application.md b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/p2p-video-chat-application.md
index 43f4bc699b7..35e642931ee 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/p2p-video-chat-application.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/take-home-projects/p2p-video-chat-application.md
@@ -8,7 +8,7 @@ dashedName: p2p-video-chat-application
# --description--
-**Objective:** Build an app that is functionally similar to this: https://p2p-video-chat-application.freecodecamp.rocks/.
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie https://p2p-video-chat-application.freecodecamp.rocks/ aufweist.
Erfülle die folgenden User Stories und bestehe alle Tests. Verwende Bibliotheken und APIs deiner Wahl. Gib dem Ganzen deinen persönlichen Stil.
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/how-neural-networks-work/deep-learning-demystified.md b/curriculum/challenges/german/11-machine-learning-with-python/how-neural-networks-work/deep-learning-demystified.md
index 7d7338ee653..142d1071521 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/how-neural-networks-work/deep-learning-demystified.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/how-neural-networks-work/deep-learning-demystified.md
@@ -22,7 +22,7 @@ Completely randomly.
---
-Alphabetically.
+Alphabetisch.
---
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/book-recommendation-engine-using-knn.md b/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/book-recommendation-engine-using-knn.md
index a34c3555c2f..83991b55931 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/book-recommendation-engine-using-knn.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/book-recommendation-engine-using-knn.md
@@ -24,13 +24,13 @@ After importing and cleaning the data, use `NearestNeighbors` from `sklearn.neig
Create a function named `get_recommends` that takes a book title (from the dataset) as an argument and returns a list of 5 similar books with their distances from the book argument.
-This code:
+Dieser Code:
```py
get_recommends("The Queen of the Damned (Vampire Chronicles (Paperback))")
```
-should return:
+sollte zurückgeben:
```py
[
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/cat-and-dog-image-classifier.md b/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/cat-and-dog-image-classifier.md
index f43cc60a47c..5825122e96d 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/cat-and-dog-image-classifier.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/machine-learning-with-python-projects/cat-and-dog-image-classifier.md
@@ -39,7 +39,7 @@ You can tweak epochs and batch size if you like, but it is not required.
The following instructions correspond to specific cell numbers, indicated with a comment at the top of the cell (such as `# 3`).
-## Cell 3
+## Zelle 3
Now it is your turn! Set each of the variables in this cell correctly. (They should no longer equal `None`.)
@@ -56,11 +56,11 @@ Found 1000 images belonging to 2 classes.
Found 50 images belonging to 1 class.
```
-## Cell 4
+## Zelle 4
The `plotImages` function will be used a few times to plot images. It takes an array of images and a probabilities list, although the probabilities list is optional. This code is given to you. If you created the `train_data_gen` variable correctly, then running this cell will plot five random training images.
-## Cell 5
+## Zelle 5
Recreate the `train_image_generator` using `ImageDataGenerator`.
@@ -68,25 +68,25 @@ Since there are a small number of training examples, there is a risk of overfitt
Add 4-6 random transformations as arguments to `ImageDataGenerator`. Make sure to rescale the same as before.
-## Cell 6
+## Zelle 6
You don't have to do anything for this cell. `train_data_gen` is created just like before but with the new `train_image_generator`. Then, a single image is plotted five different times using different variations.
-## Cell 7
+## Zelle 7
In this cell, create a model for the neural network that outputs class probabilities. It should use the Keras Sequential model. It will probably involve a stack of Conv2D and MaxPooling2D layers and then a fully connected layer on top that is activated by a ReLU activation function.
Compile the model passing the arguments to set the optimizer and loss. Also pass in `metrics=['accuracy']` to view training and validation accuracy for each training epoch.
-## Cell 8
+## Zelle 8
Use the `fit` method on your `model` to train the network. Make sure to pass in arguments for `x`, `steps_per_epoch`, `epochs`, `validation_data`, and `validation_steps`.
-## Cell 9
+## Zelle 9
Run this cell to visualize the accuracy and loss of the model.
-## Cell 10
+## Zelle 10
Now it is time to use your model to predict whether a brand new image is a cat or a dog.
@@ -96,7 +96,7 @@ Call the `plotImages` function and pass in the test images and the probabilities
After you run the cell, you should see all 50 test images with a label showing the percentage of "sure" that the image is a cat or a dog. The accuracy will correspond to the accuracy shown in the graph above (after running the previous cell). More training images could lead to a higher accuracy.
-## Cell 11
+## Zelle 11
Run this final cell to see if you passed the challenge or if you need to keep trying.
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/core-learning-algorithms.md b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/core-learning-algorithms.md
index 000e9800a42..234f702697b 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/core-learning-algorithms.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/core-learning-algorithms.md
@@ -24,7 +24,7 @@ Multiple regression
---
-Correlation
+Korrelation
---
@@ -32,7 +32,7 @@ Decision tree
---
-Linear regression
+Lineare Regression
## --video-solution--
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/introduction-to-tensorflow.md b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/introduction-to-tensorflow.md
index b5fd7cb1237..c6fefa63c92 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/introduction-to-tensorflow.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/introduction-to-tensorflow.md
@@ -34,7 +34,7 @@ SparseTensor
---
-Constant
+Konstante
## --video-solution--
diff --git a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/natural-language-processing-with-rnns-building-the-model.md b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/natural-language-processing-with-rnns-building-the-model.md
index e89886a9a1c..7dac0929cd8 100644
--- a/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/natural-language-processing-with-rnns-building-the-model.md
+++ b/curriculum/challenges/german/11-machine-learning-with-python/tensorflow/natural-language-processing-with-rnns-building-the-model.md
@@ -1,6 +1,6 @@
---
id: 5e8f2f13c4cdbe86b5c72da1
-title: 'Natural Language Processing With RNNs: Building the Model'
+title: 'Verarbeitung natürlicher Sprache mit RNNs: Aufbau des Modells'
challengeType: 11
videoId: 32WBFS7lfsw
bilibiliIds:
diff --git a/curriculum/challenges/german/17-college-algebra-with-python/learn-exponents-and-logarithms/exponents-and-logarithms.md b/curriculum/challenges/german/17-college-algebra-with-python/learn-exponents-and-logarithms/exponents-and-logarithms.md
index 24a80693af2..e3ed7a84276 100644
--- a/curriculum/challenges/german/17-college-algebra-with-python/learn-exponents-and-logarithms/exponents-and-logarithms.md
+++ b/curriculum/challenges/german/17-college-algebra-with-python/learn-exponents-and-logarithms/exponents-and-logarithms.md
@@ -14,7 +14,7 @@ Here is the , ($E$)
+($S$)
, ($E$)
-For each path, its checksum is calculated by (pseudocode):
+Per ogni percorso, il checksum è calcolato con (pseudocodice):
$$\begin{align} & \text{checksum} = 0 \\\\
& \text{checksum} = (\text{checksum} × 243 + m_1) \\; \text{mod} \\; 100\\,000\\,007 \\\\ & \text{checksum} = (\text{checksum} × 243 + m_2) \\; \text{mod} \\; 100\\,000\\,007 \\\\
& \ldots \\\\ & \text{checksum} = (\text{checksum} × 243 + m_n) \\; \text{mod} \\; 100\\,000\\,007 \end{align}$$
-where $m_k$ is the ASCII value of the $k^{\text{th}}$ letter in the move sequence and the ASCII values for the moves are:
+dove $m_k$ è il valore ASCII della $k$-esima lettera nella sequenza di movimento e i valori ASCII per le mosse sono:
$$\begin{array}{|c|c|} \hline L & 76 \\\\ \hline R & 82 \\\\ \hline U & 85 \\\\ \hline D & 68 \\\\ \hline \end{array}$$
-For the sequence $LULUR$ given above, the checksum would be 19761398. Now, starting from configuration ($S$), find all shortest ways to reach configuration ($T$).
+Per la sequenza $LULUR$ riportata sopra, il checksum sarebbe 19761398. Ora, partendo dalla configurazione ($S$), trova tutti i modi più brevi per raggiungere la configurazione ($T$).
-($S$)
, ($T$)
+($S$)
, ($T$)
-What is the sum of all checksums for the paths having the minimal length?
+Qual è la somma di tutti i checksum per i percorsi che hanno la lunghezza minima?
# --hints--
-`sliders()` should return `96356848`.
+`sliders()` dovrebbe restituire `96356848`.
```js
assert.strictEqual(sliders(), 96356848);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-245-coresilience.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-245-coresilience.md
index c3e090d0edb..a811245d97b 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-245-coresilience.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-245-coresilience.md
@@ -1,6 +1,6 @@
---
id: 5900f4621000cf542c50ff74
-title: 'Problem 245: Coresilience'
+title: 'Problema 245: coresilienza'
challengeType: 1
forumTopicId: 301892
dashedName: problem-245-coresilience
@@ -8,21 +8,21 @@ dashedName: problem-245-coresilience
# --description--
-We shall call a fraction that cannot be cancelled down a resilient fraction.
+Chiameremo frazione resiliente una frazione che non può essere semplificata.
-Furthermore we shall define the resilience of a denominator, $R(d)$, to be the ratio of its proper fractions that are resilient; for example, $R(12) = \frac{4}{11}$.
+Inoltre definiremo la resilienza di un denominatore, $R(d)$, come il rapporto delle sue frazioni proprie che sono resilienti; per esempio, $R(12) = \frac{4}{11}$.
-The resilience of a number $d > 1$ is then $\frac{φ(d)}{d − 1}$ , where $φ$ is Euler's totient function.
+La resilienza di un numero $d > 1$ è allora $\frac{φ(d)}{d − 1}$ , dove $φ$ è la funzione toziente di Eulero.
-We further define the coresilience of a number $n > 1$ as $C(n) = \frac{n − φ(n)}{n − 1}$.
+Definiamo inoltre la coresilienza di un numero $n > 1$ come $C(n) = \frac{n − φ(n)}{n − 1}$.
-The coresilience of a prime $p$ is $C(p) = \frac{1}{p − 1}$.
+La coresilienza di un primo $p$ è $C(p) = \frac{1}{p − 1}$.
-Find the sum of all composite integers $1 < n ≤ 2 × {10}^{11}$, for which $C(n)$ is a unit fraction.
+Trova la somma di tutti i numeri interi $1 < n ≤ 2 × {10}^{11}$, per cui $C(n)$ è una frazione unitaria.
# --hints--
-`coresilience()` should return `288084712410001`.
+`coresilience()` dovrebbe restituire `288084712410001`.
```js
assert.strictEqual(coresilience(), 288084712410001);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-246-tangents-to-an-ellipse.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-246-tangents-to-an-ellipse.md
index 16c5d89e23b..ec545ee1a5c 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-246-tangents-to-an-ellipse.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-246-tangents-to-an-ellipse.md
@@ -1,6 +1,6 @@
---
id: 5900f4621000cf542c50ff75
-title: 'Problem 246: Tangents to an ellipse'
+title: 'Problema 246: tangenti a un''ellisse'
challengeType: 1
forumTopicId: 301893
dashedName: problem-246-tangents-to-an-ellipse
@@ -8,31 +8,31 @@ dashedName: problem-246-tangents-to-an-ellipse
# --description--
-A definition for an ellipse is:
+Una definizione di un'ellisse è:
-Given a circle $c$ with centre $M$ and radius $r$ and a point $G$ such that $d(G, M) < r$, the locus of the points that are equidistant from $c$ and $G$ form an ellipse.
+Dato un cerchio $c$ con centro $M$ e raggio $r$ e un punto $G$ tali che $d(G, m) < r$, il luogo dei punti che sono equidistanti da $c$ e $G$ forma una ellisse.
-The construction of the points of the ellipse is shown below.
+La costruzione dei punti dell'ellisse è mostrata di seguito.
-
+
-Given are the points $M(-2000, 1500)$ and $G(8000, 1500)$.
+Dati i punti $M(-2000, 1500)$ e $G(800, 1500)$.
-Given is also the circle $c$ with centre $M$ and radius $15\\,000$.
+Dato il cerchio $c$ con centro $M$ e raggio $15\\,000$.
-The locus of the points that are equidistant from $G$ and $c$ form an ellipse $e$.
+Il luogo dei punti che sono equidistanti da $G$ e $c$ forma un'ellisse $e$.
-From a point $P$ outside $e$ the two tangents $t_1$ and $t_2$ to the ellipse are drawn.
+Da un punto $P$ al di fuori di $e$ sono tracciate le due tangenti all'ellisse $$t_1$ e $t_2$.
-Let the points where $t_1$ and $t_2$ touch the ellipse be $R$ and $S$.
+Siano $R$ e $S$ i punti dove $t_1$ e $t_2$ toccano l'ellisse.
-
+
-For how many lattice points $P$ is angle $RPS$ greater than 45°?
+Per quanti punti $P$ del reticolo l'angolo $RPS$ è maggiore di 45°?
# --hints--
-`tangentsToAnEllipse()` should return `810834388`.
+`tangentsToAnEllipse()` dovrebbe restituire `810834388`.
```js
assert.strictEqual(tangentsToAnEllipse(), 810834388);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-247-squares-under-a-hyperbola.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-247-squares-under-a-hyperbola.md
index d84036f8701..03632f07fed 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-247-squares-under-a-hyperbola.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-247-squares-under-a-hyperbola.md
@@ -1,6 +1,6 @@
---
id: 5900f4641000cf542c50ff76
-title: 'Problem 247: Squares under a hyperbola'
+title: 'Problema 247: quadrati sotto un''iperbole'
challengeType: 1
forumTopicId: 301894
dashedName: problem-247-squares-under-a-hyperbola
@@ -8,29 +8,29 @@ dashedName: problem-247-squares-under-a-hyperbola
# --description--
-Consider the region constrained by $1 ≤ x$ and $0 ≤ y ≤ \frac{1}{x}$.
+Considera la regione delimitata da $1 ≤ x$ e $0 ≤ y ≤ \frac{1}{x}$.
-Let $S_1$ be the largest square that can fit under the curve.
+Sia $S_1$ il quadrato più grande che può stare sotto la curva.
-Let $S_2$ be the largest square that fits in the remaining area, and so on.
+Sia $S_2$ il quadrato più grande che si adatta all'area rimanente, e così via.
-Let the index of $S_n$ be the pair (left, below) indicating the number of squares to the left of $S_n$ and the number of squares below $S_n$.
+Sia l'indice di $S_n$ la coppia (sinistra, sotto) indicante il numero di quadrati a sinistra di $S_n$ e il numero di quadrati sotto $S_n$.
-
+
-The diagram shows some such squares labelled by number.
+Il diagramma mostra alcuni di questi quadrati etichettati per numero.
-$S_2$ has one square to its left and none below, so the index of $S_2$ is (1, 0).
+$S_2$ ha un quadrato alla sua sinistra e nessuno sotto, quindi l'indice di $S_2$ è (1, 0).
-It can be seen that the index of $S_{32}$ is (1,1) as is the index of $S_{50}$.
+Si può vedere che l'indice di $S_{32}$ è (1,1) perché è l'indice di $S_{50}$.
-50 is the largest $n$ for which the index of $S_n$ is (1, 1).
+50 è il più grande $n$ per il quale l'indice di $S_n$ è (1, 1).
-What is the largest $n$ for which the index of $S_n$ is (3, 3)?
+Qual è il più grande $n$ per il quale l'indice di $S_n$ è (3, 3)?
# --hints--
-`squaresUnderAHyperbola()` should return `782252`.
+`squaresUnderAHyperbola()` dovrebbe restituire `782252`.
```js
assert.strictEqual(squaresUnderAHyperbola(), 782252);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-248-numbers-for-which-eulers-totient-function-equals-13.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-248-numbers-for-which-eulers-totient-function-equals-13.md
index 0df6dd5226a..46d9edfe8ca 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-248-numbers-for-which-eulers-totient-function-equals-13.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-248-numbers-for-which-eulers-totient-function-equals-13.md
@@ -1,6 +1,6 @@
---
id: 5900f4651000cf542c50ff77
-title: 'Problem 248: Numbers for which Euler’s totient function equals 13!'
+title: 'Problema 248: numeri per i quali la funzione toziente di Eulero è uguale a 13!'
challengeType: 1
forumTopicId: 301895
dashedName: problem-248-numbers-for-which-eulers-totient-function-equals-13
@@ -8,13 +8,13 @@ dashedName: problem-248-numbers-for-which-eulers-totient-function-equals-13
# --description--
-The first number $n$ for which $φ(n) = 13!$ is $6\\,227\\,180\\,929$.
+Il primo numero $n$ per il quale $φ(n) = 13!$ è $6\\,227\\,180\\,929$.
-Find the ${150\\,000}^{\text{th}}$ such number.
+Trova il ${150\\,000}^{\text{mo}}$ di questi numeri.
# --hints--
-`eulersTotientFunctionEquals()` should return `23507044290`.
+`eulersTotientFunctionEquals()` dovrebbe restituire `23507044290`.
```js
assert.strictEqual(eulersTotientFunctionEquals(), 23507044290);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-249-prime-subset-sums.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-249-prime-subset-sums.md
index 09232c7c178..5b9ffb85716 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-249-prime-subset-sums.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-249-prime-subset-sums.md
@@ -1,6 +1,6 @@
---
id: 5900f4671000cf542c50ff79
-title: 'Problem 249: Prime Subset Sums'
+title: 'Problema 249: somme di sottoinsiemi di primi'
challengeType: 1
forumTopicId: 301896
dashedName: problem-249-prime-subset-sums
@@ -8,15 +8,15 @@ dashedName: problem-249-prime-subset-sums
# --description--
-Let $S = \\{2, 3, 5, \ldots, 4999\\}$ be the set of prime numbers less than 5000.
+Sia $S = \\{2, 3, 5, \ldots, 4999\\}$ l'insieme di numeri primi minori di 5000.
-Find the number of subsets of $S$, the sum of whose elements is a prime number.
+Trova il numero di sottoinsiemi di $S$ per cui la somma degli elementi è un numero primo.
-Enter the rightmost 16 digits as your answer.
+Inserisci le 16 cifre più a destra come risposta.
# --hints--
-`primeSubsetSums()` should return `9275262564250418`.
+`primeSubsetSums()` dovrebbe restituire `9275262564250418`.
```js
assert.strictEqual(primeSubsetSums(), 9275262564250418);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-250-250250.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-250-250250.md
index c526154b6e7..c0b2dd9e2fd 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-250-250250.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-250-250250.md
@@ -1,6 +1,6 @@
---
id: 5900f4661000cf542c50ff78
-title: 'Problem 250: 250250'
+title: 'Problema 250: 250250'
challengeType: 1
forumTopicId: 301898
dashedName: problem-250-250250
@@ -8,11 +8,11 @@ dashedName: problem-250-250250
# --description--
-Find the number of non-empty subsets of $\\{{1}^{1}, {2}^{2}, {3}^{3}, \ldots, {250250}^{250250}\\}$, the sum of whose elements is divisible by 250. Enter the rightmost 16 digits as your answer.
+Trova il numero di sottoinsiemi non vuoti di $\\{{1}^{1}, {2}^{2}, {3}^{3}, \ldots, {250250}^{250250}\\}$, la somma dei cui elementi è divisibile per 250. Inserisci le 16 cifre più a destra come risposta.
# --hints--
-`twoHundredFifty()` should return `1425480602091519`.
+`twoHundredFifty()` dovrebbe restituire `1425480602091519`.
```js
assert.strictEqual(twoHundredFifty(), 1425480602091519);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-251-cardano-triplets.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-251-cardano-triplets.md
index 8f4013595f3..475479d5ce7 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-251-cardano-triplets.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-251-cardano-triplets.md
@@ -1,6 +1,6 @@
---
id: 5900f4671000cf542c50ff7a
-title: 'Problem 251: Cardano Triplets'
+title: 'Problema 251: terne di Cardano'
challengeType: 1
forumTopicId: 301899
dashedName: problem-251-cardano-triplets
@@ -8,19 +8,19 @@ dashedName: problem-251-cardano-triplets
# --description--
-A triplet of positive integers ($a$,$b$,$c$) is called a Cardano Triplet if it satisfies the condition:
+Una terna di numeri interi positivi ($a$,$b$,$c$) è chiamata terna di Cardano se soddisfa la condizione:
$$\sqrt[3]{a + b \sqrt{c}} + \sqrt[3]{a - b \sqrt{c}} = 1$$
-For example, (2,1,5) is a Cardano Triplet.
+Per esempio, (2,1,5) è una terna di Cardano.
-There exist 149 Cardano Triplets for which $a + b + c ≤ 1000$.
+Esistono 149 terne di Cardano per cui $a + b + c ≤ 1000$.
-Find how many Cardano Triplets exist such that $a + b + c ≤ 110\\,000\\,000$.
+Trova quante terne di Cardano esistono tali che $a + b + c ≤ 110\\,000\\,000$.
# --hints--
-`cardanoTriplets()` should return `18946051`.
+`cardanoTriplets()` dovrebbe restituire `18946051`.
```js
assert.strictEqual(cardanoTriplets(), 18946051);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-252-convex-holes.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-252-convex-holes.md
index ec671c067aa..8a3a7bf18d7 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-252-convex-holes.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-252-convex-holes.md
@@ -1,6 +1,6 @@
---
id: 5900f4691000cf542c50ff7b
-title: 'Problem 252: Convex Holes'
+title: 'Problema 252: fori convessi'
challengeType: 1
forumTopicId: 301900
dashedName: problem-252-convex-holes
@@ -8,20 +8,20 @@ dashedName: problem-252-convex-holes
# --description--
-Given a set of points on a plane, we define a convex hole to be a convex polygon having as vertices any of the given points and not containing any of the given points in its interior (in addition to the vertices, other given points may lie on the perimeter of the polygon).
+Dato un insieme di punti su un piano, definiamo un foro convesso come un poligono convesso avente come vertici uno dei punti indicati e non contenente nessuno dei punti indicati al suo interno (oltre ai vertici, altri punti indicati possono trovarsi sul perimetro del poligono).
-As an example, the image below shows a set of twenty points and a few such convex holes. The convex hole shown as a red heptagon has an area equal to 1049694.5 square units, which is the highest possible area for a convex hole on the given set of points.
+Ad esempio, l'immagine sottostante mostra una serie di venti punti e alcuni di questi fori convessi. Il foro convesso mostrato come un ettagono rosso ha una superficie pari a 1049694.5 unità quadrate, che è l'area più grande possibile per un foro convesso nell'insieme di punti dato.
-
+
-For our example, we used the first 20 points ($T_{2k − 1}$, $T_{2k}$), for $k = 1, 2, \ldots, 20$, produced with the pseudo-random number generator:
+Per il nostro esempio, abbiamo usato i primi 20 punti ($T_{2k − 1}$, $T_{2k}$), per $k = 1, 2, \ldots, 20$, prodotto con il generatore di numeri pseudo-casuali:
$$\begin{align} S_0 & = 290\\,797 \\\\
S_{n+1} & = {S_n}^2 \\; \text{mod} \\; 50\\,515\\,093 \\\\ T_n & = (S_n \\; \text{mod} \\; 2000) − 1000 \end{align}$$
-i.e. (527, 144), (−488, 732), (−454, −947), …
+cioè (527, 144), (−488, 732), (−454, −947), …
-What is the maximum area for a convex hole on the set containing the first 500 points in the pseudo-random sequence? Specify your answer including one digit after the decimal point.
+Qual è l'area massima per un foro convesso sul set contenente i primi 500 punti nella sequenza pseudo-casuale? Specify your answer including one digit after the decimal point.
# --hints--
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-253-tidying-up.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-253-tidying-up.md
index 3dbeca51b38..d694dbe7b12 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-253-tidying-up.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-253-tidying-up.md
@@ -1,6 +1,6 @@
---
id: 5900f4691000cf542c50ff7c
-title: 'Problem 253: Tidying up'
+title: 'Problema 253: mettere in ordine'
challengeType: 1
forumTopicId: 301901
dashedName: problem-253-tidying-up
@@ -8,42 +8,42 @@ dashedName: problem-253-tidying-up
# --description--
-A small child has a "number caterpillar" consisting of forty jigsaw pieces, each with one number on it, which, when connected together in a line, reveal the numbers 1 to 40 in order.
+Un bambino piccolo ha un "bruco di numeri" composto da quaranta pezzi, ciascuno con un numero su di esso, che, quando collegati insieme in fila, rivelano i numeri da 1 a 40 in ordine.
-Every night, the child's father has to pick up the pieces of the caterpillar that have been scattered across the play room. He picks up the pieces at random and places them in the correct order.
+Ogni notte, il padre del bambino deve raccogliere i pezzi del bruco che sono stati sparsi nella stanza dei giochi. Raccoglie i pezzi a caso e li posiziona nell'ordine corretto.
-As the caterpillar is built up in this way, it forms distinct segments that gradually merge together. The number of segments starts at zero (no pieces placed), generally increases up to about eleven or twelve, then tends to drop again before finishing at a single segment (all pieces placed).
+Mentre il bruco viene costruito in questo modo, si formano segmenti distinti che si uniscono gradualmente. Il numero di segmenti inizia con zero (nessun pezzo posizionato), generalmente aumenta fino a circa undici o dodici, poi tende a scendere di nuovo prima di finire in un singolo segmento (tutti i pezzi posizionati).
-For example:
+Per esempio:
-| Piece Placed | Segments So Far |
-| ------------ | --------------- |
-| 12 | 1 |
-| 4 | 2 |
-| 29 | 3 |
-| 6 | 4 |
-| 34 | 5 |
-| 5 | 4 |
-| 35 | 4 |
-| … | … |
+| Pezzi posizionati | Segmenti attuali |
+| ----------------- | ---------------- |
+| 12 | 1 |
+| 4 | 2 |
+| 29 | 3 |
+| 6 | 4 |
+| 34 | 5 |
+| 5 | 4 |
+| 35 | 4 |
+| … | … |
-Let $M$ be the maximum number of segments encountered during a random tidy-up of the caterpillar. For a caterpillar of ten pieces, the number of possibilities for each $M$ is
+Sia $M$ il numero massimo di segmenti incontrati durante un riordinamento casuale del bruco. Per un bruco di dieci pezzi, il numero di possibilità per ogni $M$ è
-| M | Possibilities |
-| - | ------------- |
-| 1 | 512 |
-| 2 | 250912 |
-| 3 | 1815264 |
-| 4 | 1418112 |
-| 5 | 144000 |
+| M | Possibilità |
+| - | ----------- |
+| 1 | 512 |
+| 2 | 250912 |
+| 3 | 1815264 |
+| 4 | 1418112 |
+| 5 | 144000 |
-so the most likely value of $M$ is 3 and the average value is $\frac{385\\,643}{113\\,400} = 3.400732$, rounded to six decimal places.
+quindi il valore più probabile di $M$ è 3 e il valore medio è $\frac{385\\,643}{113\\,400} = 3.400732$, arrotondato a sei decimali.
-The most likely value of $M$ for a forty-piece caterpillar is 11; but what is the average value of $M$? Give your answer rounded to six decimal places.
+Il valore più probabile di $M$ per un bruco a quaranta pezzi è 11; ma qual è il valore medio di $M$? Dai la risposta arrotondata a sei decimali.
# --hints--
-`tidyingUp()` should return `11.492847`.
+`tidyingUp()` dovrebbe restituire `11.492847`.
```js
assert.strictEqual(tidyingUp(), 11.492847);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-254-sums-of-digit-factorials.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-254-sums-of-digit-factorials.md
index 3d91777d0a4..f9dbbd62dd4 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-254-sums-of-digit-factorials.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-254-sums-of-digit-factorials.md
@@ -1,6 +1,6 @@
---
id: 5900f46b1000cf542c50ff7d
-title: 'Problem 254: Sums of Digit Factorials'
+title: 'Problema 254: somme dei fattoriali delle cifre'
challengeType: 1
forumTopicId: 301902
dashedName: problem-254-sums-of-digit-factorials
@@ -8,21 +8,21 @@ dashedName: problem-254-sums-of-digit-factorials
# --description--
-Define $f(n)$ as the sum of the factorials of the digits of $n$. For example, $f(342) = 3! + 4! + 2! = 32$.
+Sia $f(n)$ la somma dei fattoriali delle cifre di $n$. Per esempio, $f(342) = 3! + 4! + 2! = 32$.
-Define $sf(n)$ as the sum of the digits of $f(n)$. So $sf(342) = 3 + 2 = 5$.
+Definisci $sf(n)$ come la somma delle cifre di $f(n)$. Quindi $sf(342) = 3 + 2 = 5$.
-Define $g(i)$ to be the smallest positive integer $n$ such that $sf(n) = i$. Though $sf(342)$ is 5, $sf(25)$ is also 5, and it can be verified that $g(5)$ is 25.
+Definisci $g(i)$ in modo che sia il più piccolo numero intero positivo $n$ tale che $sf(n) = i$. Anche se $sf(342)$ è 5, $sf(25)$ è anch'esso 5, e si può verificare che $g(5)$ è 25.
-Define $sg(i)$ as the sum of the digits of $g(i)$. So $sg(5) = 2 + 5 = 7$.
+Definisci $sg(i)$ come la somma delle cifre di $g(i)$. Quindi $sg(5) = 2 + 5 = 7$.
-Further, it can be verified that $g(20)$ is 267 and $\sum sg(i)$ for $1 ≤ i ≤ 20$ is 156.
+Inoltre, può essere verificato che $g(20)$ è 267 e $\sum sg(i)$ per $1 ≤ i ≤ 20$ è 156.
-What is $\sum sg(i)$ for $1 ≤ i ≤ 150$?
+Quanto vale $\sum sg(i)$ per $1 ≤ i ≤ 150$?
# --hints--
-`sumsOfDigitFactorials()` should return `8184523820510`.
+`sumsOfDigitFactorials()` dovrebbe restituire `8184523820510`.
```js
assert.strictEqual(sumsOfDigitFactorials(), 8184523820510);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-255-rounded-square-roots.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-255-rounded-square-roots.md
index abfbcfe2047..a5b2197727f 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-255-rounded-square-roots.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-255-rounded-square-roots.md
@@ -1,6 +1,6 @@
---
id: 5900f46d1000cf542c50ff7f
-title: 'Problem 255: Rounded Square Roots'
+title: 'Problema 255: radici quadrate arrotondate'
challengeType: 1
forumTopicId: 301903
dashedName: problem-255-rounded-square-roots
@@ -8,40 +8,40 @@ dashedName: problem-255-rounded-square-roots
# --description--
-We define the rounded-square-root of a positive integer $n$ as the square root of $n$ rounded to the nearest integer.
+Definiamo la radice-quadrata-arrotondata di un intero positivo $n$ come la radice quadrata di $n$ arrotondata al numero intero più vicino.
-The following procedure (essentially Heron's method adapted to integer arithmetic) finds the rounded-square-root of $n$:
+La seguente procedura (essenzialmente il metodo di Heron adattato a interi aritmetici) trova la radice-quadrata-arrotondata di $n$:
-Let $d$ be the number of digits of the number $n$.
+Sia $d$ il numero di cifre del numero $n$.
-If $d$ is odd, set $x_0 = 2 × {10}^{\frac{d - 1}{2}}$.
+Se $d$ è dispari, imposta $x_0 = 2 × {10}^{\frac{d - 1}{2}}$.
-If $d$ is even, set $x_0 = 7 × {10}^{\frac{d - 2}{2}}$.
+Se $d$ è pari, imposta $x_0 = 7 × {10}^{\frac{d - 2}{2}}$.
-Repeat:
+Ripeti:
$$x_{k + 1} = \left\lfloor\frac{x_k + \left\lceil\frac{n}{x_k}\right\rceil}{2}\right\rfloor$$
-until $x_{k + 1} = x_k$.
+fino a $x_{k + 1} = x_k$.
-As an example, let us find the rounded-square-root of $n = 4321$.
+Ad esempio, cerchiamo di trovare la radice-quadrata-arrotondata di $n = 4321$.
-$n$ has 4 digits, so $x_0 = 7 × {10}^{\frac{4-2}{2}} = 70$.
+$n$ ha 4 cifre, quindi $x_0 = 7 × {10}^{\frac{4-2}{2}} = 70$.
$$x_1 = \left\lfloor\frac{70 + \left\lceil\frac{4321}{70}\right\rceil}{2}\right\rfloor = 66 \\\\
x_2 = \left\lfloor\frac{66 + \left\lceil\frac{4321}{66}\right\rceil}{2}\right\rfloor = 66$$
-Since $x_2 = x_1$, we stop here. So, after just two iterations, we have found that the rounded-square-root of 4321 is 66 (the actual square root is 65.7343137…).
+Dal momento che $x_2 = x_1$, ci fermiamo qui. Così, dopo solo due iterazioni, abbiamo scoperto che la radice-quadrata-arrotondata di 4321 è 66 (la vera radice quadrata è 65.7343137…).
-The number of iterations required when using this method is surprisingly low. For example, we can find the rounded-square-root of a 5-digit integer ($10\\,000 ≤ n ≤ 99\\,999$) with an average of 3.2102888889 iterations (the average value was rounded to 10 decimal places).
+Il numero d'iterazioni richieste quando si utilizza questo metodo è sorprendentemente basso. Ad esempio, possiamo trovare la radice-quadrata-arrotondata di un intero a 5 cifre ($10\\,000 ≤ n ≤ 99\\,999$) con una media di 3.2102888889 iterazioni (il valore medio è stato arrotondato al decimo decimale).
-Using the procedure described above, what is the average number of iterations required to find the rounded-square-root of a 14-digit number (${10}^{13} ≤ n < {10}^{14}$)? Give your answer rounded to 10 decimal places.
+In base alla procedura sopra descritta, qual è il numero medio di iterazioni richieste per trovare la radice-quadrata-arrotondata di un numero a 14 cifre (${10}^{13} ≤ n < {10}^{14}$)? Dai la risposta arrotondata a 10 decimali.
-**Note:** The symbols $⌊x⌋$ and $⌈x⌉$ represent the floor function and ceiling function respectively.
+**Nota:** I simboli $⌊x⌋$ e $⌈x⌉$ rappresentano rispettivamente la funzione arrotonda verso il basso e arrotonda verso l'alto.
# --hints--
-`roundedSquareRoots()` should return `4.447401118`.
+`roundedSquareRoots()` dovrebbe restituire `4.447401118`.
```js
assert.strictEqual(roundedSquareRoots(), 4.447401118);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-256-tatami-free-rooms.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-256-tatami-free-rooms.md
index 170443188b8..da185344439 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-256-tatami-free-rooms.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-256-tatami-free-rooms.md
@@ -1,6 +1,6 @@
---
id: 5900f46c1000cf542c50ff7e
-title: 'Problem 256: Tatami-Free Rooms'
+title: 'Problema 256: stanze senza tatami'
challengeType: 1
forumTopicId: 301904
dashedName: problem-256-tatami-free-rooms
@@ -8,29 +8,29 @@ dashedName: problem-256-tatami-free-rooms
# --description--
-Tatami are rectangular mats, used to completely cover the floor of a room, without overlap.
+I tatami sono stuoie rettangolari, utilizzate per coprire completamente il pavimento di una stanza, senza sovrapposizioni.
-Assuming that the only type of available tatami has dimensions 1×2, there are obviously some limitations for the shape and size of the rooms that can be covered.
+Supponendo che l'unico tipo di tatami disponibile abbia dimensioni 1×2, ci sono ovviamente alcune limitazioni per la forma e le dimensioni delle camere che possono essere coperte.
-For this problem, we consider only rectangular rooms with integer dimensions $a$, $b$ and even size $s = a \times b$. We use the term 'size' to denote the floor surface area of the room, and — without loss of generality — we add the condition $a ≤ b$.
+Per questo problema, consideriamo solo le stanze rettangolari con dimensioni intere $a$, $b$ e anche la dimensione $s = a \times b$. Usiamo il termine 'dimensione' per indicare la superficie del pavimento della stanza, e — senza perdita di generalità — aggiungiamo la condizione $a ≤ b$.
-There is one rule to follow when laying out tatami: there must be no points where corners of four different mats meet. For example, consider the two arrangements below for a 4×4 room:
+C'è una regola da seguire quando si posa il tatami: non ci devono essere punti in cui gli angoli di quattro tappeti diversi si incontrano. Per esempio, considerare le due disposizioni qui sotto per una stanza di dimensioni 4×4:
-
+
-The arrangement on the left is acceptable, whereas the one on the right is not: a red "X" in the middle, marks the point where four tatami meet.
+La disposizione a sinistra è accettabile, mentre quello a destra non lo è: una "X" rossa nel mezzo segna il punto in cui si incontrano quattro tatami.
-Because of this rule, certain even-sized rooms cannot be covered with tatami: we call them tatami-free rooms. Further, we define $T(s)$ as the number of tatami-free rooms of size $s$.
+A causa di questa regola, certe stanze di dimensioni pari non possono essere coperte con tatami: le chiamiamo stanze senza tatami. Inoltre, definiamo $T(s)$ come il numero di stanze senza tatami di dimensione $s$.
-The smallest tatami-free room has size $s = 70$ and dimensions 7×10. All the other rooms of size $s = 70$ can be covered with tatami; they are: 1×70, 2×35 and 5×14. Hence, $T(70) = 1$.
+La più piccola stanza senza tatami ha dimensioni $s = 70$ e dimensioni 7×10. Tutte le altre stanze di dimensione $s = 70$ che possono essere coperte con tatami; sono: 1×70, 2×35 e 5×14. Quindi, $T(70) = 1$.
-Similarly, we can verify that $T(1320) = 5$ because there are exactly 5 tatami-free rooms of size $s = 1320$: 20×66, 22×60, 24×55, 30×44 and 33×40. In fact, $s = 1320$ is the smallest room-size $s$ for which $T(s) = 5$.
+Allo stesso modo, possiamo verificare che $T(1320) = 5$ perché ci sono esattamente 5 stanze senza tatami di dimensioni $s = 1320$: 20×66, 22×60, 24×55, 30×44 e 33×40. Infatti, $s = 1320$ è la dimensione della stanza più piccola $s$ per cui $T(s) = 5$.
-Find the smallest room-size $s$ for which $T(s) = 200$.
+Trova la dimensione della stanza più piccola $s$ per cui $T(s) = 200$.
# --hints--
-`tatamiFreeRooms()` should return `85765680`.
+`tatamiFreeRooms()` dovrebbe restituire `85765680`.
```js
assert.strictEqual(tatamiFreeRooms(), 85765680);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-257-angular-bisectors.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-257-angular-bisectors.md
index 60864ac52e1..1610146b545 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-257-angular-bisectors.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-257-angular-bisectors.md
@@ -1,6 +1,6 @@
---
id: 5900f46e1000cf542c50ff80
-title: 'Problem 257: Angular Bisectors'
+title: 'Problema 257: bisettrici angolari'
challengeType: 1
forumTopicId: 301905
dashedName: problem-257-angular-bisectors
@@ -8,19 +8,19 @@ dashedName: problem-257-angular-bisectors
# --description--
-Given is an integer sided triangle $ABC$ with sides $a ≤ b ≤ c$ ($AB = c$, $BC = a$ and $AC = b$).
+Ti viene dato un triangolo con lati interi $ABC$ con lati $a ≤ b ≤ c$ ($AB = c$, $BC = a$ e $AC = b$).
-The angular bisectors of the triangle intersect the sides at points $E$, $F$ and $G$ (see picture below).
+Le bisettrici angolari del triangolo intersecano i lati nei punti $E$, $F$ e $G$ (vedi la figura sotto).
-
+
-The segments $EF$, $EG$ and $FG$ partition the triangle $ABC$ into four smaller triangles: $AEG$, $BFE$, $CGF$ and $EFG$. It can be proven that for each of these four triangles the ratio $\frac{\text{area}(ABC)}{\text{area}(\text{subtriangle})}$ is rational. However, there exist triangles for which some or all of these ratios are integral.
+I segmenti $EF$, $EG$ e $FG$, dividono il triangolo $ABC$ in quattro triangoli più piccoli: $AEG$, $BFE$, $CGF$ e $EFG$. Si può provare che per ognuno di questi quattro triangoli il rapporto $\frac{\text{area}(ABC)}{\text{area}(\text{sottotriangolo})}$ è razionale. Eppure, ci sono alcuni triangoli per cui alcuni o tutti di questi rapporti sono numeri interi.
-How many triangles $ABC$ with perimeter $≤ 100\\,000\\,000$ exist so that the ratio $\frac{\text{area}(ABC)}{\text{area}(AEG)}$ is integral?
+Quanti triangoli $ABC$ con perimetro $≤ 100\\,000\\,000$ esistono in modo tale che il rapporto $\frac{\text{area}(ABC)}{\text{area}(AEG)}$ sia un numero intero?
# --hints--
-`angularBisectors()` should return `139012411`.
+`angularBisectors()` dovrebbe restituire `139012411`.
```js
assert.strictEqual(angularBisectors(), 139012411);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-258-a-lagged-fibonacci-sequence.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-258-a-lagged-fibonacci-sequence.md
index d21eb673b78..76f6ad54211 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-258-a-lagged-fibonacci-sequence.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-258-a-lagged-fibonacci-sequence.md
@@ -1,6 +1,6 @@
---
id: 5900f46e1000cf542c50ff81
-title: 'Problem 258: A lagged Fibonacci sequence'
+title: 'Problema 258: una sequenza di Fibonacci ritardata'
challengeType: 1
forumTopicId: 301906
dashedName: problem-258-a-lagged-fibonacci-sequence
@@ -8,16 +8,16 @@ dashedName: problem-258-a-lagged-fibonacci-sequence
# --description--
-A sequence is defined as:
+Una sequenza è definita come:
-- $g_k = 1$, for $0 ≤ k ≤ 1999$
-- $g_k = g_{k - 2000} + g_{k - 1999}$, for $k ≥ 2000$.
+- $g_k = 1$, per $0 ≤ k ≤ 1999$
+- $g_k = g_{k - 2000} + g_{k - 1999}$, per $k ≥ 2000$.
-Find $g_k$ mod 20092010 for $k = {10}^{18}$.
+Trova $g_k$ mod 20092010 per $k = {10}^{18}$.
# --hints--
-`laggedFibonacciSequence()` should return `12747994`.
+`laggedFibonacciSequence()` dovrebbe restituire `12747994`.
```js
assert.strictEqual(laggedFibonacciSequence(), 12747994);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-259-reachable-numbers.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-259-reachable-numbers.md
index a8fa3ceb470..4b8d84ce9a6 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-259-reachable-numbers.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-259-reachable-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f4701000cf542c50ff82
-title: 'Problem 259: Reachable Numbers'
+title: 'Problema 259: numeri raggiungibili'
challengeType: 1
forumTopicId: 301907
dashedName: problem-259-reachable-numbers
@@ -8,22 +8,22 @@ dashedName: problem-259-reachable-numbers
# --description--
-A positive integer will be called reachable if it can result from an arithmetic expression obeying the following rules:
+Un intero positivo sarà chiamato raggiungibile se può derivare da un'espressione aritmetica che obbedisce alle seguenti regole:
-- Uses the digits 1 through 9, in that order and exactly once each.
-- Any successive digits can be concatenated (for example, using the digits 2, 3 and 4 we obtain the number 234).
-- Only the four usual binary arithmetic operations (addition, subtraction, multiplication and division) are allowed.
-- Each operation can be used any number of times, or not at all.
-- Unary minus is not allowed.
-- Any number of (possibly nested) parentheses may be used to define the order of operations.
+- Usa le cifre da 1 a 9, in quest'ordine ed esattamente una volta ciascuna.
+- Eventuali cifre successive possono essere concatenate (ad esempio, utilizzando le cifre 2, 3 e 4 otteniamo il numero 234).
+- Sono ammesse solo le quattro normali operazioni aritmetiche binarie (somma, sottrazione, moltiplicazione e divisione).
+- Ogni operazione può essere utilizzata qualsiasi numero di volte, o non essere usata affatto.
+- Il meno unario non è permesso.
+- Qualsiasi numero di parentesi (eventualmente annidate) può essere utilizzato per definire l'ordine delle operazioni.
-For example, 42 is reachable, since $\frac{1}{23} \times ((4 \times 5) - 6) \times (78 - 9) = 42$.
+Ad esempio, 42 è raggiungibile, poiché $\frac{1}{23} \times ((4 \times 5) - 6) \times (78 - 9) = 42$.
-What is the sum of all positive reachable integers?
+Qual è la somma di tutti gli interi raggiungibili positivi?
# --hints--
-`reachableNumbers()` should return `20101196798`.
+`reachableNumbers()` dovrebbe restituire `20101196798`.
```js
assert.strictEqual(reachableNumbers(), 20101196798);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-260-stone-game.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-260-stone-game.md
index d0724fd1214..b4960d86432 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-260-stone-game.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-260-stone-game.md
@@ -1,6 +1,6 @@
---
id: 5900f4701000cf542c50ff83
-title: 'Problem 260: Stone Game'
+title: 'Problema 260: gioco delle pietre'
challengeType: 1
forumTopicId: 301909
dashedName: problem-260-stone-game
@@ -8,33 +8,33 @@ dashedName: problem-260-stone-game
# --description--
-A game is played with three piles of stones and two players.
+Un gioco si svolge con tre mucchi di pietre e due giocatori.
-On each player's turn, the player removes one or more stones from the piles. However, if the player takes stones from more than one pile, the same number of stones must be removed from each of the selected piles.
+Al turno di ogni giocatore, il giocatore rimuove una o più pietre dai mucchi. Tuttavia, se il giocatore preleva pietre da più di una pila, lo stesso numero di pietre deve essere rimosso da ciascuna delle pile selezionate.
-In other words, the player chooses some $N > 0$ and removes:
+In altre parole, il giocatore sceglie alcuni $N > 0$ e rimuove:
-- $N$ stones from any single pile; or
-- $N$ stones from each of any two piles ($2N$ total); or
-- $N$ stones from each of the three piles ($3N$ total).
+- $N$ pietre da una singola pila qualsiasi; o
+- $N$ pietre da due pile qualsiasi ($2N$ totale); o
+- $N$ pietre da ciascuna delle tre pile ($3N$ totale).
-The player taking the last stone(s) wins the game.
+Il giocatore che prende l'ultima pietra vince la partita.
-A winning configuration is one where the first player can force a win.
+Una configurazione vincente è quella in cui il primo giocatore può forzare una vittoria.
-For example, (0,0,13), (0,11,11) and (5,5,5) are winning configurations because the first player can immediately remove all stones.
+Ad esempio, (0,0,13), (0,11,11) e (5,5,5) sono configurazioni vincenti perché il primo giocatore può immediatamente rimuovere tutte le pietre.
-A losing configuration is one where the second player can force a win, no matter what the first player does.
+Una configurazione perdente è quella in cui il secondo giocatore può forzare una vittoria, indipendentemente da ciò che fa il primo giocatore.
-For example, (0,1,2) and (1,3,3) are losing configurations: any legal move leaves a winning configuration for the second player.
+Ad esempio, (0,1,2) e (1,3,3) sono configurazioni perdenti: qualsiasi mossa lecita lascia una configurazione vincente per il secondo giocatore.
-Consider all losing configurations ($x_i$,$y_i$,$z_i$) where $x_i ≤ y_i ≤ z_i ≤ 100$. We can verify that $\sum (x_i + y_i + z_i) = 173\\,895$ for these.
+Considera tutte le configurazioni perdenti ($x_i$,$y_i$,$z_i$) dove $x_i ≤ y_i ≤ z_i ≤ 100$. Possiamo verificare che per queste $\sum (x_i + y_i + z_i) = 173\\,895$.
-Find $\sum (x_i + y_i + z_i)$ where ($x_i$,$y_i$,$z_i$) ranges over the losing configurations with $x_i ≤ y_i ≤ z_i ≤ 1000$.
+Trova $\sum (x_i + y_i + z_i)$ dove ($x_i$,$y_i$,$z_i$) varia sulle configurazioni perdenti con $x_i ≤ y_i ≤ z_i ≤ 1000$.
# --hints--
-`stoneGame()` should return `167542057`.
+`stoneGame()` dovrebbe restituire `167542057`.
```js
assert.strictEqual(stoneGame(), 167542057);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-261-pivotal-square-sums.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-261-pivotal-square-sums.md
index af6e1b5aa27..70657a772c9 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-261-pivotal-square-sums.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-261-pivotal-square-sums.md
@@ -1,6 +1,6 @@
---
id: 5900f4711000cf542c50ff84
-title: 'Problem 261: Pivotal Square Sums'
+title: 'Problem 261: somme di quadrati principali'
challengeType: 1
forumTopicId: 301910
dashedName: problem-261-pivotal-square-sums
@@ -8,21 +8,21 @@ dashedName: problem-261-pivotal-square-sums
# --description--
-Let us call a positive integer $k$ a square-pivot, if there is a pair of integers $m > 0$ and $n ≥ k$, such that the sum of the ($m + 1$) consecutive squares up to $k$ equals the sum of the $m$ consecutive squares from ($n + 1$) on:
+Sia $k$ un numero intero positivo detto square-pivot se c'è una coppia di numeri interi $m > 0$ e $n ≥ k$, tali che la somma dei ($m + 1$) quadrati consecutivi fino a $k$ sia uguale alla somma dei $m$ quadrati consecutivi a partire da ($n + 1$):
$${(k - m)}^2 + \ldots + k^2 = {(n + 1)}^2 + \ldots + {(n + m)}^2$$
-Some small square-pivots are
+Alcuni piccoli square-pivot sono
$$\begin{align} & \mathbf{4}: 3^2 + \mathbf{4}^2 = 5^2 \\\\
& \mathbf{21}: {20}^2 + \mathbf{21}^2 = {29}^2 \\\\ & \mathbf{24}: {21}^2 + {22}^2 + {23}^2 + \mathbf{24}^2 = {25}^2 + {26}^2 + {27}^2 \\\\
& \mathbf{110}: {108}^2 + {109}^2 + \mathbf{110}^2 = {133}^2 + {134}^2 \\\\ \end{align}$$
-Find the sum of all distinct square-pivots $≤ {10}^{10}$.
+Trova la somma degli square-pivot distinti $≤ {10}^{10}$.
# --hints--
-`pivotalSquareSums()` should return `238890850232021`.
+`pivotalSquareSums()` dovrebbe restituire `238890850232021`.
```js
assert.strictEqual(pivotalSquareSums(), 238890850232021);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-262-mountain-range.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-262-mountain-range.md
index d340e834fa6..777f3a74fb3 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-262-mountain-range.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-262-mountain-range.md
@@ -1,6 +1,6 @@
---
id: 5900f4731000cf542c50ff85
-title: 'Problem 262: Mountain Range'
+title: 'Problema 262: catena montuosa'
challengeType: 1
forumTopicId: 301911
dashedName: problem-262-mountain-range
@@ -8,23 +8,23 @@ dashedName: problem-262-mountain-range
# --description--
-The following equation represents the continuous topography of a mountainous region, giving the elevation $h$ at any point ($x$,$y$):
+La seguente equazione rappresenta la topografia continua di una regione montuosa, con l'altitudine $h$ in qualsiasi punto ($x$,$y$):
$$h = \left(5000 - \frac{x^2 + y^2 + xy}{200} + \frac{25(x + y)}{2}\right) \times e^{-\left|\frac{x^2 + y^2}{1\\,000\\,000} - \frac{3(x + y)}{2000} + \frac{7}{10}\right|}$$
-A mosquito intends to fly from A(200,200) to B(1400,1400), without leaving the area given by $0 ≤ x$, $y ≤ 1600$.
+Una zanzara intende volare da A(200,200) a B(1400,1400), senza lasciare l'area data da $0 ≤ x$, $y ≤ 1600$.
-Because of the intervening mountains, it first rises straight up to a point A', having elevation $f$. Then, while remaining at the same elevation $f$, it flies around any obstacles until it arrives at a point B' directly above B.
+A causa delle montagne, si alza prima fino a un punto A', con altitudine $f$. Poi, rimanendo alla stessa altitudine $f$, vola intorno a qualsiasi ostacolo fino a quando non arriva a un punto B' direttamente sopra B.
-First, determine $f_{min}$ which is the minimum constant elevation allowing such a trip from A to B, while remaining in the specified area. Then, find the length of the shortest path between A' and B', while flying at that constant elevation $f_{min}$.
+Per prima cosa, determina $f_{min}$ che è l'altitudine costante minima che consente un tale viaggio da A a B, rimanendo nell'area specificata. Quindi, trova la lunghezza del percorso più breve tra A' e B', volando a quell'altitudine costante $f_{min}$.
-Give that length as your answer, rounded to three decimal places.
+Dai quella lunghezza come risposta, arrotondata al terzo decimale.
-**Note:** For convenience, the elevation function shown above is repeated below, in a form suitable for most programming languages: `h=( 5000-0.005*(x*x+y*y+x*y)+12.5*(x+y) )* exp( -abs(0.000001*(x*x+y*y)-0.0015*(x+y)+0.7) )`.
+**Nota:** Per comodità, la funzione di altitudine mostrata sopra viene ripetuta qui sotto, in una forma adatta alla maggior parte dei linguaggi di programmazione: `h=( 5000-0.005*(x*x+y*y+x*y)+12.5*(x+y) )* exp( -abs(0.000001*(x*x+y*y)-0.0015*(x+y)+0.7) )`.
# --hints--
-`mountainRange()` should return `2531.205`.
+`mountainRange()` dovrebbe restituire `2531.205`.
```js
assert.strictEqual(mountainRange(), 2531.205);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-263-an-engineers-dream-come-true.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-263-an-engineers-dream-come-true.md
index 8fec64cc250..c858ba9ea99 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-263-an-engineers-dream-come-true.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-263-an-engineers-dream-come-true.md
@@ -1,6 +1,6 @@
---
id: 5900f4741000cf542c50ff86
-title: 'Problem 263: An engineers'' dream come true'
+title: 'Problema 263: un sogno da ingegneri diventa realtà'
challengeType: 1
forumTopicId: 301912
dashedName: problem-263-an-engineers-dream-come-true
@@ -8,30 +8,30 @@ dashedName: problem-263-an-engineers-dream-come-true
# --description--
-Consider the number 6. The divisors of 6 are: 1,2,3 and 6.
+Considera il numero 6. I divisori di 6 sono: 1,2,3 e 6.
-Every number from 1 up to and including 6 can be written as a sum of distinct divisors of 6:
+Ogni numero da 1 fino a 6 può essere scritto come una somma di divisori distinti di 6:
$1 = 1$, $2 = 2$, $3 = 1 + 2$, $4 = 1 + 3$, $5 = 2 + 3$, $6 = 6$.
-A number $n$ is called a practical number if every number from 1 up to and including $n$ can be expressed as a sum of distinct divisors of $n$.
+Un numero $n$ è chiamato numero pratico se ogni numero da 1 a $n$ può essere espresso come una somma di divisori distinti di $n$.
-A pair of consecutive prime numbers with a difference of six is called a sexy pair (since "sex" is the Latin word for "six"). The first sexy pair is (23, 29).
+Una coppia di numeri primi consecutivi con una differenza di sei è detta coppia sexy (dal momento che "sex" è la parola latina per "sei"). La prima coppia sexy è (23, 29).
-We may occasionally find a triple-pair, which means three consecutive sexy prime pairs, such that the second member of each pair is the first member of the next pair.
+Potremmo occasionalmente trovare una tripla-coppia, che significa tre coppie sexy consecutive, tali che il secondo membro di ogni coppia sia il primo membro della coppia successiva.
-We shall call a number $n$ such that:
+Sia $n$ un numero che:
-- ($n - 9$, $n - 3$), ($n - 3$, $n + 3$), ($n + 3$, $n + 9$) form a triple-pair, and
-- the numbers $n - 8$, $n - 4$, $n$, $n + 4$ and $n + 8$ are all practical,
+- ($n - 9$, $n - 3$), ($n - 3$, $n + 3$), ($n + 3$, $n + 9$) formano una coppia tripla, e
+- i numeri $n - 8$, $n - 4$, $n$, $n + 4$ e $n + 8$ sono tutti pratici,
-an engineers’ paradise.
+un paradiso degli ingegneri.
-Find the sum of the first four engineers’ paradises.
+Trova la somma dei primi quattro paradisi degli ingegneri.
# --hints--
-`engineersDreamComeTrue()` should return `2039506520`.
+`engineersDreamComeTrue()` dovrebbe restituire `2039506520`.
```js
assert.strictEqual(engineersDreamComeTrue(), 2039506520);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-264-triangle-centres.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-264-triangle-centres.md
index dc22c0cf51b..645bc5c4193 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-264-triangle-centres.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-264-triangle-centres.md
@@ -1,6 +1,6 @@
---
id: 5900f4751000cf542c50ff87
-title: 'Problem 264: Triangle Centres'
+title: 'Problema 264: centri dei triangoli'
challengeType: 1
forumTopicId: 301913
dashedName: problem-264-triangle-centres
@@ -8,15 +8,15 @@ dashedName: problem-264-triangle-centres
# --description--
-Consider all the triangles having:
+Considera tutti i triangoli che hanno:
-- All their vertices on lattice points.
-- Circumcentre at the origin O.
-- Orthocentre at the point H(5, 0).
+- Tutti i vertici su punti del reticolo.
+- Circocentro all'origine O.
+- Ortocentro al punto H(5, 0).
-There are nine such triangles having a $\text{perimeter} ≤ 50$.
+Ci sono nove di questi triangoli che hanno un $\text{perimetro} ≤ 50$.
-Listed and shown in ascending order of their perimeter, they are:
+Elencati e mostrati in ordine crescente del loro perimetro, sono:
@@ -34,18 +34,18 @@ A(8, 1), B(1, -8), C(-4, 7)
A(2, 9), B(9, -2), C(-6, -7)
A(9, 2), B(2, -9), C(-6, 7)
- 
+ 
-The sum of their perimeters, rounded to four decimal places, is 291.0089.
+La somma dei loro perimetri, arrotondata al quarto decimale, è di 291.0089.
-Find all such triangles with a $\text{perimeter} ≤ {10}^5$. Enter as your answer the sum of their perimeters rounded to four decimal places.
+Trova tutti questi triangoli con un $\text{perimetro} ≤ {10}^5$. Inserisci come risposta la somma dei loro perimetri arrotondata a quattro decimali.
# --hints--
-`triangleCentres()` should return `2816417.1055`.
+`triangleCentres()` dovrebbe restituire `2816417.1055`.
```js
assert.strictEqual(triangleCentres(), 2816417.1055);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-265-binary-circles.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-265-binary-circles.md
index 4262d97c798..9b44ddcbeed 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-265-binary-circles.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-265-binary-circles.md
@@ -1,6 +1,6 @@
---
id: 5900f4761000cf542c50ff88
-title: 'Problem 265: Binary Circles'
+title: 'Problema 265: cerchi binari'
challengeType: 1
forumTopicId: 301914
dashedName: problem-265-binary-circles
@@ -8,26 +8,26 @@ dashedName: problem-265-binary-circles
# --description--
-$2^N$ binary digits can be placed in a circle so that all the $N$-digit clockwise subsequences are distinct.
+$2^N$ cifre binarie possono essere posizionate in un cerchio in modo che tutte le sequenze di $N$ cifre in senso orario siano distinte.
-For $N = 3$, two such circular arrangements are possible, ignoring rotations:
+Per $N = 3$, sono possibili due di queste disposizioni circolari, ignorando le rotazioni:
-
+
-For the first arrangement, the 3-digit subsequences, in clockwise order, are: 000, 001, 010, 101, 011, 111, 110 and 100.
+Per la prima disposizione, le successioni a tre cifre, in ordine orario, sono: 000, 001, 010, 101, 011, 111, 110 e 100.
-Each circular arrangement can be encoded as a number by concatenating the binary digits starting with the subsequence of all zeros as the most significant bits and proceeding clockwise. The two arrangements for $N = 3$ are thus represented as 23 and 29:
+Ogni disposizione circolare può essere codificata come numero concatenando le cifre binarie a partire dalla successione di tutti gli zeri come bit più significativi e procedendo in senso orario. Le due disposizioni per $N = 3$ sono quindi rappresentate come 23 e 29:
$${00010111}_2 = 23\\\\
{00011101}_2 = 29$$
-Calling $S(N)$ the sum of the unique numeric representations, we can see that $S(3) = 23 + 29 = 52$.
+Chiamando $S(N)$ la somma delle rappresentazioni numeriche uniche, possiamo vedere che $S(3) = 23 + 29 = 52$.
-Find $S(5)$.
+Trova $S(5)$.
# --hints--
-`binaryCircles()` should return `209110240768`.
+`binaryCircles()` dovrebbe restituire `209110240768`.
```js
assert.strictEqual(binaryCircles(), 209110240768);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-266-pseudo-square-root.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-266-pseudo-square-root.md
index 2b22e967efb..947a6d9cf7e 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-266-pseudo-square-root.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-266-pseudo-square-root.md
@@ -1,6 +1,6 @@
---
id: 5900f4771000cf542c50ff89
-title: 'Problem 266: Pseudo Square Root'
+title: 'Problema 266: pseudo radice quadrata'
challengeType: 1
forumTopicId: 301915
dashedName: problem-266-pseudo-square-root
@@ -8,19 +8,19 @@ dashedName: problem-266-pseudo-square-root
# --description--
-The divisors of 12 are: 1,2,3,4,6 and 12.
+I divisori di 12 sono: 1,2,3,4,6 e 12.
-The largest divisor of 12 that does not exceed the square root of 12 is 3.
+Il massimo divisore di 12 che non supera la radice quadrata di 12 è 3.
-We shall call the largest divisor of an integer $n$ that does not exceed the square root of $n$ the pseudo square root ($PSR$) of $n$.
+Chiameremo il massimo divisore di un intero $n$ che non supera la radice quadrata di $n$ la pseudo radice quadrata ($PSR$) di $n$.
-It can be seen that $PSR(3102) = 47$.
+Si può vedere che $PSR(3102) = 47$.
-Let $p$ be the product of the primes below 190. Find $PSR(p)\bmod {10}^{16}$.
+Sia $p$ il prodotto dei primi sotto 190. Trova $PSR(p)\bmod {10}^{16}$.
# --hints--
-`pseudoSquareRoot()` should return `1096883702440585`.
+`pseudoSquareRoot()` dovrebbe restituire `1096883702440585`.
```js
assert.strictEqual(pseudoSquareRoot(), 1096883702440585);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-267-billionaire.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-267-billionaire.md
index 8dbe1d8ab66..6ffb5d56a47 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-267-billionaire.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-267-billionaire.md
@@ -1,6 +1,6 @@
---
id: 5900f4771000cf542c50ff8a
-title: 'Problem 267: Billionaire'
+title: 'Problema 267: miliardario'
challengeType: 1
forumTopicId: 301916
dashedName: problem-267-billionaire
@@ -8,21 +8,21 @@ dashedName: problem-267-billionaire
# --description--
-You are given a unique investment opportunity.
+Ti viene data un'opportunità di investimento unica.
-Starting with £1 of capital, you can choose a fixed proportion, $f$, of your capital to bet on a fair coin toss repeatedly for 1000 tosses.
+A partire da 1£ di capitale, è possibile scegliere una proporzione fissa, $f$, del tuo capitale da scommettere su una moneta lanciata ripetutamente per 1000 volte.
-Your return is double your bet for heads and you lose your bet for tails.
+Il tuo ritorno è il doppio della tua puntata per le teste e perdi la tua puntata per le croci.
-For example, if $f = \frac{1}{4}$, for the first toss you bet £0.25, and if heads comes up you win £0.5 and so then have £1.5. You then bet £0.375 and if the second toss is tails, you have £1.125.
+Ad esempio, se $f = \frac{1}{4}$, per il primo lancio hai scommesso £0.25, e se escono le teste vinci £ 0.5 e quindi hai £ 1.5. Quindi scommetti £ 0.375 e se il secondo lancio è croce, hai £ 1.125.
-Choosing $f$ to maximize your chances of having at least £1,000,000,000 after 1,000 flips, what is the chance that you become a billionaire?
+Scegliendo $f$ per massimizzare le tue probabilità di avere almeno £1.000.000.000 dopo 1.000 lanci, qual è la probabilità che diventi un miliardario?
-All computations are assumed to be exact (no rounding), but give your answer rounded to 12 digits behind the decimal point in the form 0.abcdefghijkl.
+Tutti i calcoli sono considerati esatti (senza arrotondamento), ma dai la tua risposta arrotondata a 12 cifre dopo il punto decimale nel formato 0.abcdefghijkl.
# --hints--
-`billionaire()` should return `0.999992836187`.
+`billionaire()` dovrebbe restituire `0.999992836187`.
```js
assert.strictEqual(billionaire(), 0.999992836187);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-268-counting-numbers-with-at-least-four-distinct-prime-factors-less-than-100.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-268-counting-numbers-with-at-least-four-distinct-prime-factors-less-than-100.md
index bd295d89e67..b4d41229549 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-268-counting-numbers-with-at-least-four-distinct-prime-factors-less-than-100.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-268-counting-numbers-with-at-least-four-distinct-prime-factors-less-than-100.md
@@ -1,7 +1,7 @@
---
id: 5900f4791000cf542c50ff8b
title: >-
- Problem 268: Counting numbers with at least four distinct prime factors less than 100
+ Problema 268: contare i numeri con almeno quattro fattori primi distinti inferiori a 100
challengeType: 1
forumTopicId: 301917
dashedName: >-
@@ -10,13 +10,13 @@ dashedName: >-
# --description--
-It can be verified that there are 23 positive integers less than 1000 that are divisible by at least four distinct primes less than 100.
+Si può verificare che ci sono 23 interi positivi inferiori a 1000 che sono divisibili per almeno quattro primi distinti inferiori a 100.
-Find how many positive integers less than ${10}^{16}$ are divisible by at least four distinct primes less than 100.
+Trova quanti interi positivi minori di ${10}^{16}$ sono divisibili per almeno quattro primi distinti minori di 100.
# --hints--
-`fourDistinctPrimeFactors()` should return `785478606870985`.
+`fourDistinctPrimeFactors()` dovrebbe restituire `785478606870985`.
```js
assert.strictEqual(fourDistinctPrimeFactors(), 785478606870985);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-269-polynomials-with-at-least-one-integer-root.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-269-polynomials-with-at-least-one-integer-root.md
index 3b66b2a2ab1..ed90c4fb89a 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-269-polynomials-with-at-least-one-integer-root.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-269-polynomials-with-at-least-one-integer-root.md
@@ -1,6 +1,6 @@
---
id: 5900f4791000cf542c50ff8c
-title: 'Problem 269: Polynomials with at least one integer root'
+title: 'Problema 269: polinomi con almeno una radice intera'
challengeType: 1
forumTopicId: 301918
dashedName: problem-269-polynomials-with-at-least-one-integer-root
@@ -8,27 +8,27 @@ dashedName: problem-269-polynomials-with-at-least-one-integer-root
# --description--
-A root or zero of a polynomial $P(x)$ is a solution to the equation $P(x) = 0$.
+Una radice o zero di un polinomio $P(x)$ è una soluzione per l'equazione $P(x) = 0$.
-Define $P_n$ as the polynomial whose coefficients are the digits of $n$.
+Definisci $P_n$ come un polinomio i cui coefficienti sono le cifre di $n$.
-For example, $P_{5703}(x) = 5x^3 + 7x^2 + 3$.
+Per esempio, $P_{5703}(x) = 5x^3 + 7x^2 + 3$.
-We can see that:
+Possiamo vedere che:
-- $P_n(0)$ is the last digit of $n$,
-- $P_n(1)$ is the sum of the digits of $n$,
-- $Pn(10)$ is $n$ itself.
+- $P_n(0)$ è l'ultima cifra di $n$,
+- $P_n(1)$ è la somma delle cifre di $n$,
+- $Pn(10)$ è $n$ stesso.
-Define $Z(k)$ as the number of positive integers, $n$, not exceeding $k$ for which the polynomial $P_n$ has at least one integer root.
+Sia $Z(k)$ il numero di numeri interi positivi, $n$, che non eccedono $k$ per cui il polinomio $P_n$ ha almeno una radice intera.
-It can be verified that $Z(100\\,000)$ is 14696.
+Si può verificare che $Z(100\\,000)$ è 14696.
-What is $Z({10}^{16})$?
+Qual è il valore di $Z({10}^{16})$?
# --hints--
-`polynomialsWithOneIntegerRoot()` should return `1311109198529286`.
+`polynomialsWithOneIntegerRoot()` dovrebbe restituire `1311109198529286`.
```js
assert.strictEqual(polynomialsWithOneIntegerRoot(), 1311109198529286);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-270-cutting-squares.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-270-cutting-squares.md
index 0458e257f05..c36c18e4d5b 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-270-cutting-squares.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-270-cutting-squares.md
@@ -1,6 +1,6 @@
---
id: 5900f47c1000cf542c50ff8e
-title: 'Problem 270: Cutting Squares'
+title: 'Problema 270: taglio dei quadrati'
challengeType: 1
forumTopicId: 301920
dashedName: problem-270-cutting-squares
@@ -8,21 +8,21 @@ dashedName: problem-270-cutting-squares
# --description--
-A square piece of paper with integer dimensions $N×N$ is placed with a corner at the origin and two of its sides along the $x$- and $y$-axes. Then, we cut it up respecting the following rules:
+Un pezzo quadrato di carta con dimensioni intere $N×N$ è posizionato con un angolo all'origine e due dei suoi lati lungo gli assi $x$ e $y$. Quindi lo tagliamo rispettando le seguenti regole:
-- We only make straight cuts between two points lying on different sides of the square, and having integer coordinates.
-- Two cuts cannot cross, but several cuts can meet at the same border point.
-- Proceed until no more legal cuts can be made.
+- Facciamo solo tagli dritti tra due punti situati su lati diversi del quadrato e aventi coordinate intere.
+- Due tagli non possono incrociarsi, ma diversi tagli possono incontrarsi sullo stesso punto di confine.
+- Procedi fino a quando non sarà possibile effettuare ulteriori tagli ammissibili.
-Counting any reflections or rotations as distinct, we call $C(N)$ the number of ways to cut an $N×N$ square. For example, $C(1) = 2$ and $C(2) = 30$ (shown below).
+Contando qualsiasi riflessione o rotazione come distinta, chiamiamo $C(N)$ il numero di modi di tagliare un quadrato $N×N$. Per esempio, $C(1) = 2$ e $C(2) = 30$ (mostrato di seguito).
-
+
-What is $C(30)\bmod {10}^8$ ?
+Quanto vale $C(30)\bmod {10}^8$ ?
# --hints--
-`cuttingSquares()` should return `82282080`.
+`cuttingSquares()` dovrebbe restituire `82282080`.
```js
assert.strictEqual(cuttingSquares(), 82282080);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-271-modular-cubes-part-1.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-271-modular-cubes-part-1.md
index f1dbf4b5666..59f45f19a65 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-271-modular-cubes-part-1.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-271-modular-cubes-part-1.md
@@ -1,6 +1,6 @@
---
id: 5900f47b1000cf542c50ff8d
-title: 'Problem 271: Modular Cubes, part 1'
+title: 'Problema 271: cubi modulari, parte 1'
challengeType: 1
forumTopicId: 301921
dashedName: problem-271-modular-cubes-part-1
@@ -8,15 +8,15 @@ dashedName: problem-271-modular-cubes-part-1
# --description--
-For a positive number $n$, define $S(n)$ as the sum of the integers $x$, for which $1 < x < n$ and $x^3 \equiv 1\bmod n$.
+Per un numero positivo $n$, definisci $S(n)$ come la somma degli interi $x$, per cui $1 < x < n$ e $x^3 \equiv 1\bmod n$.
-When $n = 91$, there are 8 possible values for $x$, namely: 9, 16, 22, 29, 53, 74, 79, 81. Thus, $S(91) = 9 + 16 + 22 + 29 + 53 + 74 + 79 + 81 = 363$.
+Quando $n = 91$, ci sono 8 valori possibili per $x$, cioè: 9, 16, 22, 29, 53, 74, 79, 81. Così, $S(91) = 9 + 16 + 22 + 29 + 53 + 74 + 79 + 81 = 363 $.
-Find $S(13\\,082\\,761\\,331\\,670\\,030)$.
+Trova $S(13\\,082\\,761\\,331\\,670\\,030)$.
# --hints--
-`modularCubesOne()` should return `4617456485273130000`.
+`modularCubesOne()` dovrebbe restituire `4617456485273130000`.
```js
assert.strictEqual(modularCubesOne(), 4617456485273130000);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-272-modular-cubes-part-2.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-272-modular-cubes-part-2.md
index d764ea6563b..8814a18de43 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-272-modular-cubes-part-2.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-272-modular-cubes-part-2.md
@@ -1,6 +1,6 @@
---
id: 5900f47d1000cf542c50ff8f
-title: 'Problem 272: Modular Cubes, part 2'
+title: 'Problema 272: cubi modulari, parte 2'
challengeType: 1
forumTopicId: 301922
dashedName: problem-272-modular-cubes-part-2
@@ -8,15 +8,15 @@ dashedName: problem-272-modular-cubes-part-2
# --description--
-For a positive number $n$, define $C(n)$ as the number of the integers $x$, for which $1 < x < n$ and $x^3 \equiv 1\bmod n$.
+Per un numero positivo $n$, definisci $C(n)$ come il numero degli interi $x$, per cui $1 < x < n$ e $x^3 \equiv 1\bmod n$.
-When $n = 91$, there are 8 possible values for $x$, namely: 9, 16, 22, 29, 53, 74, 79, 81. Thus, $C(91) = 8$.
+Quando $n = 91$, ci sono 8 valori possibili per $x$, cioè: 9, 16, 22, 29, 53, 74, 79, 81. Così, $C(91) = 8$.
-Find the sum of the positive numbers $n ≤ {10}^{11}$ for which $C(n)=242$.
+Trova la somma dei numeri positivi $n ≤ {10}^{11}$ per i quali $C(n)=242$.
# --hints--
-`modularCubesTwo()` should return `8495585919506151000`.
+`modularCubesTwo()` dovrebbe restituire `8495585919506151000`.
```js
assert.strictEqual(modularCubesTwo(), 8495585919506151000);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-273-sum-of-squares.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-273-sum-of-squares.md
index d5ffc27c633..006de891a31 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-273-sum-of-squares.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-273-sum-of-squares.md
@@ -1,6 +1,6 @@
---
id: 5900f47e1000cf542c50ff90
-title: 'Problem 273: Sum of Squares'
+title: 'Problema 273: somma di quadrati'
challengeType: 1
forumTopicId: 301923
dashedName: problem-273-sum-of-squares
@@ -8,21 +8,21 @@ dashedName: problem-273-sum-of-squares
# --description--
-Consider equations of the form: $a^2 + b^2 = N$, $0 ≤ a ≤ b$, $a$, $b$ and $N$ integer.
+Considera le equazioni nella forma: $a^2 + b^2 = N$, $0 ≤ a ≤ b$, $a$, $b$ e $N$ interi.
-For $N = 65$ there are two solutions:
+Per $N = 65$ ci sono due soluzioni:
-$a = 1, b = 8$ and $a = 4, b = 7$.
+$a = 1, b = 8$ e $a = 4, b = 7$.
-We call $S(N)$ the sum of the values of $a$ of all solutions of $a^2 + b^2 = N$, $0 ≤ a ≤ b$, $a$, $b$ and $N$ integer.
+Chiamiamo $S(N)$ la somma dei valori di $a$ di tutte le soluzioni di $a^2 + b^2 = N$, $0 ≤ a ≤ b$, $a$, $b$ e $N$ interi.
-Thus $S(65) = 1 + 4 = 5$.
+Quindi $S(65) = 1 + 4 = 5$.
-Find $\sum S(N)$, for all squarefree $N$ only divisible by primes of the form $4k + 1$ with $4k + 1 < 150$.
+Trova $\sum S(N)$, per tutti i numeri privi di quadrati $N$ divisibili solo per i numeri primi di tipo $4k + 1$ con $4k + 1 < 150$.
# --hints--
-`sumOfSquares()` should return `2032447591196869000`.
+`sumOfSquares()` dovrebbe restituire `2032447591196869000`.
```js
assert.strictEqual(sumOfSquares(), 2032447591196869000);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-274-divisibility-multipliers.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-274-divisibility-multipliers.md
index bf56b697151..669b55dcb0c 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-274-divisibility-multipliers.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-274-divisibility-multipliers.md
@@ -1,6 +1,6 @@
---
id: 5900f47f1000cf542c50ff91
-title: 'Problem 274: Divisibility Multipliers'
+title: 'Problema 274: moltiplicatori di divisibilità'
challengeType: 1
forumTopicId: 301924
dashedName: problem-274-divisibility-multipliers
@@ -8,25 +8,25 @@ dashedName: problem-274-divisibility-multipliers
# --description--
-For each integer $p > 1$ coprime to 10 there is a positive divisibility multiplier $m < p$ which preserves divisibility by $p$ for the following function on any positive integer, $n$:
+Per ogni intero $p > 1$ coprimo a 10 c'è un moltiplicatore di divisibilità positivo $m < p$ che preserva la divisibilità per $p$ per la seguente funzione su qualsiasi intero positivo, $n$:
-$f(n) = (\text{all but the last digit of} \\; n) + (\text{the last digit of} \\; n) \times m$
+$f(n) = (\text{tutte tranne l'ultima cifra di} \\; n) + (\text{l'ultima cifra di} \\; n) \times m$
-That is, if $m$ is the divisibility multiplier for $p$, then $f(n)$ is divisible by $p$ if and only if $n$ is divisible by $p$.
+Cioè, se $m$ è il moltiplicatore di divisibilità per $p$, allora $f(n)$ è divisibile per $p$ se e solo se $n$ è divisibile per $p$.
-(When $n$ is much larger than $p$, $f(n)$ will be less than $n$ and repeated application of $f$ provides a multiplicative divisibility test for $p$.)
+(Quando $n$ è molto più grande di $p$, $f(n)$ sarà inferiore a $n$ e l'applicazione ripetuta di $f$ fornisce un test di divisibilità moltiplicativa per $p$.)
-For example, the divisibility multiplier for 113 is 34.
+Ad esempio, il moltiplicatore di divisibilità per 113 è 34.
-$f(76275) = 7627 + 5 \times 34 = 7797$: 76275 and 7797 are both divisible by 113
+$f(76275) = 7627 + 5 \times 34 = 7797$: 76275 e 7797 sono entrambi divisibili per 113
-$f(12345) = 1234 + 5 \times 34 = 1404$: 12345 and 1404 are both not divisible by 113
+$f(12345) = 1234 + 5 \times 34 = 1404$: 12345 e 1404 non sono entrambi divisibili per 113
-The sum of the divisibility multipliers for the primes that are coprime to 10 and less than 1000 is 39517. What is the sum of the divisibility multipliers for the primes that are coprime to 10 and less than ${10}^7$?
+La somma dei moltiplicatori di divisibilità per i primi che sono coprimi a 10 e minori di 1000 è 39517. Qual è la somma dei moltiplicatori di divisibilità per i primi che sono coprimi a 10 e minori di ${10}^7$?
# --hints--
-`divisibilityMultipliers()` should return `1601912348822`.
+`divisibilityMultipliers()` dovrebbe restituire `1601912348822`.
```js
assert.strictEqual(divisibilityMultipliers(), 1601912348822);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-275-balanced-sculptures.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-275-balanced-sculptures.md
index decc755a9ee..ad1a9925fe3 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-275-balanced-sculptures.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-275-balanced-sculptures.md
@@ -1,6 +1,6 @@
---
id: 5900f4801000cf542c50ff92
-title: 'Problem 275: Balanced Sculptures'
+title: 'Problema 275: sculture bilanciate'
challengeType: 1
forumTopicId: 301925
dashedName: problem-275-balanced-sculptures
@@ -8,24 +8,24 @@ dashedName: problem-275-balanced-sculptures
# --description--
-Let us define a balanced sculpture of order $n$ as follows:
+Definiamo una scultura bilanciata di ordine $n$ come segue:
-- A polyomino made up of $n + 1$ tiles known as the blocks ($n$ tiles) and the plinth (remaining tile);
-- the plinth has its centre at position ($x = 0$, $y = 0$);
-- the blocks have $y$-coordinates greater than zero (so the plinth is the unique lowest tile);
-- the centre of mass of all the blocks, combined, has $x$-coordinate equal to zero.
+- Un polimino fatto di $n + 1$ mattonelle noti come i blocchi ($n$ mattonelle) e il plinto (la mattonella rimanente);
+- il plinto ha il suo centro in posizione ($x = 0$, $y = 0$);
+- i blocchi hanno coordinate $y$ maggiori di zero (quindi il plinto è l'unica piastrella più in basso);
+- il centro di massa di tutti i blocchi, combinati, ha una coordinata $x$ pari a zero.
-When counting the sculptures, any arrangements which are simply reflections about the $y$-axis, are not counted as distinct. For example, the 18 balanced sculptures of order 6 are shown below; note that each pair of mirror images (about the $y$-axis) is counted as one sculpture:
+Quando si contano le strutture, qualsiasi arrangiamento che è una semplice riflessione lungo l'asse $y$, non viene contato come distinto. Per esempio, le 18 sculture bilanciate di ordine 6 sono mostrate di seguito; nota che ogni coppia d'immagini specchiate (intorno all'asse $y$) è contata come una sola scultura:
-
+
-There are 964 balanced sculptures of order 10 and 360505 of order 15.
+Ci sono 964 sculture bilanciate di ordine 10 e 360505 di ordine 15.
-How many balanced sculptures are there of order 18?
+Quante sculture bilanciate di ordine 18 ci sono?
# --hints--
-`balancedSculptures()` should return `15030564`.
+`balancedSculptures()` dovrebbe restituire `15030564`.
```js
assert.strictEqual(balancedSculptures(), 15030564);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-276-primitive-triangles.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-276-primitive-triangles.md
index 26ce00839b4..dc3278214c7 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-276-primitive-triangles.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-276-primitive-triangles.md
@@ -1,6 +1,6 @@
---
id: 5900f4801000cf542c50ff93
-title: 'Problem 276: Primitive Triangles'
+title: 'Problema 276: triangoli primitivi'
challengeType: 1
forumTopicId: 301926
dashedName: problem-276-primitive-triangles
@@ -8,15 +8,15 @@ dashedName: problem-276-primitive-triangles
# --description--
-Consider the triangles with integer sides $a$, $b$ and $c$ with $a ≤ b ≤ c$.
+Considera i triangoli con lati interi $a$, $b$ e $c$ con $a ≤ b ≤ c$.
-An integer sided triangle $(a,b,c)$ is called primitive if $gcd(a,b,c) = 1$.
+Un triangolo con lati interi $(a,b,c)$ è detto primitivo se $MCD(a,b,c) = 1$.
-How many primitive integer sided triangles exist with a perimeter not exceeding $10\\,000\\,000$?
+Quanti triangoli con lati interi primitivi esistono con un perimetro non superiore a $10\\,000\\,000$?
# --hints--
-`primitiveTriangles()` should return `5777137137739633000`.
+`primitiveTriangles()` dovrebbe restituire `5777137137739633000`.
```js
assert.strictEqual(primitiveTriangles(), 5777137137739633000);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-277-a-modified-collatz-sequence.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-277-a-modified-collatz-sequence.md
index c80635aa3d8..2df9d7448f0 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-277-a-modified-collatz-sequence.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-277-a-modified-collatz-sequence.md
@@ -1,6 +1,6 @@
---
id: 5900f4811000cf542c50ff94
-title: 'Problem 277: A Modified Collatz sequence'
+title: 'Problema 277: una sequenza di Collatz modificata'
challengeType: 1
forumTopicId: 301927
dashedName: problem-277-a-modified-collatz-sequence
@@ -8,29 +8,29 @@ dashedName: problem-277-a-modified-collatz-sequence
# --description--
-A modified Collatz sequence of integers is obtained from a starting value $a_1$ in the following way:
+Una sequenza di numeri interi modificata è ottenuta da un valore iniziale $a_1$ nel seguente modo:
-$a_{n + 1} = \frac{a_n}{3}$ if $a_n$ is divisible by 3. We shall denote this as a large downward step, "D".
+$a_{n + 1} = \frac{a_n}{3}$ se $a_n$ è divisibile per 3. Lo indicheremo come un passo grande verso il basso, "D".
-$a_{n + 1} = \frac{4a_n + 2}{3}$ if $a_n$ divided by 3 gives a remainder of 1. We shall denote this as an upward step, "U".
+$a_{n + 1} = \frac{4a_n + 2}{3}$ se $a_n$ diviso per 3 dà un resto di 1. Lo indicheremo come un passo verso l'alto, "U".
-$a_{n + 1} = \frac{2a_n - 1}{3}$ if $a_n$ divided by 3 gives a remainder of 2. We shall denote this as a small downward step, "d".
+$a_{n + 1} = \frac{2a_n - 1}{3}$ se $a_n$ diviso per 3 dà un resto di 2. Lo indicheremo come un piccolo passo verso il basso, "d".
-The sequence terminates when some $a_n = 1$.
+La sequenza termina quando qualche $a_n = 1$.
-Given any integer, we can list out the sequence of steps. For instance if $a_1 = 231$, then the sequence $\\{a_n\\} = \\{231, 77, 51, 17, 11, 7, 10, 14, 9, 3, 1\\}$ corresponds to the steps "DdDddUUdDD".
+Dato qualsiasi numero intero, possiamo elencare la sequenza dei passaggi. Per esempio se $a_1 = 231$, allora la sequenza \\{a_n\\} = \\{231, 77, 51, 17, 11, 7, 10, 14, 9, 3, 1\\}$ corrisponde ai passi "DdDddUUdDD".
-Of course, there are other sequences that begin with that same sequence "DdDddUUdDD....".
+Naturalmente, ci sono altre sequenze che iniziano con quella stessa sequenza "DdDddUUdDD...".
-For instance, if $a_1 = 1004064$, then the sequence is DdDddUUdDDDdUDUUUdDdUUDDDUdDD.
+Per esempio, se $a_1 = 1004064$, allora la sequenza è DdDddUUdDDDdUDUUUdDdUUDDDUdDD.
-In fact, 1004064 is the smallest possible $a_1 > {10}^6$ that begins with the sequence DdDddUUdDD.
+Infatti, 1004064 è il più piccolo possibile $a_1 > {10}^6$ che inizia con la sequenza DdDddUUdDD.
-What is the smallest $a_1 > {10}^{15}$ that begins with the sequence "UDDDUdddDDUDDddDdDddDDUDDdUUDd"?
+Qual è il più piccolo $a_1 > {10}^{15}$ che inizia con la sequenza "UDDDUdddDDUDDddDdDddDDUDDdUUDd"?
# --hints--
-`modifiedCollatzSequence()` should return `1125977393124310`.
+`modifiedCollatzSequence()` dovrebbe restituire `1125977393124310`.
```js
assert.strictEqual(modifiedCollatzSequence(), 1125977393124310);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-278-linear-combinations-of-semiprimes.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-278-linear-combinations-of-semiprimes.md
index 215c51cb036..b493ac172de 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-278-linear-combinations-of-semiprimes.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-278-linear-combinations-of-semiprimes.md
@@ -1,6 +1,6 @@
---
id: 5900f4831000cf542c50ff95
-title: 'Problem 278: Linear Combinations of Semiprimes'
+title: 'Problema 278: combinazioni lineari di semiprimi'
challengeType: 1
forumTopicId: 301928
dashedName: problem-278-linear-combinations-of-semiprimes
@@ -8,17 +8,17 @@ dashedName: problem-278-linear-combinations-of-semiprimes
# --description--
-Given the values of integers $1 < a_1 < a_2 < \ldots < a_n$, consider the linear combination $q_1a_1 + q_2a_2 + \ldots + q_na_n = b$, using only integer values $q_k ≥ 0$.
+Dati i valori di numeri interi $1 < a_1 < a_2 < \ldots < a_n$, considera la combinazione lineare $q_1a_1 + q_2a_2 + \ldots + q_na_n = b$, utilizzando solo valori interi $q_k ≥ 0$.
-Note that for a given set of $a_k$, it may be that not all values of $b$ are possible. For instance, if $a_1 = 5$ and $a_2 = 7$, there are no $q_1 ≥ 0$ and $q_2 ≥ 0$ such that $b$ could be 1, 2, 3, 4, 6, 8, 9, 11, 13, 16, 18 or 23.
+Nota che per un dato set di $a_k$ potrebbe essere che non tutti i valori di $b$ siano possibili. Per esempio, se $a_1 = 5$ e $a_2 = 7$, non ci sono $q_1 ≥ 0$ e $q_2 ≥ 0$ tali che $b$ possa essere 1, 2, 3, 4, 6, 8, 9, 11, 13, 16, 18 o 23.
-In fact, 23 is the largest impossible value of $b$ for $a_1 = 5$ and $a_2 = 7$. We therefore call $f(5, 7) = 23$. Similarly, it can be shown that $f(6, 10, 15)=29$ and $f(14, 22, 77) = 195$.
+Infatti 23 è il più grande valore impossibile di $b$ per $a_1 = 5$ e $a_2 = 7$. Chiamiamo quindi $f(5, 7) = 23$. Allo stesso modo, si può dimostrare che $f(6, 10, 15)=29$ e $f(14, 22, 77) = 195$.
-Find $\sum f(pq,pr,qr)$, where $p$, $q$ and $r$ are prime numbers and $p < q < r < 5000$.
+Trova $\sum f(pq,pr,qr)$, dove $p$, $q$ e $r$ sono numeri primi e $p < q < r < 5000$.
# --hints--
-`linearCombinationOfSemiprimes()` should return `1228215747273908500`.
+`linearCombinationOfSemiprimes()` dovrebbe restituire `1228215747273908500`.
```js
assert.strictEqual(linearCombinationOfSemiprimes(), 1228215747273908500);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-279-triangles-with-integral-sides-and-an-integral-angle.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-279-triangles-with-integral-sides-and-an-integral-angle.md
index 9d50a5ebc61..65507c8ab2a 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-279-triangles-with-integral-sides-and-an-integral-angle.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-279-triangles-with-integral-sides-and-an-integral-angle.md
@@ -1,6 +1,6 @@
---
id: 5900f4841000cf542c50ff96
-title: 'Problem 279: Triangles with integral sides and an integral angle'
+title: 'Problema 279: triangoli con lati interi e angolo intero'
challengeType: 1
forumTopicId: 301929
dashedName: problem-279-triangles-with-integral-sides-and-an-integral-angle
@@ -8,11 +8,11 @@ dashedName: problem-279-triangles-with-integral-sides-and-an-integral-angle
# --description--
-How many triangles are there with integral sides, at least one integral angle (measured in degrees), and a perimeter that does not exceed ${10}^8$?
+Quanti triangoli ci sono con i lati interi, almeno un angolo intero (misurato in gradi) e un perimetro che non supera ${10}^8$?
# --hints--
-`trianglesWithIntegralSidesAndAngle()` should return `416577688`.
+`trianglesWithIntegralSidesAndAngle()` dovrebbe restituire `416577688`.
```js
assert.strictEqual(trianglesWithIntegralSidesAndAngle(), 416577688);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-280-ant-and-seeds.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-280-ant-and-seeds.md
index 5057b8bd47c..ff88ab330d7 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-280-ant-and-seeds.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-280-ant-and-seeds.md
@@ -1,6 +1,6 @@
---
id: 5900f4841000cf542c50ff97
-title: 'Problem 280: Ant and seeds'
+title: 'Problema 280: formica e semi'
challengeType: 1
forumTopicId: 301931
dashedName: problem-280-ant-and-seeds
@@ -8,15 +8,15 @@ dashedName: problem-280-ant-and-seeds
# --description--
-A laborious ant walks randomly on a 5x5 grid. The walk starts from the central square. At each step, the ant moves to an adjacent square at random, without leaving the grid; thus there are 2, 3 or 4 possible moves at each step depending on the ant's position.
+Una formica laboriosa cammina casualmente su una griglia 5x5. La passeggiata parte dal quadrato centrale. A ogni passo, la formica si sposta in un quadrato adiacente a caso, senza lasciare la griglia; così ci sono due, tre o quattro possibili mosse a ogni passo a seconda della posizione della formica.
-At the start of the walk, a seed is placed on each square of the lower row. When the ant isn't carrying a seed and reaches a square of the lower row containing a seed, it will start to carry the seed. The ant will drop the seed on the first empty square of the upper row it eventually reaches.
+All'inizio della passeggiata, un seme viene posto su ogni quadrato della fila inferiore. Quando la formica non porta un seme e raggiunge un quadrato della fila inferiore contenente un seme, inizierà a portare il seme. La formica lascerà cadere il seme sul primo quadrato vuoto della riga superiore che raggiunge.
-What's the expected number of steps until all seeds have been dropped in the top row? Give your answer rounded to 6 decimal places.
+Qual è il numero previsto di passaggi perché tutti i semi siano lasciati cadere nella riga superiore? Dai la risposta arrotondata a 6 decimali.
# --hints--
-`antAndSeeds()` should return `430.088247`.
+`antAndSeeds()` dovrebbe restituire `430.088247`.
```js
assert.strictEqual(antAndSeeds(), 430.088247);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-281-pizza-toppings.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-281-pizza-toppings.md
index 60b84a893f8..924547c1b07 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-281-pizza-toppings.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-281-pizza-toppings.md
@@ -1,6 +1,6 @@
---
id: 5900f4861000cf542c50ff98
-title: 'Problem 281: Pizza Toppings'
+title: 'Problema 281: topping per pizza'
challengeType: 1
forumTopicId: 301932
dashedName: problem-281-pizza-toppings
@@ -8,19 +8,19 @@ dashedName: problem-281-pizza-toppings
# --description--
-You are given a pizza (perfect circle) that has been cut into $m·n$ equal pieces and you want to have exactly one topping on each slice.
+Ti viene data una pizza (cerchio perfetto) che è stata tagliata in $m·n$ pezzi uguali e vuoi avere esattamente un condimento su ogni pezzo.
-Let $f(m,n)$ denote the number of ways you can have toppings on the pizza with $m$ different toppings ($m ≥ 2$), using each topping on exactly $n$ slices ($n ≥ 1$). Reflections are considered distinct, rotations are not.
+Sia $f(m, n)$ il numero di modi in cui puoi avere condimenti sulla pizza con $m$ condimenti diversi ($m ≥ 2$), usando ogni condimento su esattamente $n$ pezzi($n ≥ 1$). Le riflessioni sono considerate distinte, le rotazioni non lo sono.
-Thus, for instance, $f(2,1) = 1$, $f(2,2) = f(3,1) = 2$ and $f(3,2) = 16$. $f(3,2)$ is shown below:
+Così, per esempio, $f(2,1) = 1$, $f(2,2) = f(3,1) = 2$ e $f(3,2) = 16$. $f(3,2)$ è mostrato sotto:
-
+
-Find the sum of all $f(m,n)$ such that $f(m,n) ≤ {10}^{15}$.
+Trova la somma di tutte le $f(m,n)$ in modo tale che $f(m,n) ≤ {10}^{15}$.
# --hints--
-`pizzaToppings()` should return `1485776387445623`.
+`pizzaToppings()` dovrebbe restituire `1485776387445623`.
```js
assert.strictEqual(pizzaToppings(), 1485776387445623);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-282-the-ackermann-function.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-282-the-ackermann-function.md
index c9cbb75087d..c80b3048c34 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-282-the-ackermann-function.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-282-the-ackermann-function.md
@@ -1,6 +1,6 @@
---
id: 5900f4861000cf542c50ff99
-title: 'Problem 282: The Ackermann function'
+title: 'Problema 282: la funzione Ackermann'
challengeType: 1
forumTopicId: 301933
dashedName: problem-282-the-ackermann-function
@@ -8,18 +8,18 @@ dashedName: problem-282-the-ackermann-function
# --description--
-For non-negative integers $m$, $n$, the Ackermann function $A(m, n)$ is defined as follows:
+Per gli interi non negativi $m$, $n$, la funzione Ackermann $A(m, n)$ è definita come segue:
$$A(m, n) = \begin{cases} n + 1 & \text{if $m = 0$} \\\\
-A(m - 1, 1) & \text{if $m > 0$ and $n = 0$} \\\\ A(m - 1, A(m, n - 1)) & \text{if $m > 0$ and $n > 0$} \end{cases}$$
+A(m - 1, 1) & \text{if $m > 0$ e $n = 0$} \\\\ A(m - 1, A(m, n - 1)) & \text{if $m > 0$ e $n > 0$} \end{cases}$$
-For example $A(1, 0) = 2$, $A(2, 2) = 7$ and $A(3, 4) = 125$.
+Per esempio $A(1, 0) = 2$, $A(2, 2) = 7$ e $A(3, 4) = 125$.
Find $\displaystyle\sum_{n = 0}^6 A(n, n)$ and give your answer mod ${14}^8$.
# --hints--
-`ackermanFunction()` should return `1098988351`.
+`ackermanFunction()` dovrebbe restituire `1098988351`.
```js
assert.strictEqual(ackermanFunction(), 1098988351);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-283-integer-sided-triangles-for-which-the-area--perimeter-ratio-is-integral.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-283-integer-sided-triangles-for-which-the-area--perimeter-ratio-is-integral.md
index e32d0d74b9d..3f99ff76cf5 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-283-integer-sided-triangles-for-which-the-area--perimeter-ratio-is-integral.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-283-integer-sided-triangles-for-which-the-area--perimeter-ratio-is-integral.md
@@ -1,7 +1,7 @@
---
id: 5900f4881000cf542c50ff9a
title: >-
- Problem 283: Integer sided triangles for which the area / perimeter ratio is integral
+ Problema 283: triangoli con lati interi per i quali il rapporto area / perimetro è intero
challengeType: 1
forumTopicId: 301934
dashedName: >-
@@ -10,19 +10,19 @@ dashedName: >-
# --description--
-Consider the triangle with sides 6, 8 and 10. It can be seen that the perimeter and the area are both equal to 24.
+Considera il triangolo con i lati 6, 8 e 10. Si può vedere che il perimetro e l'area sono entrambi uguali a 24.
-So the $\frac{\text{area}}{\text{perimeter}}$ ratio is equal to 1.
+Quindi il rapporto $\frac{\text{area}}{\text{perimetro}}$ è uguale a 1.
-Consider also the triangle with sides 13, 14 and 15. The perimeter equals 42 while the area is equal to 84.
+Considera anche il triangolo con i lati 13, 14 e 15. Il perimetro è uguale a 42 mentre l'area è pari a 84.
-So for this triangle the $\frac{\text{area}}{\text{perimeter}}$ ratio is equal to 2.
+Quindi per questo triangolo il rapporto $\frac{\text{area}}{\text{perimetro}}$ è uguale a 2.
-Find the sum of the perimeters of all integer sided triangles for which the area/perimeter ratios are equal to positive integers not exceeding 1000.
+Trova la somma dei perimetri di tutti i triangoli con lati interi per i quali i rapporti area/perimetro sono uguali a interi positivi non superiori a 1000.
# --hints--
-`integralAreaPerimeterRatio()` should return `28038042525570324`.
+`integralAreaPerimeterRatio()` dovrebbe restituire `28038042525570324`.
```js
assert.strictEqual(integralAreaPerimeterRatio(), 28038042525570324);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-284-steady-squares.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-284-steady-squares.md
index d6c86b00055..e7e15481b31 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-284-steady-squares.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-284-steady-squares.md
@@ -1,6 +1,6 @@
---
id: 5900f4891000cf542c50ff9b
-title: 'Problem 284: Steady Squares'
+title: 'Problema 284: quadrati stazionari'
challengeType: 1
forumTopicId: 301935
dashedName: problem-284-steady-squares
@@ -8,23 +8,23 @@ dashedName: problem-284-steady-squares
# --description--
-The 3-digit number 376 in the decimal numbering system is an example of numbers with the special property that its square ends with the same digits: ${376}^2 = 141376$. Let's call a number with this property a steady square.
+Il numero 376 a 3 cifre nel sistema di numerazione decimale è un esempio di numeri con la proprietà speciale che il suo quadrato termina con le stesse cifre: ${376}^2 = 141376$. Chiamiamo un numero con questa proprietà quadrato stazionario.
-Steady squares can also be observed in other numbering systems. In the base 14 numbering system, the 3-digit number $c37$ is also a steady square: $c37^2 = aa0c37$, and the sum of its digits is $c+3+7=18$ in the same numbering system. The letters $a$, $b$, $c$ and $d$ are used for the 10, 11, 12 and 13 digits respectively, in a manner similar to the hexadecimal numbering system.
+I quadrati stabili possono essere osservati anche in altri sistemi di numerazione. Nel sistema di numerazione base 14, il numero a 3 cifre $c37$ è un quadrato stazionario: $c37^2 = aa0c37$, e la somma delle sue cifre è $c+3+7=18$ nello stesso sistema di numerazione. Le lettere $a$, $b$, $c$ e $d$ sono usate rispettivamente per le cifre 10, 11, 12 e 13, in modo simile al sistema di numerazione esadecimale.
-For $1 ≤ n ≤ 9$, the sum of the digits of all the $n$-digit steady squares in the base 14 numbering system is $2d8$ (582 decimal). Steady squares with leading 0's are not allowed.
+Per $1 ≤ n ≤ 9$, la somma delle cifre di tutti i quadrati stazionari di $n$ cifre nel sistema di numerazione in base 14 è $2d8$ (582 decimali). I quadrati stazionari con 0 iniziali non sono permessi.
-Find the sum of the digits of all the $n$-digit steady squares in the base 14 numbering system for $1 ≤ n ≤ 10000$ (decimal) and give your answer as a string in the base 14 system using lower case letters where necessary.
+Trova la somma delle cifre di tutti i quadrati stazionari di $n$ cifre nel sistema di numerazione della base 14 per $1 ≤ n ≤ 10000$ (decimale) e dai la tua risposta come una stringa nel sistema base 14 utilizzando lettere minuscole se necessario.
# --hints--
-`steadySquares()` should return a string.
+`steadySquares()` dovrebbe restituire una stringa.
```js
assert(typeof steadySquares() === 'string');
```
-`steadySquares()` should return the string `5a411d7b`.
+`steadySquares()` dovrebbe restituire la stringa `5a411d7b`.
```js
assert.strictEqual(steadySquares(), '5a411d7b');
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-285-pythagorean-odds.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-285-pythagorean-odds.md
index 5c6e49167f9..105438c1c0c 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-285-pythagorean-odds.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-285-pythagorean-odds.md
@@ -1,6 +1,6 @@
---
id: 5900f48a1000cf542c50ff9c
-title: 'Problem 285: Pythagorean odds'
+title: 'Problema 285: disparità pitagoriche'
challengeType: 1
forumTopicId: 301936
dashedName: problem-285-pythagorean-odds
@@ -8,19 +8,19 @@ dashedName: problem-285-pythagorean-odds
# --description--
-Albert chooses a positive integer $k$, then two real numbers $a$, $b$ are randomly chosen in the interval [0,1] with uniform distribution.
+Albert sceglie un numero intero positivo $k$, quindi due numeri reali $a$, $b$ sono scelti casualmente nell'intervallo [0,1] con distribuzione uniforme.
-The square root of the sum ${(ka + 1)}^2 + {(kb + 1)}^2$ is then computed and rounded to the nearest integer. If the result is equal to $k$, he scores $k$ points; otherwise he scores nothing.
+La radice quadrata della somma ${(ka + 1)}^2 + {(kb + 1)}^2$ viene quindi calcolata e arrotondata alla cifra intera più vicina. Se il risultato è uguale a $k$, ottiene $k$ punti; altrimenti non ottiene nulla.
-For example, if $k = 6$, $a = 0.2$ and $b = 0.85$, then ${(ka + 1)}^2 + {(kb + 1)}^2 = 42.05$. The square root of 42.05 is 6.484... and when rounded to the nearest integer, it becomes 6. This is equal to $k$, so he scores 6 points.
+Per esempio, se $k = 6$, $a = 0.2$ e $b = 0.85$, poi ${(ka + 1)}^2 + {(kb + 1)}^2 = 42.05$. La radice quadrata di 42.05 è 6.484... che arrotondata al numero intero più vicino, diventa 6. Questo è uguale a $k$, quindi ottiene 6 punti.
-It can be shown that if he plays 10 turns with $k = 1, k = 2, \ldots, k = 10$, the expected value of his total score, rounded to five decimal places, is 10.20914.
+Si può dimostrare che se gioca 10 turni con $k = 1, k = 2, \ldots, k = 10$, il valore previsto del suo punteggio totale, arrotondato al quinto decimale, è 10.20914.
-If he plays ${10}^5$ turns with $k = 1, k = 2, k = 3, \ldots, k = {10}^5$, what is the expected value of his total score, rounded to five decimal places?
+Se gioca ${10}^5$ turni con $k = 1, k = 2, k = 3, \ldots, k = {10}^5$, qual è il valore previsto del suo punteggio totale, arrotondato al quinto decimale?
# --hints--
-`pythagoreanOdds()` should return `157055.80999`.
+`pythagoreanOdds()` dovrebbe restituire `157055.80999`.
```js
assert.strictEqual(pythagoreanOdds(), 157055.80999);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-286-scoring-probabilities.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-286-scoring-probabilities.md
index 26e3e198604..5da1b3c79f7 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-286-scoring-probabilities.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-286-scoring-probabilities.md
@@ -1,6 +1,6 @@
---
id: 5900f48a1000cf542c50ff9d
-title: 'Problem 286: Scoring probabilities'
+title: 'Problema 286: dare punteggi alle probabilità'
challengeType: 1
forumTopicId: 301937
dashedName: problem-286-scoring-probabilities
@@ -8,15 +8,15 @@ dashedName: problem-286-scoring-probabilities
# --description--
-Barbara is a mathematician and a basketball player. She has found that the probability of scoring a point when shooting from a distance $x$ is exactly ($1 - \frac{x}{q}$), where $q$ is a real constant greater than 50.
+Barbara è una matematica e una giocatrice di basket. Ha trovato che la probabilità di segnare un punto lanciando da una distanza $x$ è esattamente ($1 - \frac{x}{q}$), dove $q$ è una costante reale maggiore di 50.
-During each practice run, she takes shots from distances $x = 1, x = 2, \ldots, x = 50$ and, according to her records, she has precisely a 2 % chance to score a total of exactly 20 points.
+Durante ogni allenamento, lancia la palla da distanze $x = 1, x = 2, \ldots, x = 50$ e, secondo le sue registrazioni, ha precisamente un 2 % di possibilità di segnare esattamente 20 punti.
-Find $q$ and give your answer rounded to 10 decimal places.
+Trova $q$ e dai la tua risposta arrotondata a 10 cifre decimali.
# --hints--
-`scoringProbabilities()` should return `52.6494571953`.
+`scoringProbabilities()` dovrebbe restituire `52.6494571953`.
```js
assert.strictEqual(scoringProbabilities(), 52.6494571953);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-287-quadtree-encoding-a-simple-compression-algorithm.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-287-quadtree-encoding-a-simple-compression-algorithm.md
index 707a6fa97e7..86166808d44 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-287-quadtree-encoding-a-simple-compression-algorithm.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-287-quadtree-encoding-a-simple-compression-algorithm.md
@@ -1,6 +1,6 @@
---
id: 5900f48b1000cf542c50ff9e
-title: 'Problem 287: Quadtree encoding (a simple compression algorithm)'
+title: 'Problema 287: codifica quadtree (un semplice algoritmo di compressione)'
challengeType: 1
forumTopicId: 301938
dashedName: problem-287-quadtree-encoding-a-simple-compression-algorithm
@@ -8,32 +8,32 @@ dashedName: problem-287-quadtree-encoding-a-simple-compression-algorithm
# --description--
-The quadtree encoding allows us to describe a $2^N×2^N$ black and white image as a sequence of bits (0 and 1). Those sequences are to be read from left to right like this:
+La codifica Quadtree ci permette di descrivere un'immagine $2^N×2^N$ in bianco e nero come sequenza di bit (0 e 1). Queste sequenze devono essere lette da sinistra a destra in questo modo:
-- the first bit deals with the complete $2^N×2^N$ region;
-- "0" denotes a split:
- - the current $2^n×2^n$ region is divided into 4 sub-regions of dimension $2^{n - 1}×2^{n - 1}$,
- - the next bits contains the description of the top left, top right, bottom left and bottom right sub-regions - in that order;
-- "10" indicates that the current region contains only black pixels;
-- "11" indicates that the current region contains only white pixels.
+- il primo bit si occupa dell'intera regione $2^N×2^N$;
+- "0" indica una suddivisione:
+ - la regione attuale $2^n×2^n$ è divisa in 4 sottoregioni di dimensione $2^{n - 1}×2^{n - 1}$,
+ - i bit successivi contengono la descrizione delle sottoregioni in alto a sinistra, in alto a destra, in basso a sinistra e in basso a destra - in quest'ordine;
+- "10" indica che la regione corrente contiene solo pixel neri;
+- "11" indica che la regione corrente contiene solo pixel bianchi.
-Consider the following 4×4 image (colored marks denote places where a split can occur):
+Considera la seguente immagine 4×4 (i segni colorati indicano i luoghi in cui può verificarsi una divisione):
-
+
-This image can be described by several sequences, for example : "001010101001011111011010101010", of length 30, or "0100101111101110", of length 16, which is the minimal sequence for this image.
+Questa immagine può essere descritta da diverse sequenze, ad esempio: "001010101001011111011010101010", di lunghezza 30, o "0100101111101110", di lunghezza 16, che è la sequenza minima per questa immagine.
-For a positive integer $N$, define $D_N$ as the $2^N×2^N$ image with the following coloring scheme:
+Per un numero intero positivo $N$, definisci $D_N$ come l'immagine $2^N×2^N$ con il seguente schema di colorazione:
-- the pixel with coordinates $x = 0$, $y = 0$ corresponds to the bottom left pixel,
-- if ${(x - 2^{N - 1})}^2 + {(y - 2^{N - 1})}^2 ≤ 2^{2N - 2}$ then the pixel is black,
-- otherwise the pixel is white.
+- il pixel con le coordinate $x = 0$, $y = 0$ corrisponde al pixel in basso a sinistra,
+- se ${(x - 2^{N - 1})}^2 + {(y - 2^{N - 1})}^2 ≤ 2^{2N - 2}$ allora il pixel è nero,
+- altrimenti il pixel è bianco.
-What is the length of the minimal sequence describing $D_{24}$?
+Qual è la lunghezza della sequenza minima che descrive $D_{24}$?
# --hints--
-`quadtreeEncoding()` should return `313135496`.
+`quadtreeEncoding()` dovrebbe restituire `313135496`.
```js
assert.strictEqual(quadtreeEncoding(), 313135496);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-288-an-enormous-factorial.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-288-an-enormous-factorial.md
index cd92a15cd8c..bfa61e9d328 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-288-an-enormous-factorial.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-288-an-enormous-factorial.md
@@ -1,6 +1,6 @@
---
id: 5900f48d1000cf542c50ff9f
-title: 'Problem 288: An enormous factorial'
+title: 'Problema 288: un fattoriale enorme'
challengeType: 1
forumTopicId: 301939
dashedName: problem-288-an-enormous-factorial
@@ -8,22 +8,22 @@ dashedName: problem-288-an-enormous-factorial
# --description--
-For any prime $p$ the number $N(p,q)$ is defined by $N(p,q) = \sum_{n=0}^q T_n \times p^n$ with $T_n$ generated by the following random number generator:
+Per ogni numero primo $p$ il numero $N(p, q)$ è definito da $N(p,q) = \sum_{n=0}^q T_n \times p^n$ con $T_n$ generato dal seguente generatore casuale di numeri:
$$\begin{align} & S_0 = 290797 \\\\
& S_{n + 1} = {S_n}^2\bmod 50\\,515\\,093 \\\\ & T_n = S_n\bmod p \end{align}$$
-Let $Nfac(p,q)$ be the factorial of $N(p,q)$.
+Sia $Nfac(p,q)$ il fattoriale di $N(p,q)$.
-Let $NF(p,q)$ be the number of factors $p$ in $Nfac(p,q)$.
+Sia $NF(p,q)$ il numero di fattori $p$ in $Nfac(p,q)$.
-You are given that $NF(3,10000) \bmod 3^{20} = 624\\,955\\,285$.
+Ti è dato che $NF(3,10000) \bmod 3^{20} = 624\\,955\\,285$.
-Find $NF(61,{10}^7)\bmod {61}^{10}$.
+Trova $NF(61,{10}^7)\bmod {61}^{10}$.
# --hints--
-`enormousFactorial()` should return `605857431263982000`.
+`enormousFactorial()` dovrebbe restituire `605857431263982000`.
```js
assert.strictEqual(enormousFactorial(), 605857431263982000);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-289-eulerian-cycles.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-289-eulerian-cycles.md
index e491cab3612..f4f1e61277d 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-289-eulerian-cycles.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-289-eulerian-cycles.md
@@ -1,6 +1,6 @@
---
id: 5900f48d1000cf542c50ffa0
-title: 'Problem 289: Eulerian Cycles'
+title: 'Problema 289: cicli euleriani'
challengeType: 1
forumTopicId: 301940
dashedName: problem-289-eulerian-cycles
@@ -8,23 +8,23 @@ dashedName: problem-289-eulerian-cycles
# --description--
-Let $C(x,y)$ be a circle passing through the points ($x$, $y$), ($x$, $y + 1$), ($x + 1$, $y$) and ($x + 1$, $y + 1$).
+Sia $C(x,y)$ una circonferenza che passa attraverso i punti ($x$, $y$), ($x$, $y + 1$), ($x + 1$, $y$) e ($x + 1$, $y + 1$).
-For positive integers $m$ and $n$, let $E(m,n)$ be a configuration which consists of the $m·n$ circles: { $C(x,y)$: $0 ≤ x < m$, $0 ≤ y < n$, $x$ and $y$ are integers }
+Dati i numeri interi positivi $m$ e $n$, sia $E(m,n)$ una configurazione che consiste di $m·n$ circonferenze: { $C(x,y)$: $0 ≤ x < m$, $0 ≤ y < n$, con $x$ e $y$ interi }
-An Eulerian cycle on $E(m,n)$ is a closed path that passes through each arc exactly once. Many such paths are possible on $E(m,n)$, but we are only interested in those which are not self-crossing: A non-crossing path just touches itself at lattice points, but it never crosses itself.
+Un ciclo euleriano su $E(m,n)$ è un percorso chiuso che passa attraverso ogni arco esattamente una volta. Molti di questi percorsi sono possibili su $E(m,n)$, ma siamo interessati solo a quelli che non sono auto-attraversanti: un sentiero non incrociato si tocca solo ai punti di reticolo, ma non si attraversa mai.
-The image below shows $E(3,3)$ and an example of an Eulerian non-crossing path.
+L'immagine qui sotto mostra $E(3,3)$ e un esempio di un percorso euleriano senza incroci.
-
+
-Let $L(m,n)$ be the number of Eulerian non-crossing paths on $E(m,n)$. For example, $L(1,2) = 2$, $L(2,2) = 37$ and $L(3,3) = 104290$.
+Sia $L(m,n)$ il numero di percorsi euleriani senza incroci su $E(m,n)$. Per esempio, $L(1,2) = 2$, $L(2,2) = 37$ e $L(3,3) = 104290$.
-Find $L(6,10)\bmod {10}^{10}$.
+Trova $L(6,10)\bmod {10}^{10}$.
# --hints--
-`eulerianCycles()` should return `6567944538`.
+`eulerianCycles()` dovrebbe restituire `6567944538`.
```js
assert.strictEqual(eulerianCycles(), 6567944538);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-290-digital-signature.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-290-digital-signature.md
index a6b3636eefd..3b64fb1349d 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-290-digital-signature.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-290-digital-signature.md
@@ -1,6 +1,6 @@
---
id: 5900f48f1000cf542c50ffa1
-title: 'Problem 290: Digital Signature'
+title: 'Problema 290: firma digitale'
challengeType: 1
forumTopicId: 301942
dashedName: problem-290-digital-signature
@@ -8,11 +8,11 @@ dashedName: problem-290-digital-signature
# --description--
-How many integers $0 ≤ n < {10}^{18}$ have the property that the sum of the digits of $n$ equals the sum of digits of $137n$?
+Quanti interi $0 ≤ n < {10}^{18}$ hanno la proprietà che la somma delle cifre di $n$ è uguale alla somma delle cifre di $137n$?
# --hints--
-`digitalSignature()` should return `20444710234716470`.
+`digitalSignature()` dovrebbe restituire `20444710234716470`.
```js
assert.strictEqual(digitalSignature(), 20444710234716470);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-291-panaitopol-primes.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-291-panaitopol-primes.md
index bb33727271a..992040ab4a4 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-291-panaitopol-primes.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-291-panaitopol-primes.md
@@ -1,6 +1,6 @@
---
id: 5900f48f1000cf542c50ffa2
-title: 'Problem 291: Panaitopol Primes'
+title: 'Problema 291: primi di Panaitopol'
challengeType: 1
forumTopicId: 301943
dashedName: problem-291-panaitopol-primes
@@ -8,13 +8,13 @@ dashedName: problem-291-panaitopol-primes
# --description--
-A prime number $p$ is called a Panaitopol prime if $p = \frac{x^4 - y^4}{x^3 + y^3}$ for some positive integers $x$ and $y$.
+Un numero primo $p$ viene chiamato primo di Panaitopol se $p = \frac{x^4 - y^4}{x^3 + y^3}$ per qualche numero positivo $x$ e $y$.
-Find how many Panaitopol primes are less than $5 × {10}^{15}$.
+Trova quanti primi di Panaitopol esistono minori di $5 × {10}^{15}$.
# --hints--
-`panaitopolPrimes()` should return `4037526`.
+`panaitopolPrimes()` dovrebbe restituire `4037526`.
```js
assert.strictEqual(panaitopolPrimes(), 4037526);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-292-pythagorean-polygons.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-292-pythagorean-polygons.md
index 8e0dd899454..c3809cb7069 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-292-pythagorean-polygons.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-292-pythagorean-polygons.md
@@ -1,6 +1,6 @@
---
id: 5900f4911000cf542c50ffa3
-title: 'Problem 292: Pythagorean Polygons'
+title: 'Problema 292: poligoni pitagorici'
challengeType: 1
forumTopicId: 301944
dashedName: problem-292-pythagorean-polygons
@@ -8,24 +8,24 @@ dashedName: problem-292-pythagorean-polygons
# --description--
-We shall define a pythagorean polygon to be a convex polygon with the following properties:
+Definiremo un poligono pitagorico come poligono convesso con le seguenti proprietà:
-- there are at least three vertices,
-- no three vertices are aligned,
-- each vertex has integer coordinates,
-- each edge has integer length.
+- ci sono almeno tre vertici,
+- non ci sono tre vertici allineati,
+- ogni vertice ha coordinate intere,
+- ogni lato ha lunghezza intera.
-For a given integer $n$, define $P(n)$ as the number of distinct pythagorean polygons for which the perimeter is $≤ n$.
+Per un dato numero intero $n$, si definisce $P(n)$ come il numero di poligoni pitagorici distinti per i quali il perimetro è $≤ n$.
-Pythagorean polygons should be considered distinct as long as none is a translation of another.
+I poligoni pitagorici dovrebbero essere considerati distinti purché nessuno sia la traslazione di un altro.
-You are given that $P(4) = 1$, $P(30) = 3655$ and $P(60) = 891045$.
+Ti viene dato che $P(4) = 1$, $P(30) = 3655$ e $P(60) = 891045$.
-Find $P(120)$.
+Trova $P(120)$.
# --hints--
-`pythagoreanPolygons()` should return `3600060866`.
+`pythagoreanPolygons()` dovrebbe restituire `3600060866`.
```js
assert.strictEqual(pythagoreanPolygons(), 3600060866);
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-293-pseudo-fortunate-numbers.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-293-pseudo-fortunate-numbers.md
index 0c8076828de..d4c36f064fe 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-293-pseudo-fortunate-numbers.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-293-pseudo-fortunate-numbers.md
@@ -1,6 +1,6 @@
---
id: 5900f4931000cf542c50ffa4
-title: 'Problem 293: Pseudo-Fortunate Numbers'
+title: 'Problema 293: numeri pseudo-fortunati'
challengeType: 1
forumTopicId: 301945
dashedName: problem-293-pseudo-fortunate-numbers
@@ -8,19 +8,19 @@ dashedName: problem-293-pseudo-fortunate-numbers
# --description--
-An even positive integer $N$ will be called admissible, if it is a power of 2 or its distinct prime factors are consecutive primes.
+Un intero pari positivo $N$ sarà chiamato ammissibile, se è una potenza di 2 o i suoi distinti fattori primi sono primi consecutivi.
-The first twelve admissible numbers are 2, 4, 6, 8, 12, 16, 18, 24, 30, 32, 36, 48.
+I primi dodici numeri ammissibili sono 2, 4, 6, 8, 12, 16, 18, 24, 30, 32, 36, 48.
-If $N$ is admissible, the smallest integer $M > 1$ such that $N + M$ is prime, will be called the pseudo-Fortunate number for $N$.
+Se $N$ è ammissibile, il più piccolo numero intero $M > 1$ tale che la somma $N + M$ sia prima, sarà chiamato il numero pseudo-fortunato per $N$.
-For example, $N = 630$ is admissible since it is even and its distinct prime factors are the consecutive primes 2, 3, 5 and 7. The next prime number after 631 is 641; hence, the pseudo-Fortunate number for 630 is $M = 11$. It can also be seen that the pseudo-Fortunate number for 16 is 3.
+Ad esempio $N = 630$ è ammissibile in quanto è pari e i suoi distinti fattori primi sono i primi consecutivi 2, 3, 5 e 7. Il numero primo successivo a 631 è 641; quindi il numero pseudo-fortunato per 630 è $M = 11$. Si può anche vedere che il numero pseudo-fortunato per 16 è 3.
-Find the sum of all distinct pseudo-Fortunate numbers for admissible numbers $N$ less than ${10}^9$.
+Trova la somma di tutti i numeri pseudo-fortunati distinti per i numeri ammissibili $N$ minori di ${10}^9$.
# --hints--
-`pseudoFortunateNumbers()` should return `2209`.
+`pseudoFortunateNumbers()` dovrebbe restituire `2209`.
```js
assert.strictEqual(pseudoFortunateNumbers(), 2209);
diff --git a/curriculum/challenges/portuguese/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md b/curriculum/challenges/portuguese/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
index 96594e33c40..1b5d4b448a7 100644
--- a/curriculum/challenges/portuguese/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
+++ b/curriculum/challenges/portuguese/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
@@ -10,7 +10,7 @@ dashedName: remove-an-element-using-jquery
Agora vamos remover um elemento HTML da sua página usando jQuery.
-jQuery has a function called `.remove()` that will remove an HTML element entirely.
+O jQuery possui uma função chamada `.remove()` que removerá completamente um elemento HTML.
Remova o elemento `#target4` da sua página usando a função `.remove()`.
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6406bb32f9ed593f26c33b2b.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6406bb32f9ed593f26c33b2b.md
index e030a06e0fc..a4dd0e45f28 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6406bb32f9ed593f26c33b2b.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6406bb32f9ed593f26c33b2b.md
@@ -7,19 +7,19 @@ dashedName: step-6
# --description--
-Remember that `.getElementsByClassName()` returns an array-like object. You can use the spread operator to convert it into an array.
+Lembre-se de que `.getElementsByClassName()` retorna um objeto do tipo array. Você pode usar o operador spread para convertê-lo em um array.
-Convert the `document.getElementsByClassName()` call to an array with the spread operator and assign it to a variable called `inputValues`.
+Converta a chamada de `document.getElementsByClassName()` em um array com o operador spread e atribua esse array a uma variável chamada `inputValues`.
# --hints--
-You should use the spread operator on `document.getElementsByClassName()`.
+Você deve usar o operador spread com `document.getElementsByClassName()`.
```js
assert.match(code, /\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)/);
```
-You should wrap the spread operator and `.getElementsByClassName()` in square brackets to create an array.
+Você deve encapsular o operador spread e `.getElementsByClassName()` entre colchetes para criar um array.
```js
assert.match(code, /\[\s*\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)\s*\]/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407b940b8983005578d0824.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407b940b8983005578d0824.md
index d94d66c7e18..14707ce9b5e 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407b940b8983005578d0824.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407b940b8983005578d0824.md
@@ -7,31 +7,31 @@ dashedName: step-7
# --description--
-You need to get the values from your `select` elements. However, these values are strings, and you need them to be numbers.
+Você precisa obter os valores dos elementos `select`. No entanto, esses valores são strings. Você precisa que elas sejam números.
-Since you have an array, you can use the `map` method to convert each value to a number. Do this by passing a callback function to `map` that takes a `dropdown` parameter and returns `Number(dropdown.value)`.
+Como você tem um array, você pode usar o método `map` para converter cada valor em um número. Faça isso passando uma função de callback para `map` que receba um parâmetro `dropdown` e retorne `Number(dropdown.value)`.
# --hints--
-You should chain the `map` method directly on your array.
+Você deve encadear o método `map` diretamente em seu array.
```js
assert.match(code, /inputValues\s*=\s*\[\s*\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)\s*\]\s*\.map\(/);
```
-Your `map` callback function should use arrow function syntax.
+A função de callback de `map` deve usar a sintaxe das arrow functions.
```js
assert.match(code, /inputValues\s*=\s*\[\s*\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)\s*\]\s*\.map\s*\(\s*\(?dropdown?\)?\s*\s*=>/);
```
-Your `map` callback function should take a `dropdown` parameter.
+A função de callback de `map` deve receber um parâmetro `dropdown`.
```js
assert.match(code, /inputValues\s*=\s*\[\s*\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)\s*\]\s*\.map\s*\(\s*\(?dropdown\s*\)?\s*=>/);
```
-Your `map` callback function should implicitly return `Number(dropdown.value)`.
+A função de callback de `map` deve retornar implicitamente `Number(dropdown.value)`.
```js
assert.match(code, /inputValues\s*=\s*\[\s*\.\.\.document\.getElementsByClassName\(\s*('|"|`)values-dropdown\1\s*\)\s*\]\s*\.map\s*\(\s*\(?dropdown\s*\)?\s*=>\s*Number\s*\(\s*dropdown\.value\s*\)/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c303b4272606c019f338.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c303b4272606c019f338.md
index b19ce1dc4af..10fd2a77222 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c303b4272606c019f338.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c303b4272606c019f338.md
@@ -7,9 +7,9 @@ dashedName: step-8
# --description--
-You need a function to update the display with the sorted numbers. Start by using arrow syntax to declare an `updateUI` function that takes a single `array` parameter.
+Você precisa de uma função para atualizar a exibição dos números ordenados. Comece usando a sintaxe das arrow functions para declarar uma função `updateUI`, que recebe um único parâmetro `array`.
-Because you will be writing algorithms that won't immediately have a return value, set a fallback value for `array` to be an empty array. Here is an example of a function that has a fallback value:
+Como você escreverá algoritmos que não terão um valor de retorno imediato, defina um valor de fallback para `array` que seja um array vazio. Aqui vemos um exemplo de uma função que tem um valor de fallback:
```js
const myFunction = (string = "") => {
@@ -19,37 +19,37 @@ const myFunction = (string = "") => {
# --hints--
-You should use `const` to declare an `updateUI` variable.
+Você deve usar `const` para declarar uma variável `updateUI`.
```js
assert.match(code, /const\s+updateUI\s*=/);
```
-`updateUI` should be a function.
+`updateUI` deve ser uma função.
```js
assert.isFunction(updateUI);
```
-`updateUI` should use arrow syntax.
+`updateUI` deve usar a sintaxe das arrow functions.
```js
assert.match(code, /const\s+updateUI\s*=\s*\(.*\)\s*=>/);
```
-`updateUI` should take a single `array` parameter.
+`updateUI` deve receber um único parâmetro `array`.
```js
assert.match(code, /const\s+updateUI\s*=\s*\(\s*array/);
```
-`updateUI` should have a fallback value of an empty array for `array`.
+`updateUI` deve ter como valor de fallback para `array` um array vazio.
```js
assert.match(code, /const\s+updateUI\s*=\s*\(\s*array\s*=\s*\[\s*\]\s*\)/);
```
-`updateUI` should be empty.
+`updateUI` deve estar vazia.
```js
assert.match(code, /const\s+updateUI\s*=\s*\(\s*array\s*=\s*\[\s*\]\s*\)\s*=>\s*{\s*}/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c6a2c2159309994779a5.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c6a2c2159309994779a5.md
index 63b1c82d429..c38369ce37b 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c6a2c2159309994779a5.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6407c6a2c2159309994779a5.md
@@ -7,17 +7,17 @@ dashedName: step-11
# --description--
-Set the `innerText` property of `outputValueNode` to `num`.
+Defina a propriedade `innerText` de `outputValueNode` como `num`.
# --hints--
-You should use `innerText` to set the text of `outputValueNode`.
+Você deve usar `innerText` para definir o texto de `outputValueNode`.
```js
assert.match(code, /array\.forEach\s*\(\s*\(\s*num\s*,\s*i\s*\)\s*=>\s*\{\s*const\s*outputValueNode\s*=\s*document\.getElementById\s*\(\s*`output-value-\$\{i\}`\s*\)\s*;?\s*outputValueNode\.innerText/)
```
-You should use `innerText` to set the text of `outputValueNode` to `num`.
+Você deve usar `innerText` para definir o texto de `outputValueNode` como `num`.
```js
assert.match(code, /array\.forEach\s*\(\s*\(\s*num\s*,\s*i\s*\)\s*=>\s*\{\s*const\s*outputValueNode\s*=\s*document\.getElementById\s*\(\s*`output-value-\$\{i\}`\s*\)\s*;?\s*outputValueNode\.innerText\s*=\s*num;?/)
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f149110ec60fd40fcfe1.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f149110ec60fd40fcfe1.md
index 1d105146ee7..110cf397f80 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f149110ec60fd40fcfe1.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f149110ec60fd40fcfe1.md
@@ -7,13 +7,13 @@ dashedName: step-22
# --description--
-É a hora de implementar outro algoritmo de ordenação. This time, you'll be implementing a selection sort. Selection sort works by finding the smallest value in the array, then swapping it with the first value in the array. Then, it finds the next smallest value in the array, and swaps it with the second value in the array. It continues iterating through the array until it is completely sorted.
+É a hora de implementar outro algoritmo de ordenação. Desta vez, você implementará uma ordenação de seleção. A ordenação de seleção (em inglês, Selection Sort) funciona a partir da seleção do valor mínimo de um array, trocando-o de posição posteriormente com o primeiro valor na lista. Em seguida, a ordenação encontra o próximo valor menor e o troca pelo segundo valor do array. Ela seguirá percorrendo o array até que ele esteja completamente ordenado.
-Start by declaring a `selectionSort` variable and assigning it an arrow function that takes an `array` parameter.
+Comece declarando uma variável `selectionSort` e atribuindo a ela uma arrow function que recebe um parâmetro `array`.
# --hints--
-You should use `const` to declare a `selectionSort` variable.
+Você deve usar `const` para declarar a variável `selectionSort`.
```js
assert.match(code, /const\s+selectionSort\s*=/);
@@ -25,19 +25,19 @@ assert.match(code, /const\s+selectionSort\s*=/);
assert.isFunction(selectionSort);
```
-`selectionSort` should use arrow syntax.
+`selectionSort` deve usar a sintaxe das arrow functions.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(?.*\)?\s*=>/);
```
-`selectionSort` should take a single `array` parameter.
+`selectionSort` deve receber um único parâmetro `array`.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(?\s*array/);
```
-`selectionSort` should be empty.
+`selectionSort` deve estar vazia.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(?\s*array\s*\)?\s*=>\s*{\s*}/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f97a721cd1144804b7a8.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f97a721cd1144804b7a8.md
index be9a854092b..e2b7cd9ec82 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f97a721cd1144804b7a8.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/6410f97a721cd1144804b7a8.md
@@ -7,35 +7,35 @@ dashedName: step-24
# --description--
-Like a bubble sort, a selection sort needs to iterate through the array. Declare a `for` loop to do so.
+Assim como na ordenação de bolha (Bubble Sort), uma ordenação de seleção precisa percorrer o array. Declare um laço `for` para fazer isso.
# --hints--
-You should use a `for` loop.
+Você deve usar um laço `for`.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(\s*array\s*\)\s*=>\s*{\s*for\s*\(/);
```
-Your `for` loop should initialize a variable `i` to `0`.
+O laço `for` deve inicializar uma variável `i` como `0`.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(\s*array\s*\)\s*=>\s*{\s*for\s*\(\s*let\s+i\s*=\s*0\s*;\s*/);
```
-Your `for` loop should have a condition that checks if the value of `i` is less than the length of the array.
+O laço `for` deve ter uma condição que verifica se o valor de `i` é menor do que o comprimento do array.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(\s*array\s*\)\s*=>\s*{\s*for\s*\(\s*let\s+i\s*=\s*0\s*;\s*i\s*<\s*array\.length\s*;\s*/);
```
-Your `for` loop should increment `i` by `1` each time it runs.
+O laço `for` deve incrementar `i` em `1` a cada vez que é executado.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(\s*array\s*\)\s*=>\s*{\s*for\s*\(\s*let\s+i\s*=\s*0\s*;\s*i\s*<\s*array\.length\s*;\s*i\s*\+\+\s*/);
```
-Your `for` loop should have an empty body.
+O laço `for` deve estar vazio.
```js
assert.match(code, /const\s+selectionSort\s*=\s*\(\s*array\s*\)\s*=>\s*{\s*for\s*\(\s*let\s+i\s*=\s*0\s*;\s*i\s*<\s*array\.length\s*;\s*i\s*\+\+\s*\)\s*{\s*}\s*}/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110377201e7b1a0de0d558.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110377201e7b1a0de0d558.md
index 801ce4c1de8..323ba2bb0ee 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110377201e7b1a0de0d558.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110377201e7b1a0de0d558.md
@@ -7,17 +7,17 @@ dashedName: step-23
# --description--
-Update your `sortedValues` variable to be the result of calling `selectionSort` instead of `bubbleSort`.
+Atualize sua variável `sortedValues` para que seja o resultado da chamada de `selectionSort` ao invés de `bubbleSort`.
# --hints--
-Your `sortedValues` variable should be assigned the value of calling `selectionSort` with your `inputValues` array.
+A variável `sortedValues` deve receber por atribuição o valor da chamada de `selectionSort` com o array `inputValues`.
```js
assert.match(code, /const\s+sortedValues\s*=\s*selectionSort\s*\(\s*inputValues\s*\)/);
```
-You should not call `bubbleSort` in your code.
+Você não deve chamar `bubbleSort` no seu código.
```js
assert.notMatch(code, /bubbleSort\s*\(/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110998bc00321fd8052ab5.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110998bc00321fd8052ab5.md
index 06fd715e75d..2a22f113269 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110998bc00321fd8052ab5.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110998bc00321fd8052ab5.md
@@ -7,13 +7,13 @@ dashedName: step-30
# --description--
-The last sorting algorithm you will implement is the insertion sort. This algorithm works by building up a sorted array at the beginning of the list. Ele inicia o array ordenado com o primeiro elemento. Then it inspects the next element and swaps it backward into the sorted array until it is in a sorted position, and so on.
+O último algoritmo de ordenação que você implementará é a ordenação de inserção. Esse algoritmo funciona criando um array ordenado no início da lista. Ele inicia o array ordenado com o primeiro elemento. Depois, ele inspeciona o próximo elemento e o lança para trás no array ordenado até ficar em posição ordenada – e assim por diante.
-Start by declaring an `insertionSort` variable and assigning it an arrow function which takes an `array` parameter.
+Comece declarando uma variável `insertionSort` e atribuindo a ela uma arrow function que recebe um parâmetro `array`.
# --hints--
-You should use `const` to declare an `insertionSort` variable.
+Você deve usar `const` para declarar a variável `insertionSort`.
```js
assert.match(code, /const\s+insertionSort\s*=/);
@@ -25,19 +25,19 @@ assert.match(code, /const\s+insertionSort\s*=/);
assert.isFunction(insertionSort);
```
-`insertionSort` should use arrow syntax.
+`insertionSort` deve usar a sintaxe das arrow functions.
```js
assert.match(code, /const\s+insertionSort\s*=\s*\(?.*\)?\s*=>/);
```
-`insertionSort` should take a single `array` parameter.
+`insertionSort` deve receber um único parâmetro `array`.
```js
assert.match(code, /const\s+insertionSort\s*=\s*\(?\s*array/);
```
-`insertionSort` should be empty.
+`insertionSort` deve estar vazia.
```js
assert.match(code, /const\s+insertionSort\s*=\s*\(?\s*array\s*\)?\s*=>\s*{\s*}/);
diff --git a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110a03f6a450209b01f45c.md b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110a03f6a450209b01f45c.md
index 55ef4d012e1..9ea5f5e172f 100644
--- a/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110a03f6a450209b01f45c.md
+++ b/curriculum/challenges/portuguese/15-javascript-algorithms-and-data-structures-22/learn-basic-algorithmic-thinking-by-building-a-number-sorter/64110a03f6a450209b01f45c.md
@@ -7,7 +7,7 @@ dashedName: step-31
# --description--
-As before, update your `sortedValues` variable to be the result of `insertionSort` instead of `selectionSort`.
+Como antes, atualize sua variável `sortedValues` para que seja o resultado da chamada de `insertionSort` ao invés de `selectionSort`.
# --hints--
diff --git a/curriculum/challenges/portuguese/16-the-odin-project/top-learn-css-foundations-projects/css-foundations-exercise-d.md b/curriculum/challenges/portuguese/16-the-odin-project/top-learn-css-foundations-projects/css-foundations-exercise-d.md
index aef6c9105a4..d25152cb1dd 100644
--- a/curriculum/challenges/portuguese/16-the-odin-project/top-learn-css-foundations-projects/css-foundations-exercise-d.md
+++ b/curriculum/challenges/portuguese/16-the-odin-project/top-learn-css-foundations-projects/css-foundations-exercise-d.md
@@ -7,51 +7,51 @@ dashedName: css-foundations-exercise-d
# --description--
-With this exercise, we've provided you a completed HTML file, so you will only have to edit the CSS file. For this exercise, it's more important to understand how chaining different selectors works than how to actually add the attributes.
+Com este exercício, fornecemos um arquivo HTML completo. Então, você só precisará editar o arquivo CSS. Para este exercício, é mais importante entender como funciona o encadeamento de diferentes seletores do que como adicionar de fato os atributos.
-1. You should see a `width` of `300px` on the `avatar` and `proportioned` class.
-1. You should give it a height so that it retains its original square proportions (don't hardcode in a pixel value for the height!).
-1. You should give the elements with both the `avatar` and `distorted` classes a `width` of `200px`.
-1. You should give it a `height` twice as big as it's width.
+1. Você deve ver uma `width` de `300px` na classe `avatar` e na classe `proportioned`.
+1. Você deve dar uma altura para que ele mantenha suas proporções quadradas originais (não coloque diretamente no código um valor de pixel para a altura).
+1. Você deve dar aos elementos com as classes `avatar` e `distorted` uma `width` de `200px`.
+1. Você deve dar a eles uma `height` duas vezes maior que a largura (width).
# --hints--
-You should have a `width` of `300px` on the `avatar` and `proportioned` class.
+Você deve ter uma `width` de `300px` na classe `avatar` e na classe `proportioned`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.proportioned`) || new __helpers.CSSHelp(document).getStyle(`.proportioned.avatar`);
assert(style?.width === '300px');
```
-You should have a height of `auto` on the `avatar` and `proportioned` class.
+Você deve ter uma altura de `auto` nas classes `avatar` e `proportioned`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.proportioned`) || new __helpers.CSSHelp(document).getStyle(`.proportioned.avatar`)
assert(style?.height === 'auto');
```
-You should use a chaining selector on the `avatar` and `proportioned` class.
+Você deve usar um seletor de encadeamento nas classes `avatar` e `proportioned`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.proportioned`) || new __helpers.CSSHelp(document).getStyle(`.proportioned.avatar`);
assert(style);
```
-You should have a `width` of `200px` on the `avatar` and `distorted` class.
+Você deve ter uma `width` de `200px` na classe `avatar` e na classe `distorted`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.distorted`) || new __helpers.CSSHelp(document).getStyle(`.distorted.avatar`);
assert(style?.width === '200px');
```
-You should use a chaining selector on the `avatar` and `distorted` class.
+Você deve usar um seletor de encadeamento nas classes `avatar` e `distorted`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.distorted`) || new __helpers.CSSHelp(document).getStyle(`.distorted.avatar`);
assert(style);
```
-You should have a `height` two times the width on the `avatar` and `distorted` class.
+Você deve ter uma `height` duas vezes maior que a largura nas classes `avatar` e `distorted`.
```js
const style = new __helpers.CSSHelp(document).getStyle(`.avatar.distorted`) || new __helpers.CSSHelp(document).getStyle(`.distorted.avatar`);