From d40d0e6145e15edae7dd6b3a8432c7ada88087fe Mon Sep 17 00:00:00 2001
From: camperbot <camperbot@users.noreply.github.com>
Date: Mon, 15 May 2023 19:36:59 +0530
Subject: [PATCH] chore(i18n,learn): processed translations (#50391)

---
 .../data-cleaning-and-visualizations.md       |  4 +-
 .../loading-data-and-advanced-indexing.md     |  2 +-
 .../port-scanner.md                           |  4 +-
 .../sha-1-password-cracker.md                 | 14 ++---
 .../stock-price-checker.md                    |  2 +-
 ...ur-site-via-https-only-with-helmet.hsts.md |  2 +-
 ...lmet-using-the-parent-helmet-middleware.md |  6 +--
 ...client-side-caching-with-helmet.nocache.md |  4 +-
 ...fetching-with-helmet.dnsprefetchcontrol.md |  6 +--
 ...ash-and-compare-passwords-synchronously.md |  4 +-
 ...-information-using-helmet.hidepoweredby.md |  4 +-
 .../install-and-require-helmet.md             |  2 +-
 ...-of-clickjacking-with-helmet.frameguard.md |  4 +-
 ...pting-xss-attacks-with-helmet.xssfilter.md |  8 +--
 ...ing-untrusted-html-with-helmet.ienoopen.md |  2 +-
 ...olicy-with-helmet.contentsecuritypolicy.md | 10 ++--
 .../understand-bcrypt-hashes.md               |  6 +--
 .../introduction-and-setup.md                 |  2 +-
 .../data-structures/create-a-queue-class.md   |  6 +--
 ...ete-a-leaf-node-in-a-binary-search-tree.md |  2 +-
 .../data-structures/invert-a-binary-tree.md   |  2 +-
 ...erform-a-difference-on-two-sets-of-data.md |  2 +-
 ...form-a-subset-check-on-two-sets-of-data.md |  8 +--
 ...orm-an-intersection-on-two-sets-of-data.md |  2 +-
 .../data-structures/typed-arrays.md           |  4 +-
 .../use-.has-and-.size-on-an-es6-set.md       |  2 +-
 ...pread-and-notes-for-es5-set-integration.md |  2 +-
 .../rosetta-code/24-game.md                   |  4 +-
 .../9-billion-names-of-god-the-integer.md     |  2 +-
 .../rosetta-code/abc-problem.md               | 16 +++---
 ...ient-and-perfect-number-classifications.md |  8 +--
 .../rosetta-code/accumulator-factory.md       |  6 +--
 .../rosetta-code/ackermann-function.md        | 10 ++--
 .../rosetta-code/align-columns.md             |  2 +-
 .../rosetta-code/amicable-pairs.md            | 12 ++---
 .../rosetta-code/averages-mode.md             |  2 +-
 .../averages-pythagorean-means.md             |  2 +-
 .../rosetta-code/averages-root-mean-square.md |  4 +-
 .../rosetta-code/babbage-problem.md           |  2 +-
 .../rosetta-code/balanced-brackets.md         | 40 +++++++-------
 ...cles-of-given-radius-through-two-points.md | 14 ++---
 .../rosetta-code/closest-pair-problem.md      |  4 +-
 .../rosetta-code/combinations.md              | 10 ++--
 .../rosetta-code/comma-quibbling.md           | 12 ++---
 .../rosetta-code/compare-a-list-of-strings.md | 26 +++++-----
 .../convert-seconds-to-compound-duration.md   |  8 +--
 .../count-occurrences-of-a-substring.md       |  8 +--
 .../rosetta-code/count-the-coins.md           |  8 +--
 .../rosetta-code/cramers-rule.md              |  6 +--
 .../cumulative-standard-deviation.md          | 14 ++---
 .../rosetta-code/cusip.md                     | 22 ++++----
 .../rosetta-code/cut-a-rectangle.md           | 14 ++---
 .../rosetta-code/date-format.md               |  4 +-
 .../rosetta-code/date-manipulation.md         | 14 ++---
 .../rosetta-code/day-of-the-week.md           |  8 +--
 .../rosetta-code/deal-cards-for-freecell.md   | 10 ++--
 .../rosetta-code/deepcopy.md                  |  4 +-
 .../define-a-primitive-data-type.md           |  6 +--
 .../rosetta-code/department-numbers.md        |  2 +-
 .../rosetta-code/discordian-date.md           | 16 +++---
 .../rosetta-code/dot-product.md               | 14 ++---
 .../rosetta-code/element-wise-operations.md   | 16 +++---
 .../rosetta-code/emirp-primes.md              | 10 ++--
 .../rosetta-code/entropy.md                   | 14 ++---
 .../rosetta-code/equilibrium-index.md         | 14 ++---
 .../rosetta-code/ethiopian-multiplication.md  | 16 +++---
 .../rosetta-code/euler-method.md              | 14 ++---
 .../evaluate-binomial-coefficients.md         | 12 ++---
 .../execute-a-markov-algorithm.md             | 14 ++---
 .../extensible-prime-generator.md             | 10 ++--
 .../rosetta-code/factorial.md                 | 12 ++---
 .../factors-of-a-mersenne-number.md           | 10 ++--
 .../rosetta-code/factors-of-an-integer.md     |  8 +--
 .../rosetta-code/farey-sequence.md            | 12 ++---
 .../fibonacci-n-step-number-sequences.md      | 16 +++---
 .../rosetta-code/fibonacci-sequence.md        |  4 +-
 .../rosetta-code/fibonacci-word.md            |  8 +--
 .../rosetta-code/fizzbuzz.md                  |  6 +--
 .../rosetta-code/fractran.md                  | 12 ++---
 .../rosetta-code/gamma-function.md            | 18 +++----
 .../rosetta-code/gaussian-elimination.md      | 14 ++---
 .../rosetta-code/general-fizzbuzz.md          | 22 ++++----
 .../generate-lower-case-ascii-alphabet.md     | 16 +++---
 .../rosetta-code/generator-exponential.md     | 14 ++---
 .../rosetta-code/gray-code.md                 | 20 +++----
 .../rosetta-code/greatest-common-divisor.md   | 16 +++---
 .../greatest-subsequential-sum.md             | 16 +++---
 .../rosetta-code/hailstone-sequence.md        | 10 ++--
 .../rosetta-code/happy-numbers.md             | 26 +++++-----
 .../rosetta-code/harshad-or-niven-series.md   |  8 +--
 .../rosetta-code/hash-from-two-arrays.md      | 16 +++---
 .../rosetta-code/hash-join.md                 |  8 +--
 .../rosetta-code/heronian-triangles.md        | 10 ++--
 .../hofstadter-figure-figure-sequences.md     | 24 ++++-----
 .../rosetta-code/hofstadter-q-sequence.md     | 12 ++---
 .../rosetta-code/i-before-e-except-after-c.md | 20 +++----
 .../rosetta-code/iban.md                      | 14 ++---
 .../rosetta-code/identity-matrix.md           | 10 ++--
 .../rosetta-code/iterated-digits-squaring.md  | 16 +++---
 .../rosetta-code/jaro-distance.md             | 16 +++---
 .../rosetta-code/jortsort.md                  | 16 +++---
 .../rosetta-code/josephus-problem.md          | 14 ++---
 .../rosetta-code/k-d-tree.md                  | 16 +++---
 .../rosetta-code/kaprekar-numbers.md          | 18 +++----
 .../rosetta-code/knapsack-problem-0-1.md      | 12 ++---
 .../rosetta-code/knapsack-problem-bounded.md  | 10 ++--
 .../knapsack-problem-continuous.md            | 12 ++---
 .../knapsack-problem-unbounded.md             | 10 ++--
 .../rosetta-code/knights-tour.md              | 14 ++---
 .../largest-int-from-concatenated-ints.md     | 14 ++---
 .../rosetta-code/last-friday-of-each-month.md | 20 +++----
 .../rosetta-code/last-letter-first-letter.md  | 14 ++---
 .../rosetta-code/leap-year.md                 | 16 +++---
 .../rosetta-code/least-common-multiple.md     | 14 ++---
 .../rosetta-code/left-factorials.md           | 18 +++----
 .../rosetta-code/letter-frequency.md          | 16 +++---
 .../rosetta-code/levenshtein-distance.md      | 18 +++----
 .../linear-congruential-generator.md          | 14 ++---
 .../rosetta-code/long-multiplication.md       | 14 ++---
 .../longest-common-subsequence.md             | 14 ++---
 .../longest-increasing-subsequence.md         | 16 +++---
 .../rosetta-code/longest-string-challenge.md  | 14 ++---
 .../rosetta-code/look-and-say-sequence.md     | 18 +++----
 ...oop-over-multiple-arrays-simultaneously.md | 16 +++---
 .../rosetta-code/lu-decomposition.md          | 16 +++---
 .../rosetta-code/lucas-lehmer-test.md         | 16 +++---
 .../rosetta-code/ludic-numbers.md             | 16 +++---
 .../luhn-test-of-credit-card-numbers.md       | 18 +++----
 .../rosetta-code/lychrel-numbers.md           | 16 +++---
 .../rosetta-code/lzw-compression.md           | 18 +++----
 .../rosetta-code/s-expressions.md             |  6 +--
 .../sailors-coconuts-and-a-monkey-problem.md  |  8 +--
 .../rosetta-code/search-a-list-of-records.md  | 14 ++---
 .../rosetta-code/sedols.md                    | 10 ++--
 .../rosetta-code/self-describing-numbers.md   | 10 ++--
 .../rosetta-code/self-referential-sequence.md | 14 ++---
 .../rosetta-code/semiprime.md                 | 24 ++++-----
 .../rosetta-code/set-consolidation.md         | 26 +++++-----
 .../rosetta-code/set-of-real-numbers.md       | 26 +++++-----
 .../rosetta-code/sha-1.md                     | 14 ++---
 .../rosetta-code/sha-256.md                   | 14 ++---
 .../sort-an-array-of-composite-structures.md  | 10 ++--
 .../rosetta-code/sort-disjoint-sublist.md     | 14 ++---
 .../rosetta-code/sort-stability.md            | 14 ++---
 .../sort-using-a-custom-comparator.md         | 14 ++---
 .../sorting-algorithms-bead-sort.md           | 12 ++---
 .../sorting-algorithms-bogosort.md            | 14 ++---
 .../sorting-algorithms-cocktail-sort.md       | 14 ++---
 .../sorting-algorithms-comb-sort.md           | 12 ++---
 .../sorting-algorithms-gnome-sort.md          | 14 ++---
 .../sorting-algorithms-pancake-sort.md        | 16 +++---
 .../sorting-algorithms-permutation-sort.md    | 14 ++---
 .../sorting-algorithms-shell-sort.md          | 14 ++---
 .../sorting-algorithms-stooge-sort.md         | 14 ++---
 .../sorting-algorithms-strand-sort.md         | 14 ++---
 .../rosetta-code/soundex.md                   | 28 +++++-----
 .../rosetta-code/spiral-matrix.md             | 10 ++--
 ...ter-string-based-on-change-of-character.md | 14 ++---
 .../rosetta-code/state-name-puzzle.md         | 10 ++--
 .../rosetta-code/stern-brocot-sequence.md     | 14 ++---
 .../rosetta-code/straddling-checkerboard.md   | 20 +++----
 .../rosetta-code/stream-merge.md              | 14 ++---
 ...s-and-extended-characters-from-a-string.md | 14 ++---
 .../rosetta-code/subleq.md                    |  6 +--
 .../rosetta-code/sudoku.md                    | 10 ++--
 .../rosetta-code/sum-digits-of-an-integer.md  | 16 +++---
 .../rosetta-code/sum-multiples-of-3-and-5.md  | 14 ++---
 .../rosetta-code/sum-of-a-series.md           | 14 ++---
 .../rosetta-code/sum-of-squares.md            | 14 ++---
 .../rosetta-code/sum-to-100.md                | 16 +++---
 .../sutherland-hodgman-polygon-clipping.md    | 10 ++--
 .../rosetta-code/symmetric-difference.md      | 16 +++---
 .../rosetta-code/taxicab-numbers.md           | 10 ++--
 .../tokenize-a-string-with-escaping.md        |  8 +--
 .../rosetta-code/top-rank-per-group.md        |  4 +-
 .../rosetta-code/topological-sort.md          | 12 ++---
 .../rosetta-code/towers-of-hanoi.md           |  4 +-
 .../rosetta-code/vector-cross-product.md      |  6 +--
 .../rosetta-code/vector-dot-product.md        | 16 +++---
 .../rosetta-code/word-frequency.md            | 16 +++---
 .../rosetta-code/word-wrap.md                 |  8 +--
 .../rosetta-code/y-combinator.md              | 12 ++---
 .../zeckendorf-number-representation.md       | 46 ++++++++--------
 .../zhang-suen-thinning-algorithm.md          | 10 ++--
 .../build-a-tic-tac-toe-game.md               |  2 +-
 .../chart-the-stock-market.md                 |  2 +-
 .../p2p-video-chat-application.md             |  2 +-
 .../deep-learning-demystified.md              |  2 +-
 .../book-recommendation-engine-using-knn.md   |  4 +-
 .../cat-and-dog-image-classifier.md           | 18 +++----
 .../tensorflow/core-learning-algorithms.md    |  4 +-
 .../tensorflow/introduction-to-tensorflow.md  |  2 +-
 ...processing-with-rnns-building-the-model.md |  2 +-
 .../exponents-and-logarithms.md               |  2 +-
 .../ratios-and-proportions-extra.md           |  2 +-
 .../jquery/remove-an-element-using-jquery.md  |  2 +-
 .../problem-244-sliders.md                    | 16 +++---
 .../problem-245-coresilience.md               | 16 +++---
 .../problem-246-tangents-to-an-ellipse.md     | 26 +++++-----
 .../problem-247-squares-under-a-hyperbola.md  | 24 ++++-----
 ...which-eulers-totient-function-equals-13.md |  8 +--
 .../problem-249-prime-subset-sums.md          | 10 ++--
 .../problem-250-250250.md                     |  6 +--
 .../problem-251-cardano-triplets.md           | 12 ++---
 .../problem-252-convex-holes.md               | 14 ++---
 .../problem-253-tidying-up.md                 | 52 +++++++++----------
 .../problem-254-sums-of-digit-factorials.md   | 16 +++---
 .../problem-255-rounded-square-roots.md       | 30 +++++------
 .../problem-256-tatami-free-rooms.md          | 24 ++++-----
 .../problem-257-angular-bisectors.md          | 14 ++---
 ...problem-258-a-lagged-fibonacci-sequence.md | 12 ++---
 .../problem-259-reachable-numbers.md          | 22 ++++----
 .../problem-260-stone-game.md                 | 30 +++++------
 .../problem-261-pivotal-square-sums.md        | 10 ++--
 .../problem-262-mountain-range.md             | 16 +++---
 ...roblem-263-an-engineers-dream-come-true.md | 24 ++++-----
 .../problem-264-triangle-centres.md           | 22 ++++----
 .../problem-265-binary-circles.md             | 18 +++----
 .../problem-266-pseudo-square-root.md         | 14 ++---
 .../problem-267-billionaire.md                | 16 +++---
 ...ur-distinct-prime-factors-less-than-100.md |  8 +--
 ...ynomials-with-at-least-one-integer-root.md | 24 ++++-----
 .../problem-270-cutting-squares.md            | 18 +++----
 .../problem-271-modular-cubes-part-1.md       | 10 ++--
 .../problem-272-modular-cubes-part-2.md       | 10 ++--
 .../problem-273-sum-of-squares.md             | 16 +++---
 .../problem-274-divisibility-multipliers.md   | 20 +++----
 .../problem-275-balanced-sculptures.md        | 22 ++++----
 .../problem-276-primitive-triangles.md        | 10 ++--
 ...problem-277-a-modified-collatz-sequence.md | 24 ++++-----
 ...m-278-linear-combinations-of-semiprimes.md | 12 ++---
 ...th-integral-sides-and-an-integral-angle.md |  6 +--
 .../problem-280-ant-and-seeds.md              | 10 ++--
 .../problem-281-pizza-toppings.md             | 14 ++---
 .../problem-282-the-ackermann-function.md     | 10 ++--
 ...h-the-area--perimeter-ratio-is-integral.md | 14 ++---
 .../problem-284-steady-squares.md             | 14 ++---
 .../problem-285-pythagorean-odds.md           | 14 ++---
 .../problem-286-scoring-probabilities.md      | 10 ++--
 ...encoding-a-simple-compression-algorithm.md | 34 ++++++------
 .../problem-288-an-enormous-factorial.md      | 14 ++---
 .../problem-289-eulerian-cycles.md            | 18 +++----
 .../problem-290-digital-signature.md          |  6 +--
 .../problem-291-panaitopol-primes.md          |  8 +--
 .../problem-292-pythagorean-polygons.md       | 22 ++++----
 .../problem-293-pseudo-fortunate-numbers.md   | 14 ++---
 .../jquery/remove-an-element-using-jquery.md  |  2 +-
 .../6406bb32f9ed593f26c33b2b.md               |  8 +--
 .../6407b940b8983005578d0824.md               | 12 ++---
 .../6407c303b4272606c019f338.md               | 16 +++---
 .../6407c6a2c2159309994779a5.md               |  6 +--
 .../6410f149110ec60fd40fcfe1.md               | 12 ++---
 .../6410f97a721cd1144804b7a8.md               | 12 ++---
 .../64110377201e7b1a0de0d558.md               |  6 +--
 .../64110998bc00321fd8052ab5.md               | 12 ++---
 .../64110a03f6a450209b01f45c.md               |  2 +-
 .../css-foundations-exercise-d.md             | 22 ++++----
 257 files changed, 1589 insertions(+), 1589 deletions(-)

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:
 
 <pre>
 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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-port-scanne
 -   Wähle `Use run command` und klicke auf die `Done`-Schaltfläche.
 
 
-Wir sind noch dabei, den interaktiven Teil des Python-Kurses zu entwickeln. For now, here are some videos on the freeCodeCamp.org YouTube channel that will teach you everything you need to know to complete this project:
+Wir sind noch dabei, den interaktiven Teil des Python-Kurses zu entwickeln. Hier sind einige Videos auf dem freeCodeCamp.org YouTube-Kanal, die dir alles beibringen, was du wissen musst, um dieses Projekt abzuschließen:
 
 - <a href="https://www.freecodecamp.org/news/python-for-everybody/" target="_blank" rel="noopener noreferrer nofollow">Videokurs: Python für jedermann</a> (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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-SHA-1-passw
 -   Wähle `Use run command` und klicke auf die `Done`-Schaltfläche.
 
 
-Wir sind noch dabei, den interaktiven Teil des Python-Kurses zu entwickeln. For now, here are some videos on the freeCodeCamp.org YouTube channel that will teach you everything you need to know to complete this project:
+Wir sind noch dabei, den interaktiven Teil des Python-Kurses zu entwickeln. Hier sind einige Videos auf dem freeCodeCamp.org YouTube-Kanal, die dir alles beibringen, was du wissen musst, um dieses Projekt abzuschließen:
 
 - <a href="https://www.freecodecamp.org/news/python-for-everybody/" target="_blank" rel="noopener noreferrer nofollow">Python for Everybody Video Course</a> (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. <a href="https://docs.python.org/3/library/hashlib.html" target="_blank" rel="noopener noreferrer nofollow">Learn more about "hashlib" here</a>.
+Die `hashlib`-Bibliothek wurde für dich importiert. You should consider using it in your code. <a href="https://docs.python.org/3/library/hashlib.html" target="_blank" rel="noopener noreferrer nofollow">Erfahre hier mehr über "hashlib" </a>.
 
 ## 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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-`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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
+Zur Erinnerung: Dieses Projekt baut auf dem folgenden Starterprojekt auf: <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a> oder geklont von <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-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 <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-Deine Seite könnte ohne deine Zustimmung in ein `<frame>` oder `<iframe>` gesetzt werden. Dies kann unter anderem zu Clickjacking-Attacken führen. Clickjacking is a technique of tricking a user into interacting with a page different from what the user thinks it is. This can be obtained by executing your page in a malicious context, by means of iframing. In diesem Zusammenhang kann ein Hacker eine versteckte Ebene über deine Seite legen. Hidden buttons can be used to run bad scripts. This middleware sets the X-Frame-Options header. It restricts who can put your site in a frame. Es gibt drei Modi: DENY, SAMEORIGIN und ALLOW-FROM.
+Deine Seite könnte ohne deine Zustimmung in ein `<frame>` oder `<iframe>` gesetzt werden. Dies kann unter anderem zu Clickjacking-Attacken führen. Clickjacking is a technique of tricking a user into interacting with a page different from what the user thinks it is. This can be obtained by executing your page in a malicious context, by means of iframing. In diesem Zusammenhang kann ein Hacker eine versteckte Ebene über deine Seite legen. Versteckte Buttons können verwendet werden, um schlechte Skripte auszuführen. This middleware sets the X-Frame-Options header. It restricts who can put your site in a frame. Es gibt drei Modi: DENY, SAMEORIGIN und ALLOW-FROM.
 
 We don’t need our app to be framed.
 
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-cross-site-scripting-xss-attacks-with-helmet.xssfilter.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-cross-site-scripting-xss-attacks-with-helmet.xssfilter.md
index 2ec2f36fb95..00e2aa15732 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-cross-site-scripting-xss-attacks-with-helmet.xssfilter.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/mitigate-the-risk-of-cross-site-scripting-xss-attacks-with-helmet.xssfilter.md
@@ -1,7 +1,7 @@
 ---
 id: 587d8247367417b2b2512c39
 title: >-
-  Mitigate the Risk of Cross Site Scripting (XSS) Attacks with helmet.xssFilter()
+  Minderung des Risikos von Cross Site Scripting (XSS)-Angriffen mit helmet.xssFilter()
 challengeType: 2
 forumTopicId: 301583
 dashedName: mitigate-the-risk-of-cross-site-scripting-xss-attacks-with-helmet-xssfilter
@@ -15,13 +15,13 @@ Cross-site scripting (XSS) is a frequent type of attack where malicious scripts
 
 The basic rule to lower the risk of an XSS attack is simple: “Never trust user’s input”. As a developer you should always sanitize all the input coming from the outside. This includes data coming from forms, GET query urls, and even from POST bodies. Sanitizing means that you should find and encode the characters that may be dangerous e.g. &lt;, >.
 
-Modern browsers can help mitigating the risk by adopting better software strategies. Often these are configurable via http headers.
+Moderne Browser können helfen, das Risiko zu verringern, indem sie bessere Software-Strategien anwenden. Oft sind diese über HTTP-Header konfigurierbar.
 
-The X-XSS-Protection HTTP header is a basic protection. The browser detects a potential injected script using a heuristic filter. If the header is enabled, the browser changes the script code, neutralizing it. It still has limited support.
+Der X-XSS-Protection HTTP-Header ist ein grundlegender Schutz. Der Browser erkennt ein potenziell eingeschleustes Skript mithilfe eines heuristischen Filters. Wenn die Kopfzeile aktiviert ist, ändert der Browser den Skriptcode und neutralisiert ihn. It still has limited support.
 
 # --instructions--
 
-Use `helmet.xssFilter()` to sanitize input sent to your server.
+Verwende `helmet.xssFilter()`, um die an deinen Server gesendeten Eingaben zu bereinigen.
 
 # --hints--
 
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/prevent-ie-from-opening-untrusted-html-with-helmet.ienoopen.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/prevent-ie-from-opening-untrusted-html-with-helmet.ienoopen.md
index 9cfaef5bd7e..63fb5970225 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/prevent-ie-from-opening-untrusted-html-with-helmet.ienoopen.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/prevent-ie-from-opening-untrusted-html-with-helmet.ienoopen.md
@@ -10,7 +10,7 @@ dashedName: prevent-ie-from-opening-untrusted-html-with-helmet-ienoopen
 
 As a reminder, this project is being built upon the following starter project on <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-Some web applications will serve untrusted HTML for download. Some versions of Internet Explorer by default open those HTML files in the context of your site. This means that an untrusted HTML page could start doing bad things in the context of your pages. This middleware sets the X-Download-Options header to noopen. This will prevent IE users from executing downloads in the trusted site’s context.
+Some web applications will serve untrusted HTML for download. Einige Versionen des Internet Explorer öffnen diese HTML-Dateien standardmäßig im Kontext Ihrer Website. Das bedeutet, dass eine nicht vertrauenswürdige HTML-Seite im Zusammenhang mit deinen Seiten unerwünschte Dinge tun könnte. This middleware sets the X-Download-Options header to noopen. This will prevent IE users from executing downloads in the trusted site’s context.
 
 # --instructions--
 
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/set-a-content-security-policy-with-helmet.contentsecuritypolicy.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/set-a-content-security-policy-with-helmet.contentsecuritypolicy.md
index 52449b8b2d6..a7552280c2f 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/set-a-content-security-policy-with-helmet.contentsecuritypolicy.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/set-a-content-security-policy-with-helmet.contentsecuritypolicy.md
@@ -1,6 +1,6 @@
 ---
 id: 587d8249367417b2b2512c3f
-title: Set a Content Security Policy with helmet.contentSecurityPolicy()
+title: Festlegen einer Inhaltssicherheitsrichtlinie mit helmet.contentSecurityPolicy()
 challengeType: 2
 forumTopicId: 301585
 dashedName: set-a-content-security-policy-with-helmet-contentsecuritypolicy
@@ -10,9 +10,9 @@ dashedName: set-a-content-security-policy-with-helmet-contentsecuritypolicy
 
 As a reminder, this project is being built upon the following starter project on <a href="https://replit.com/github/freeCodeCamp/boilerplate-infosec" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or cloned from <a href="https://github.com/freeCodeCamp/boilerplate-infosec/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-This challenge highlights one promising new defense that can significantly reduce the risk and impact of many type of attacks in modern browsers. By setting and configuring a Content Security Policy you can prevent the injection of anything unintended into your page. This will protect your app from XSS vulnerabilities, undesired tracking, malicious frames, and much more. CSP works by defining an allowed list of content sources which are trusted. You can configure them for each kind of resource a web page may need (scripts, stylesheets, fonts, frames, media, and so on…). There are multiple directives available, so a website owner can have a granular control. See HTML 5 Rocks, KeyCDN for more details. Unfortunately CSP is unsupported by older browsers.
+Diese Aufgabe hebt eine vielversprechende neue Verteidigung hervor, die das Risiko und die Auswirkungen vieler Arten von Angriffen in modernen Browsern erheblich reduzieren kann. Durch das Einrichten und Konfigurieren einer Inhaltssicherheitsrichtlinie kannst du verhindern, dass etwas Unerwünschtes in deine Seite eingefügt wird. Dadurch wird deine App vor XSS-Schwachstellen, unerwünschtem Tracking, bösartigen Frames und vielem mehr geschützt. CSP funktioniert durch die Festlegung einer Liste zulässiger Inhaltsquellen, die als vertrauenswürdig gelten. Du kannst sie für jede Art von Ressource, die eine Webseite benötigt, konfigurieren (Skripte, Stylesheets, Schriftarten, Frames, Medien usw...). There are multiple directives available, so a website owner can have a granular control. Siehe HTML 5 Rocks, KeyCDN für weitere Details. Unfortunately CSP is unsupported by older browsers.
 
-By default, directives are wide open, so it’s important to set the defaultSrc directive as a fallback. Helmet supports both defaultSrc and default-src naming styles. The fallback applies for most of the unspecified directives.
+By default, directives are wide open, so it’s important to set the defaultSrc directive as a fallback. Helmet unterstützt sowohl defaultSrc- als auch default-src-Benennungsstile. Der Fallback gilt für die meisten nicht spezifizierten Richtlinien.
 
 # --instructions--
 
@@ -22,7 +22,7 @@ Hint: in the `'self'` keyword, the single quotes are part of the keyword itself,
 
 # --hints--
 
-helmet.contentSecurityPolicy() middleware should be mounted correctly
+Die helmet.contentSecurityPolicy()-Middleware sollte korrekt eingebaut werden
 
 ```js
 (getUserInput) =>
@@ -36,7 +36,7 @@ helmet.contentSecurityPolicy() middleware should be mounted correctly
   );
 ```
 
-Your csp config is not correct. defaultSrc sollte ["self'"] und scriptSrc sollte ["'self'", 'trusted-cdn.com'] sein
+Deine csp-Konfiguration ist nicht korrekt. defaultSrc sollte ["self'"] und scriptSrc sollte ["'self'", 'trusted-cdn.com'] sein
 
 ```js
 (getUserInput) =>
diff --git a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/understand-bcrypt-hashes.md b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/understand-bcrypt-hashes.md
index 69dc997a4b7..1b3f6f43887 100644
--- a/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/understand-bcrypt-hashes.md
+++ b/curriculum/challenges/german/09-information-security/information-security-with-helmetjs/understand-bcrypt-hashes.md
@@ -10,9 +10,9 @@ dashedName: understand-bcrypt-hashes
 
 For the following challenges, you will be working with a new starter project that is different from the previous one. You can find the new starter project on <a href="https://replit.com/github/freeCodeCamp/boilerplate-bcrypt" target="_blank" rel="noopener noreferrer nofollow">Replit</a>, or clone it from <a href="https://github.com/freeCodeCamp/boilerplate-bcrypt/" target="_blank" rel="noopener noreferrer nofollow">GitHub</a>.
 
-BCrypt hashes are very secure. Ein Hash ist im Grunde ein Fingerabdruck der ursprünglichen Daten - immer einzigartig. This is accomplished by feeding the original data into an algorithm and returning a fixed length result. To further complicate this process and make it more secure, you can also *salt* your hash. Salting your hash involves adding random data to the original data before the hashing process which makes it even harder to crack the hash.
+BCrypt-Hashes sind sehr sicher. Ein Hash ist im Grunde ein Fingerabdruck der ursprünglichen Daten - immer einzigartig. This is accomplished by feeding the original data into an algorithm and returning a fixed length result. To further complicate this process and make it more secure, you can also *salt* your hash. Salting your hash involves adding random data to the original data before the hashing process which makes it even harder to crack the hash.
 
-BCrypt hashes will always look like `$2a$13$ZyprE5MRw2Q3WpNOGZWGbeG7ADUre1Q8QO.uUUtcbqloU0yvzavOm` which does have a structure. Das erste kleine Datenbit `$2a` gibt an, welche Art von Hash-Algorithmus verwendet wurde. Der nächste Teil `$13` definiert die *Kosten*. Bei den Kosten geht es darum, wie viel Energie für die Berechnung des Hashwerts benötigt wird. It is on a logarithmic scale of 2^cost and determines how many times the data is put through the hashing algorithm. For example, at a cost of 10 you are able to hash 10 passwords a second on an average computer, however at a cost of 15 it takes 3 seconds per hash... and to take it further, at a cost of 31 it would take multiple days to complete a hash. Ein Aufwand von 12 gilt zur Zeit als sehr sicher. The last portion of your hash `$ZyprE5MRw2Q3WpNOGZWGbeG7ADUre1Q8QO.uUUtcbqloU0yvzavOm`, looks like one large string of numbers, periods, and letters but it is actually two separate pieces of information. The first 22 characters is the salt in plain text, and the rest is the hashed password!
+BCrypt hashes will always look like `$2a$13$ZyprE5MRw2Q3WpNOGZWGbeG7ADUre1Q8QO.uUUtcbqloU0yvzavOm` which does have a structure. Das erste kleine Datenbit `$2a` gibt an, welche Art von Hash-Algorithmus verwendet wurde. Der nächste Teil `$13` definiert die *Kosten*. Bei den Kosten geht es darum, wie viel Energie für die Berechnung des Hashwerts benötigt wird. Sie liegt auf einer logarithmischen Skala von 2^cost und bestimmt, wie oft die Daten durch den Hash-Algorithmus geschickt werden. Bei einem Preis von 10 kann man zum Beispiel 10 Passwörter pro Sekunde auf einem durchschnittlichen Computer hacken, bei einem Preis von 15 braucht man 3 Sekunden pro Hash... und bei einem Preis von 31 würde es mehrere Tage dauern, einen Hash zu erstellen. Ein Aufwand von 12 gilt zur Zeit als sehr sicher. The last portion of your hash `$ZyprE5MRw2Q3WpNOGZWGbeG7ADUre1Q8QO.uUUtcbqloU0yvzavOm`, looks like one large string of numbers, periods, and letters but it is actually two separate pieces of information. The first 22 characters is the salt in plain text, and the rest is the hashed password!
 
 # --instructions--
 
@@ -43,7 +43,7 @@ BCrypt sollte eine Abhängigkeit sein.
   );
 ```
 
-BCrypt should be properly required.
+BCrypt sollte ordnungsgemäß angefordert werden.
 
 ```js
 (getUserInput) =>
diff --git a/curriculum/challenges/german/09-information-security/python-for-penetration-testing/introduction-and-setup.md b/curriculum/challenges/german/09-information-security/python-for-penetration-testing/introduction-and-setup.md
index e872d44e8f3..413defb8ccb 100644
--- a/curriculum/challenges/german/09-information-security/python-for-penetration-testing/introduction-and-setup.md
+++ b/curriculum/challenges/german/09-information-security/python-for-penetration-testing/introduction-and-setup.md
@@ -22,7 +22,7 @@ Atom and the atom-python-run extension.
 
 ---
 
-VSCode and Microsoft's Python extension.
+VSCode und Microsofts Python-Erweiterung.
 
 ---
 
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/create-a-queue-class.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/create-a-queue-class.md
index 306b90e0c08..1b9fbc2ca91 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/create-a-queue-class.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/create-a-queue-class.md
@@ -20,7 +20,7 @@ Write an `enqueue` method that pushes an element to the tail of the queue, a `de
 
 # --hints--
 
-Your `Queue` class should have a `enqueue` method.
+Deine `Queue`-Klasse sollte eine `enqueue`-Methode haben.
 
 ```js
 assert(
@@ -31,7 +31,7 @@ assert(
 );
 ```
 
-Your `Queue` class should have a `dequeue` method.
+Deine `Queue`-Klasse sollte eine `dequeue`-Methode haben.
 
 ```js
 assert(
@@ -42,7 +42,7 @@ assert(
 );
 ```
 
-Your `Queue` class should have a `front` method.
+Deine `Queue`-Klasse sollte eine `front`-Methode haben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.md
index a359575e5f7..035900f669e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.md
@@ -12,7 +12,7 @@ This is the first of three challenges where we will implement a more difficult o
 
 # --instructions--
 
-Create a method on our binary tree called `remove`. We'll build the logic for our deletion operation in here. First, you'll want to create a function within remove that finds the node we are trying to delete in the current tree. If the node is not present in the tree, `remove` should return `null`. Now, if the target node is a leaf node with no children, then the parent reference to it should be set to `null`. This effectively deletes the node from the tree. To do this, you will have to keep track of the parent of the node we are trying to delete as well. It will also be useful to create a way to track the number of children the target node has, as this will determine which case our deletion falls under. We will handle the second and third cases in the next challenges. Good luck!
+Create a method on our binary tree called `remove`. We'll build the logic for our deletion operation in here. First, you'll want to create a function within remove that finds the node we are trying to delete in the current tree. If the node is not present in the tree, `remove` should return `null`. Now, if the target node is a leaf node with no children, then the parent reference to it should be set to `null`. This effectively deletes the node from the tree. To do this, you will have to keep track of the parent of the node we are trying to delete as well. It will also be useful to create a way to track the number of children the target node has, as this will determine which case our deletion falls under. We will handle the second and third cases in the next challenges. Viel Glück!
 
 # --hints--
 
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/invert-a-binary-tree.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/invert-a-binary-tree.md
index 8be38b0d5d8..a5f495a11b4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/invert-a-binary-tree.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/invert-a-binary-tree.md
@@ -8,7 +8,7 @@ dashedName: invert-a-binary-tree
 
 # --description--
 
-Here will we create a function to invert a binary tree. Given a binary tree, we want to produce a new tree that is equivalently the mirror image of this tree. Running an inorder traversal on an inverted tree will explore the nodes in reverse order when compared to the inorder traversal of the original tree. Write a method to do this called `invert` on our binary tree. Calling this method should invert the current tree structure. Ideally, we would like to do this in-place in linear time. That is, we only visit each node once and we modify the existing tree structure as we go, without using any additional memory. Good luck!
+Here will we create a function to invert a binary tree. Given a binary tree, we want to produce a new tree that is equivalently the mirror image of this tree. Running an inorder traversal on an inverted tree will explore the nodes in reverse order when compared to the inorder traversal of the original tree. Write a method to do this called `invert` on our binary tree. Calling this method should invert the current tree structure. Ideally, we would like to do this in-place in linear time. That is, we only visit each node once and we modify the existing tree structure as we go, without using any additional memory. Viel Glück!
 
 # --hints--
 
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
index 1c793291283..b8f87022005 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-difference-on-two-sets-of-data.md
@@ -25,7 +25,7 @@ assert(
 );
 ```
 
-Your `difference` method should return the proper collection.
+Deine `difference`-Methode sollte die richtige Sammlung zurückgeben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
index 3c099ab1d33..3954e86444a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.md
@@ -43,7 +43,7 @@ assert(
 );
 ```
 
-`['a', 'b'].isSubsetOf(['a', 'b', 'c', 'd'])` should return `true`.
+`['a', 'b'].isSubsetOf(['a', 'b', 'c', 'd'])` sollte `true` zurückgeben.
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-`['a', 'b', 'c'].isSubsetOf(['a', 'b'])` should return `false`.
+`['a', 'b', 'c'].isSubsetOf(['a', 'b'])` sollte `false` zurückgeben.
 
 ```js
 assert(
@@ -80,7 +80,7 @@ assert(
 );
 ```
 
-`[].isSubsetOf([])` should return `true`.
+`[].isSubsetOf([])` sollte `true` zurückgeben.
 
 ```js
 assert(
@@ -93,7 +93,7 @@ assert(
 );
 ```
 
-`['a', 'b'].isSubsetOf(['c', 'd'])` should return `false`.
+`['a', 'b'].isSubsetOf(['c', 'd'])` sollte `false` zurückgeben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-an-intersection-on-two-sets-of-data.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-an-intersection-on-two-sets-of-data.md
index a108cb3b4ee..54af11bfddc 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-an-intersection-on-two-sets-of-data.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/perform-an-intersection-on-two-sets-of-data.md
@@ -14,7 +14,7 @@ For example, if `setA = ['a','b','c']` and `setB = ['a','b','d','e']`, then the
 
 # --hints--
 
-Your `Set` class should have a `intersection` method.
+Deine `Set`-Klasse sollte eine `intersection`-Methode haben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/typed-arrays.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/typed-arrays.md
index b992af729a4..ec288066d4e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/typed-arrays.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/typed-arrays.md
@@ -20,7 +20,7 @@ However, in the world of high performance and different element types, sometimes
 
 <dfn>Typed arrays</dfn> are the answer to this problem. You are now able to say how much memory you want to give an array. Below is a basic overview of the different types of arrays available and the size in bytes for each element in that array.
 
-<table class='table table-striped'><tbody><tr><th>Type</th><th>Each element size in bytes</th></tr><tr><td><code>Int8Array</code></td><td>1</td></tr><tr><td><code>Uint8Array</code></td><td>1</td></tr><tr><td><code>Uint8ClampedArray</code></td><td>1</td></tr><tr><td><code>Int16Array</code></td><td>2</td></tr><tr><td><code>Uint16Array</code></td><td>2</td></tr><tr><td><code>Int32Array</code></td><td>4</td></tr><tr><td><code>Uint32Array</code></td><td>4</td></tr><tr><td><code>Float32Array</code></td><td>4</td></tr><tr><td><code>Float64Array</code></td><td>8</td></tr></tbody></table>
+<table class='table table-striped'><tbody><tr><th>Typ</th><th>Each element size in bytes</th></tr><tr><td><code>Int8Array</code></td><td>1</td></tr><tr><td><code>Uint8Array</code></td><td>1</td></tr><tr><td><code>Uint8ClampedArray</code></td><td>1</td></tr><tr><td><code>Int16Array</code></td><td>2</td></tr><tr><td><code>Uint16Array</code></td><td>2</td></tr><tr><td><code>Int32Array</code></td><td>4</td></tr><tr><td><code>Uint32Array</code></td><td>4</td></tr><tr><td><code>Float32Array</code></td><td>4</td></tr><tr><td><code>Float64Array</code></td><td>8</td></tr></tbody></table>
 
 There are two ways in creating these kind of arrays. One way is to create it directly. Below is how to create a 3 length `Int16Array`.
 
@@ -65,7 +65,7 @@ Your `buffer` should be 64 bytes large.
 assert(buffer.byteLength === 64);
 ```
 
-Your `i32View` view of your buffer should be 64 bytes large.
+Ihre `i32View` Ansicht des Puffers sollte 64 Bytes groß sein.
 
 ```js
 assert(i32View.byteLength === 64);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.md
index 55d4ac67de8..54508524744 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.md
@@ -34,7 +34,7 @@ In this exercise we will pass an array and a value to the checkSet() function. Y
 
 # --hints--
 
-`checkSet([4, 5, 6], 3)` should return [ false, 3 ]
+`checkSet([4, 5, 6], 3)` sollte [ false, 3 ] zurückgeben
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-spread-and-notes-for-es5-set-integration.md b/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-spread-and-notes-for-es5-set-integration.md
index 79ba7313b8c..e673f2dce3d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-spread-and-notes-for-es5-set-integration.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/data-structures/use-spread-and-notes-for-es5-set-integration.md
@@ -28,7 +28,7 @@ Now you've successfully learned how to use the ES6 `Set()` object, good job!
 
 # --hints--
 
-`checkSet(new Set([1,2,3,4,5,6,7])` should return `[1, 2, 3, 4, 5, 6, 7]`.
+`checkSet(new Set([1,2,3,4,5,6,7])` sollte `[1, 2, 3, 4, 5, 6, 7]` zurückgeben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/24-game.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/24-game.md
index ac16df78509..6b0e5b9e7ed 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/24-game.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/24-game.md
@@ -16,7 +16,7 @@ The aim of the game is to arrange four numbers in a way that when evaluated, the
 
 Implement a function that takes a string of four digits as its argument, with each digit from 1 to 9 (inclusive) with repetitions allowed, and returns an arithmetic expression that evaluates to the number 24. If no such solution exists, return "no solution exists".
 
-**Rules:**
+**Regeln:**
 <ul>
   <li> Only the following operators/functions are allowed: multiplication, division, addition, subtraction. </li>
   <li> Division should use floating point or rational arithmetic, etc, to preserve remainders. </li>
@@ -33,7 +33,7 @@ Implement a function that takes a string of four digits as its argument, with ea
 
 # --hints--
 
-`solve24` should be a function.
+`solve24` solllte eine Funktion sein.
 
 ```js
 assert(typeof solve24 === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
index f857c18e239..bd307b919ef 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.md
@@ -42,7 +42,7 @@ Implement a function that returns the sum of the $n$-th row.
 
 # --hints--
 
-`numberOfNames` should be function.
+`numberOfNames` sollte eine Funktion sein.
 
 ```js
 assert(typeof numberOfNames === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abc-problem.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abc-problem.md
index 36a7b23eeb7..8a65eb7cc62 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abc-problem.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abc-problem.md
@@ -45,49 +45,49 @@ Some rules to keep in mind:
 
 # --hints--
 
-`canMakeWord` should be a function.
+`canMakeWord` sollte eine Funktion sein.
 
 ```js
 assert(typeof canMakeWord === 'function');
 ```
 
-`canMakeWord` should return a boolean.
+`canMakeWord` sollte einen Boolean zurückgeben.
 
 ```js
 assert(typeof canMakeWord('hi') === 'boolean');
 ```
 
-`canMakeWord("bark")` should return true.
+`canMakeWord("bark")` sollte true zurückgeben.
 
 ```js
 assert(canMakeWord(words[0]));
 ```
 
-`canMakeWord("BooK")` should return false.
+`canMakeWord("BooK")` sollte false zurückgeben.
 
 ```js
 assert(!canMakeWord(words[1]));
 ```
 
-`canMakeWord("TReAT")` should return true.
+`canMakeWord("TReAT")` sollte true zurückgeben.
 
 ```js
 assert(canMakeWord(words[2]));
 ```
 
-`canMakeWord("COMMON")` should return false.
+`canMakeWord("COMMON")` sollte false zurückgeben.
 
 ```js
 assert(!canMakeWord(words[3]));
 ```
 
-`canMakeWord("squAD")` should return true.
+`canMakeWord("squAD")` sollte true zurückgeben.
 
 ```js
 assert(canMakeWord(words[4]));
 ```
 
-`canMakeWord("conFUSE")` should return true.
+`canMakeWord("conFUSE")` sollte true zurückgeben.
 
 ```js
 assert(canMakeWord(words[5]));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.md
index 5626858b7d3..844b8bba9c0 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.md
@@ -26,7 +26,7 @@ Implement a function that calculates how many of the integers from `1` to `num`
 
 # --hints--
 
-`getDPA` should be a function.
+`getDPA` sollte eine Funktion sein.
 
 ```js
 assert(typeof getDPA === 'function');
@@ -44,19 +44,19 @@ assert(Array.isArray(getDPA(5000)));
 assert(getDPA(5000).length === 3);
 ```
 
-`getDPA(5000)` should return `[3758, 3, 1239]`.
+`getDPA(5000)` sollte `[3758, 3, 1239]` zurückgeben.
 
 ```js
 assert.deepEqual(getDPA(5000), [3758, 3, 1239]);
 ```
 
-`getDPA(10000)` should return `[7508, 4, 2488]`.
+`getDPA(10000)` sollte `[7508, 4, 2488]` zurückgeben.
 
 ```js
 assert.deepEqual(getDPA(10000), [7508, 4, 2488]);
 ```
 
-`getDPA(20000)` should return `[15043, 4, 4953]`.
+`getDPA(20000)` sollte `[15043, 4, 4953]` zurückgeben.
 
 ```js
 assert.deepEqual(getDPA(20000), [15043, 4, 4953]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/accumulator-factory.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/accumulator-factory.md
index e3ee77daf90..f6c22097562 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/accumulator-factory.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/accumulator-factory.md
@@ -24,19 +24,19 @@ Closures save outer state.
 
 # --hints--
 
-`accumulator` should be a function.
+`accumulator` sollte eine Funktion sein.
 
 ```js
 assert(typeof accumulator === 'function');
 ```
 
-`accumulator(0)` should return a function.
+`accumulator(0)` sollte eine Funktion zurückgeben.
 
 ```js
 assert(typeof accumulator(0) === 'function');
 ```
 
-`accumulator(0)(2)` should return a number.
+`accumulator(0)(2)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof accumulator(0)(2) === 'number');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ackermann-function.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ackermann-function.md
index f6443aee8c4..aa5c998337c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ackermann-function.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ackermann-function.md
@@ -22,31 +22,31 @@ Write a function which returns the value of $A(m, n)$. Arbitrary precision is pr
 
 # --hints--
 
-`ack` should be a function.
+`ack` sollte eine Funktion sein.
 
 ```js
 assert(typeof ack === 'function');
 ```
 
-`ack(0, 0)` should return 1.
+`ack(0, 0)` sollte 1 zurückgeben.
 
 ```js
 assert(ack(0, 0) === 1);
 ```
 
-`ack(1, 1)` should return 3.
+`ack(1, 1)` sollte 3 zurückgeben.
 
 ```js
 assert(ack(1, 1) === 3);
 ```
 
-`ack(2, 5)` should return 13.
+`ack(2, 5)` sollte 13 zurückgeben.
 
 ```js
 assert(ack(2, 5) === 13);
 ```
 
-`ack(3, 3)` should return 61.
+`ack(3, 3)` sollte 61 zurückgeben.
 
 ```js
 assert(ack(3, 3) === 61);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/align-columns.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/align-columns.md
index ad0b7acd1cd..86fd09e6f3b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/align-columns.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/align-columns.md
@@ -48,7 +48,7 @@ For example, one of the lines from the `testText`, after justifying to the right
 
 # --hints--
 
-`formatText` should be a function.
+`formatText` sollte eine Funktion sein.
 
 ```js
 assert(typeof formatText === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/amicable-pairs.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/amicable-pairs.md
index 945b5cb117f..f7b49f76f23 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/amicable-pairs.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/amicable-pairs.md
@@ -10,12 +10,12 @@ dashedName: amicable-pairs
 
 Two integers $N$ and $M$ are said to be amicable pairs if $N \\neq M$ and the sum of the proper divisors of $N$ ($\\mathrm{sum}(\\mathrm{propDivs}(N))$) $= M$ as well as $\\mathrm{sum}(\\mathrm{propDivs}(M)) = N$.
 
-**Example:**
+**Beispiel:**
 
 **1184** and **1210** are an amicable pair, with proper divisors:
 
 <ul>
-  <li>1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 and</li>
+  <li>1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 und</li>
   <li>1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 respectively.</li>
 </ul>
 
@@ -27,25 +27,25 @@ Calculate and show here the Amicable pairs below 20,000 (there are eight).
 
 # --hints--
 
-`amicablePairsUpTo` should be a function.
+`amicablePairsUpTo` sollte eine Funktion sein.
 
 ```js
 assert(typeof amicablePairsUpTo === 'function');
 ```
 
-`amicablePairsUpTo(300)` should return `[[220,284]]`.
+`amicablePairsUpTo(300)` sollte `[[220,284]]` zurückgeben.
 
 ```js
 assert.deepEqual(amicablePairsUpTo(300), answer300);
 ```
 
-`amicablePairsUpTo(3000)` should return `[[220,284],[1184,1210],[2620,2924]]`.
+`amicablePairsUpTo(3000)` sollte `[[220,284],[1184,1210],[2620,2924]]` zurückgeben.
 
 ```js
 assert.deepEqual(amicablePairsUpTo(3000), answer3000);
 ```
 
-`amicablePairsUpTo(20000)` should return `[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]`.
+`amicablePairsUpTo(20000)` sollte `[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]` zurückgeben.
 
 ```js
 assert.deepEqual(amicablePairsUpTo(20000), answer20000);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-mode.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-mode.md
index d65362b8929..0eb70a45e18 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-mode.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-mode.md
@@ -16,7 +16,7 @@ If it is not appropriate or possible to support a general collection, use a vect
 
 # --hints--
 
-`mode` should be a function.
+`mode` sollte eine Funktion sein.
 
 ```js
 assert(typeof mode === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-pythagorean-means.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-pythagorean-means.md
index 12b5b68cd57..e6319f25322 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-pythagorean-means.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-pythagorean-means.md
@@ -40,7 +40,7 @@ For the answer, please output an object in the following format:
 
 # --hints--
 
-`pythagoreanMeans` should be a function.
+`pythagoreanMeans` sollte eine Funktion sein.
 
 ```js
 assert(typeof pythagoreanMeans === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-root-mean-square.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-root-mean-square.md
index f4dbbcbcca7..749372dc46a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-root-mean-square.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/averages-root-mean-square.md
@@ -1,6 +1,6 @@
 ---
 id: 594da033de4190850b893874
-title: Averages/Root mean square
+title: Durchschnitte/Quadratisches Mittel
 challengeType: 1
 forumTopicId: 302228
 dashedName: averagesroot-mean-square
@@ -16,7 +16,7 @@ $$x\_{\\mathrm{rms}} = \\sqrt {{{x_1}^2 + {x_2}^2 + \\cdots + {x_n}^2} \\over n}
 
 # --hints--
 
-`rms` should be a function.
+`rms` sollte eine Funktion sein.
 
 ```js
 assert(typeof rms === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/babbage-problem.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/babbage-problem.md
index aa9d6f54100..4e7b8875940 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/babbage-problem.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/babbage-problem.md
@@ -25,7 +25,7 @@ Implement a function to return the lowest integer that satisfies the Babbage pro
 
 # --hints--
 
-`babbage` should be a function.
+`babbage` sollte eine Funktion sein.
 
 ```js
 assert(typeof babbage === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/balanced-brackets.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/balanced-brackets.md
index 1de7c2352ce..8bab2178c16 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/balanced-brackets.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/balanced-brackets.md
@@ -10,7 +10,7 @@ dashedName: balanced-brackets
 
 Determine whether a generated string of brackets is balanced; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.
 
-**Examples:**
+**Beispiele:**
 | Input                     | Output |
 | ------------------------- | ------ |
 | <code>\[]</code> | true   |
@@ -22,115 +22,115 @@ Determine whether a generated string of brackets is balanced; that is, whether i
 
 # --hints--
 
-`isBalanced` should be a function.
+`isBalanced` sollte eine Funktion sein.
 
 ```js
 assert(typeof isBalanced === 'function');
 ```
 
-`isBalanced("[]")` should return true.
+`isBalanced("[]")` sollte true zurückgeben.
 
 ```js
 assert(isBalanced(testCases[0]));
 ```
 
-`isBalanced("]][[[][][][]][")` should return false.
+`isBalanced("]][[[][][][]][")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[1]));
 ```
 
-`isBalanced("[][[[[][][[[]]]]]]")` should return true.
+`isBalanced("[][[[[][][[[]]]]]]")` sollte true zurückgeben.
 
 ```js
 assert(isBalanced(testCases[2]));
 ```
 
-`isBalanced("][")` should return false.
+`isBalanced("][")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[3]));
 ```
 
-`isBalanced("[[[]]]][[]")` should return false.
+`isBalanced("[[[]]]][[]")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[4]));
 ```
 
-`isBalanced("][[]")` should return false.
+`isBalanced("][[]")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[5]));
 ```
 
-`isBalanced("][[][]][[[]]")` should return false.
+`isBalanced("][[][]][[[]]")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[6]));
 ```
 
-`isBalanced("[[][]]][")` should return false.
+`isBalanced("[[][]]][")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[7]));
 ```
 
-`isBalanced("[[[]]][[]]]][][[")` should return false.
+`isBalanced("[[[]]][[]]]][][[")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[8]));
 ```
 
-`isBalanced("[]][[]]][[[[][]]")` should return false.
+`isBalanced("[]][[]]][[[[][]]")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[9]));
 ```
 
-`isBalanced("][]][[][")` should return false.
+`isBalanced("][]][[][")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[10]));
 ```
 
-`isBalanced("[[]][[][]]")` should return true.
+`isBalanced("[[]][[][]]")` sollte true zurückgeben.
 
 ```js
 assert(isBalanced(testCases[11]));
 ```
 
-`isBalanced("[[]]")` should return true.
+`isBalanced("[[]]")` sollte true zurückgeben.
 
 ```js
 assert(isBalanced(testCases[12]));
 ```
 
-`isBalanced("]][]][[]][[[")` should return false.
+`isBalanced("]][]][[]][[[")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[13]));
 ```
 
-`isBalanced("][]][][[")` should return false.
+`isBalanced("][]][][[")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[14]));
 ```
 
-`isBalanced("][][")` should return false.
+`isBalanced("][][")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[15]));
 ```
 
-`isBalanced("[]]]")` should return false.
+`isBalanced("[]]]")` sollte false zurückgeben.
 
 ```js
 assert(!isBalanced(testCases[16]));
 ```
 
-`isBalanced("")` should return true.
+`isBalanced("")` sollte true zurückgeben.
 
 ```js
 assert(isBalanced(testCases[17]));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.md
index 2254ea4c44a..3265b803121 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.md
@@ -10,7 +10,7 @@ dashedName: circles-of-given-radius-through-two-points
 
 Given two points on a plane and a radius, usually two circles of given radius can be drawn through the points.
 
-**Exceptions:**
+**Ausnahmen:**
 
 <ul>
   <li>A radius of zero should be treated as never describing circles (except in the case where the points are coincident).</li>
@@ -43,37 +43,37 @@ Implement a function that takes two points and a radius and returns the two circ
 
 # --hints--
 
-`getCircles` should be a function.
+`getCircles` sollte eine Funktion sein.
 
 ```js
 assert(typeof getCircles === 'function');
 ```
 
-`getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)` should return `[[1.8631, 1.9742], [-0.8632, -0.7521]]`.
+`getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)` sollte `[[1.8631, 1.9742], [-0.8632, -0.7521]]` zurückgeben.
 
 ```js
 assert.deepEqual(getCircles(...testCases[0]), answers[0]);
 ```
 
-`getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)` should return `[0, 1]`
+`getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)` sollte `[0, 1]` zurückgeben
 
 ```js
 assert.deepEqual(getCircles(...testCases[1]), answers[1]);
 ```
 
-`getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)` should return `Coincident point. Infinite solutions`
+`getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)` sollte `Coincident point. Infinite solutions` zurückgeben
 
 ```js
 assert.deepEqual(getCircles(...testCases[2]), answers[2]);
 ```
 
-`getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)` should return `No intersection. Points further apart than circle diameter`
+`getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)` sollte `No intersection. Points further apart than circle diameter` zurückgeben
 
 ```js
 assert.deepEqual(getCircles(...testCases[3]), answers[3]);
 ```
 
-`getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)` should return `Radius Zero`
+`getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)` sollte `Radius Zero` zurückgeben
 
 ```js
 assert.deepEqual(getCircles(...testCases[4]), answers[4]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/closest-pair-problem.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/closest-pair-problem.md
index 06259fbc6a1..1148d21b09d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/closest-pair-problem.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/closest-pair-problem.md
@@ -100,7 +100,7 @@ Would return:
 
 # --hints--
 
-`getClosestPair` should be a function.
+`getClosestPair` sollte eine Funktion sein.
 
 ```js
 assert(typeof getClosestPair === 'function');
@@ -112,7 +112,7 @@ assert(typeof getClosestPair === 'function');
 assert.equal(getClosestPair(points1).distance, answer1.distance);
 ```
 
-`getClosestPair(points1).pair` should be `[ { x: 7.46489, y: 4.6268 }, { x: 7.46911, y: 4.71611 } ]`.
+`getClosestPair(points1).pair` sollte `[ { x: 7.46489, y: 4.6268 }, { x: 7.46911, y: 4.71611 } ]` sein.
 
 ```js
 assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/combinations.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/combinations.md
index 39498bf8ed9..3b31d90e9f8 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/combinations.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/combinations.md
@@ -10,9 +10,9 @@ dashedName: combinations
 
 Given non-negative integers `m` and `n`, generate all size `m` combinations of the integers from `0` (zero) to `n-1` in sorted order (each combination is sorted and the entire table is sorted).
 
-**Example:**
+**Beispiel:**
 
-`3` comb `5` is:
+`3` comb `5` ist:
 
 <pre>0 1 2
 0 1 3
@@ -28,19 +28,19 @@ Given non-negative integers `m` and `n`, generate all size `m` combinations of t
 
 # --hints--
 
-`combinations` should be a function.
+`combinations` sollte eine Funktion sein.
 
 ```js
 assert(typeof combinations === 'function');
 ```
 
-`combinations(3, 5)` should return `[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]`.
+`combinations(3, 5)` sollte `[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]` zurückgeben.
 
 ```js
 assert.deepEqual(combinations(testInput1[0], testInput1[1]), testOutput1);
 ```
 
-`combinations(4, 6)` should return `[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]`
+`combinations(4, 6)` sollte `[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]` zurückgeben
 
 ```js
 assert.deepEqual(combinations(testInput2[0], testInput2[1]), testOutput2);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/comma-quibbling.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/comma-quibbling.md
index 28053f80b67..76e2866239d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/comma-quibbling.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/comma-quibbling.md
@@ -34,37 +34,37 @@ Test your function with the following series of inputs showing your output here
 
 # --hints--
 
-`quibble` should be a function.
+`quibble` sollte eine Funktion sein.
 
 ```js
 assert(typeof quibble === 'function');
 ```
 
-`quibble(["ABC"])` should return a string.
+`quibble(["ABC"])` sollte einen String zurückgeben.
 
 ```js
 assert(typeof quibble(['ABC']) === 'string');
 ```
 
-`quibble([])` should return "{}".
+`quibble([])` sollte "{}" zurückgeben.
 
 ```js
 assert.equal(quibble(testCases[0]), results[0]);
 ```
 
-`quibble(["ABC"])` should return `"{ABC}"`.
+`quibble(["ABC"])` sollte `"{ABC}"` zurückgeben.
 
 ```js
 assert.equal(quibble(testCases[1]), results[1]);
 ```
 
-`quibble(["ABC", "DEF"])` should return `"{ABC and DEF}"`.
+`quibble(["ABC", "DEF"])` sollte `"{ABC and DEF}"` zurückgeben.
 
 ```js
 assert.equal(quibble(testCases[2]), results[2]);
 ```
 
-`quibble(["ABC", "DEF", "G", "H"])` should return `"{ABC, DEF, G and H}"`.
+`quibble(["ABC", "DEF", "G", "H"])` sollte `"{ABC, DEF, G and H}"` zurückgeben.
 
 ```js
 assert.equal(quibble(testCases[3]), results[3]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/compare-a-list-of-strings.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/compare-a-list-of-strings.md
index 292a0a077c4..98f89b10e3c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/compare-a-list-of-strings.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/compare-a-list-of-strings.md
@@ -8,7 +8,7 @@ dashedName: compare-a-list-of-strings
 
 # --description--
 
-A list is an ordered set of values that may contain duplicates. Here is an example:
+A list is an ordered set of values that may contain duplicates. Hier ist ein Beispiel:
 
 ```js
 const list = [['AA',  'BB', 'CC'], ['AA', 'ACB', 'AA'], [], ['AA']];
@@ -23,73 +23,73 @@ Given a list of arbitrarily many strings, implement a function for each of the f
 
 # --hints--
 
-`allEqual` should be a function.
+`allEqual` sollte eine Funktion sein.
 
 ```js
 assert(typeof allEqual === 'function');
 ```
 
-`azSorted` should be a function.
+`azSorted` sollte eine Funktion sein.
 
 ```js
 assert(typeof azSorted === 'function');
 ```
 
-`allEqual(["AA", "AA", "AA", "AA"])` should return true.
+`allEqual(["AA", "AA", "AA", "AA"])` sollte true zurückgeben.
 
 ```js
 assert(allEqual(testCases[0]));
 ```
 
-`azSorted(["AA", "AA", "AA", "AA"])` should return false.
+`azSorted(["AA", "AA", "AA", "AA"])` sollte false zurückgeben.
 
 ```js
 assert(!azSorted(testCases[0]));
 ```
 
-`allEqual(["AA", "ACB", "BB", "CC"])` should return false.
+`allEqual(["AA", "ACB", "BB", "CC"])` sollte false zurückgeben.
 
 ```js
 assert(!allEqual(testCases[1]));
 ```
 
-`azSorted(["AA", "ACB", "BB", "CC"])` should return true.
+`azSorted(["AA", "ACB", "BB", "CC"])` sollte true zurückgeben.
 
 ```js
 assert(azSorted(testCases[1]));
 ```
 
-`allEqual([])` should return true.
+`allEqual([])` sollte true zurückgeben.
 
 ```js
 assert(allEqual(testCases[2]));
 ```
 
-`azSorted([])` should return true.
+`azSorted([])` sollte true zurückgeben.
 
 ```js
 assert(azSorted(testCases[2]));
 ```
 
-`allEqual(["AA"])` should return true.
+`allEqual(["AA"])` sollte true zurückgeben.
 
 ```js
 assert(allEqual(testCases[3]));
 ```
 
-`azSorted(["AA"])` should return true.
+`azSorted(["AA"])` sollte true zurückgeben.
 
 ```js
 assert(azSorted(testCases[3]));
 ```
 
-`allEqual(["BB", "AA"])` should return false.
+`allEqual(["BB", "AA"])` sollte false zurückgeben.
 
 ```js
 assert(!allEqual(testCases[4]));
 ```
 
-`azSorted(["BB", "AA"])` should return false.
+`azSorted(["BB", "AA"])` sollte false zurückgeben.
 
 ```js
 assert(!azSorted(testCases[4]));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
index 683a565c301..59fdd1631c7 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.md
@@ -52,25 +52,25 @@ Demonstrate that it passes the following three test-cases:
 
 # --hints--
 
-`convertSeconds` should be a function.
+`convertSeconds` sollte eine Funktion sein.
 
 ```js
 assert(typeof convertSeconds === 'function');
 ```
 
-`convertSeconds(7259)` should return `2 hr, 59 sec`.
+`convertSeconds(7259)` sollte `2 hr, 59 sec` zurückgeben.
 
 ```js
 assert.equal(convertSeconds(testCases[0]), results[0]);
 ```
 
-`convertSeconds(86400)` should return `1 d`.
+`convertSeconds(86400)` sollte `1 d` zurückgeben.
 
 ```js
 assert.equal(convertSeconds(testCases[1]), results[1]);
 ```
 
-`convertSeconds(6000000)` should return `9 wk, 6 d, 10 hr, 40 min`.
+`convertSeconds(6000000)` sollte `9 wk, 6 d, 10 hr, 40 min` zurückgeben.
 
 ```js
 assert.equal(convertSeconds(testCases[2]), results[2]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
index c3274154b40..e54017b187f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.md
@@ -25,25 +25,25 @@ In general, this essentially means matching from left-to-right or right-to-left.
 
 # --hints--
 
-`countSubstring` should be a function.
+`countSubstring` sollte eine Funktion sein.
 
 ```js
 assert(typeof countSubstring === 'function');
 ```
 
-`countSubstring("the three truths", "th")` should return `3`.
+`countSubstring("the three truths", "th")` sollte `3` zurückgeben.
 
 ```js
 assert.equal(countSubstring(testCases[0], searchString[0]), results[0]);
 ```
 
-`countSubstring("ababababab", "abab")` should return `2`.
+`countSubstring("ababababab", "abab")` sollte `2` zurückgeben.
 
 ```js
 assert.equal(countSubstring(testCases[1], searchString[1]), results[1]);
 ```
 
-`countSubstring("abaabba*bbaba*bbab", "a*b")` should return `2`.
+`countSubstring("abaabba*bbaba*bbab", "a*b")` sollte `2` zurückgeben.
 
 ```js
 assert.equal(countSubstring(testCases[2], searchString[2]), results[2]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-the-coins.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-the-coins.md
index bf1d4eac68c..0ea845c01ac 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-the-coins.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/count-the-coins.md
@@ -34,25 +34,25 @@ Implement a function to determine how many ways there are to make change for a g
 
 # --hints--
 
-`countCoins` should be a function.
+`countCoins` sollte eine Funktion zurückgeben.
 
 ```js
 assert(typeof countCoins === 'function');
 ```
 
-`countCoins(15)` should return `6`.
+`countCoins(15)` sollte `6` zurückgeben.
 
 ```js
 assert.equal(countCoins(15), 6);
 ```
 
-`countCoins(85)` should return `163`.
+`countCoins(85)` sollte `163` zurückgeben.
 
 ```js
 assert.equal(countCoins(85), 163);
 ```
 
-`countCoins(100)` should return `242`.
+`countCoins(100)` sollte `242` zurückgeben.
 
 ```js
 assert.equal(countCoins(100), 242);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cramers-rule.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cramers-rule.md
index 2d612f0a7f2..e5f9f868a3c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cramers-rule.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cramers-rule.md
@@ -36,19 +36,19 @@ solve for $w$, $x$, $y$ and $z$, using Cramer's rule.
 
 # --hints--
 
-`cramersRule` should be a function.
+`cramersRule` sollte eine Funktion sein.
 
 ```js
 assert(typeof cramersRule === 'function');
 ```
 
-`cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])` should return `[2, -12, -4, 1]`.
+`cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])` sollte `[2, -12, -4, 1]` zurückgeben.
 
 ```js
 assert.deepEqual(cramersRule(matrices[0], freeTerms[0]), answers[0]);
 ```
 
-`cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])` should return `[1, 1, -1]`.
+`cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])` sollte `[1, 1, -1]` zurückgeben.
 
 ```js
 assert.deepEqual(cramersRule(matrices[1], freeTerms[1]), answers[1]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
index 2802c448aaa..c40f09739ed 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cumulative-standard-deviation.md
@@ -37,37 +37,37 @@ Write a function that takes an array of numbers as parameter and returns the <a
 
 # --hints--
 
-`standardDeviation` should be a function.
+`standardDeviation` sollte eine Funktion sein.
 
 ```js
 assert(typeof standardDeviation == 'function');
 ```
 
-`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` should return a number.
+`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) == 'number');
 ```
 
-`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` should return `2`.
+`standardDeviation([2, 4, 4, 4, 5, 5, 7, 9])` sollte `2` zurückgeben.
 
 ```js
 assert.equal(standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2);
 ```
 
-`standardDeviation([600, 470, 170, 430, 300])` should return `147.323`.
+`standardDeviation([600, 470, 170, 430, 300])` sollte `147.323` zurückgeben.
 
 ```js
 assert.equal(standardDeviation([600, 470, 170, 430, 300]), 147.323);
 ```
 
-`standardDeviation([75, 83, 96, 100, 121, 125])` should return `18.239`.
+`standardDeviation([75, 83, 96, 100, 121, 125])` sollte `18.239`.
 
 ```js
 assert.equal(standardDeviation([75, 83, 96, 100, 121, 125]), 18.239);
 ```
 
-`standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82])` should return `16.87`.
+`standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82])` sollte `16.87` zurückgeben.
 
 ```js
 assert.equal(
@@ -76,7 +76,7 @@ assert.equal(
 );
 ```
 
-`standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314])` should return `22.631`.
+`standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314])` sollte `22.631` zurückgeben.
 
 ```js
 assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cusip.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cusip.md
index b74ce598f4a..9a9c640a2fd 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cusip.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cusip.md
@@ -8,7 +8,7 @@ dashedName: cusip
 
 # --description--
 
-A **CUSIP** is a nine-character alphanumeric code that identifies a North American financial security for the purposes of facilitating clearing and settlement of trades. The CUSIP was adopted as an American National Standard under Accredited Standards X9.6.
+Eine **CUSIP** ist ein neunstelliger alphanumerischer Code, der ein nordamerikanisches Finanzpapier zum Zwecke der Erleichterung des Clearings und der Abwicklung von Geschäften identifiziert. The CUSIP was adopted as an American National Standard under Accredited Standards X9.6.
 
 # --instructions--
 
@@ -16,61 +16,61 @@ Write a function that takes a string as a parameter and checks if the string is
 
 # --hints--
 
-`isCusip` should be a function.
+`isCusip` sollte eine Funktion sein.
 
 ```js
 assert(typeof isCusip == 'function');
 ```
 
-`isCusip("037833100")` should return a boolean.
+`isCusip("037833100")` sollte einen Boolean zurückgeben.
 
 ```js
 assert(typeof isCusip('037833100') == 'boolean');
 ```
 
-`isCusip("037833100")` should return `true`.
+`isCusip("037833100")` sollte `true` zurückgeben.
 
 ```js
 assert.equal(isCusip('037833100'), true);
 ```
 
-`isCusip("17275R102")` should return `true`.
+`isCusip("17275R102")` sollte `true` zurückgeben.
 
 ```js
 assert.equal(isCusip('17275R102'), true);
 ```
 
-`isCusip("38259P50a")` should return `false`.
+`isCusip("38259P50a")` sollte `false` zurückgeben.
 
 ```js
 assert.equal(isCusip('38259P50a'), false);
 ```
 
-`isCusip("38259P508")` should return `true`.
+`isCusip("38259P508")` sollte `true` zurückgeben.
 
 ```js
 assert.equal(isCusip('38259P508'), true);
 ```
 
-`isCusip("38259P50#")` should return `false`.
+`isCusip("38259P50#")` sollte `false` zurückgeben.
 
 ```js
 assert.equal(isCusip('38259P50#'), false);
 ```
 
-`isCusip("68389X105")` should return `true`.
+`isCusip("68389X105")` sollte `true` zurückgeben.
 
 ```js
 assert.equal(isCusip('68389X105'), true);
 ```
 
-`isCusip("68389X106")` should return `false`.
+`isCusip("68389X106")` sollte `false` zurückgeben.
 
 ```js
 assert.equal(isCusip('68389X106'), false);
 ```
 
-`isCusip("5949181")` should return `false`.
+`isCusip("5949181")` sollte `false` zurückgeben.
 
 ```js
 assert.equal(isCusip('5949181'), false);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cut-a-rectangle.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cut-a-rectangle.md
index 446e3fddf1f..23cd335d433 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cut-a-rectangle.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/cut-a-rectangle.md
@@ -96,43 +96,43 @@ Write a function that calculates the number of different ways to cut an *m* × *
 
 # --hints--
 
-`cutRectangle` should be a function.
+`cutRectangle` sollte eine Funktion sein.
 
 ```js
 assert(typeof cutRectangle == 'function');
 ```
 
-`cutRectangle(2, 2)` should return a number.
+`cutRectangle(2, 2)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof cutRectangle(2, 2) == 'number');
 ```
 
-`cutRectangle(2, 2)` should return `2`.
+`cutRectangle(2, 2)` sollte `2` zurückgeben.
 
 ```js
 assert.equal(cutRectangle(2, 2), 2);
 ```
 
-`cutRectangle(4, 3)` should return `9`.
+`cutRectangle(4, 3)` sollte `9` zurückgeben.
 
 ```js
 assert.equal(cutRectangle(4, 3), 9);
 ```
 
-`cutRectangle(4, 4)` should return `22`.
+`cutRectangle(4, 4)` sollte `22` zurückgeben.
 
 ```js
 assert.equal(cutRectangle(4, 4), 22);
 ```
 
-`cutRectangle(8, 3)` should return `53`.
+`cutRectangle(8, 3)` sollte `53` zurückgeben.
 
 ```js
 assert.equal(cutRectangle(8, 3), 53);
 ```
 
-`cutRectangle(7, 4)` should return `151`.
+`cutRectangle(7, 4)` sollte `151` zurückgeben.
 
 ```js
 assert.equal(cutRectangle(7, 4), 151);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-format.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-format.md
index 1d5f06010c2..400242262cb 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-format.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-format.md
@@ -25,13 +25,13 @@ Example outputs:
 
 # --hints--
 
-`getDateFormats` should be a function.
+`getDateFormats` sollte eine Funktion sein.
 
 ```js
 assert(typeof getDateFormats === 'function');
 ```
 
-`getDateFormats` should return an object.
+`getDateFormats` sollte ein Objekt zurückgeben.
 
 ```js
 assert(typeof getDateFormats() === 'object');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-manipulation.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-manipulation.md
index 8c9e853bb80..092e36c21ed 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-manipulation.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/date-manipulation.md
@@ -16,19 +16,19 @@ Example output: `"March 7 2009 7:30am EST"`
 
 # --hints--
 
-`add12Hours` should be a function.
+`add12Hours` sollte eine Funktion sein.
 
 ```js
 assert(typeof add12Hours === 'function');
 ```
 
-`add12Hours(dateString)` should return a string.
+`add12Hours(dateString)` sollte einen String zurückgeben.
 
 ```js
 assert(typeof add12Hours('January 17 2017 11:43am EST') === 'string');
 ```
 
-`add12Hours("January 17 2017 11:43am EST")` should return `"January 17 2017 11:43pm EST"`
+`add12Hours("January 17 2017 11:43am EST")` sollte `"January 17 2017 11:43pm EST"` zurückgeben
 
 ```js
 assert(
@@ -36,25 +36,25 @@ assert(
 );
 ```
 
-Should handle day change. `add12Hours("March 6 2009 7:30pm EST")` should return `"March 7 2009 7:30am EST"`
+Should handle day change. `add12Hours("March 6 2009 7:30pm EST")` sollte `"March 7 2009 7:30am EST"` zurückgeben
 
 ```js
 assert(add12Hours('March 6 2009 7:30pm EST') === 'March 7 2009 7:30am EST');
 ```
 
-Should handle month change in a leap years. `add12Hours("February 29 2004 9:15pm EST")` should return `"March 1 2004 9:15am EST"`
+Should handle month change in a leap years. `add12Hours("February 29 2004 9:15pm EST")` sollte `"March 1 2004 9:15am EST"` zurückgeben
 
 ```js
 assert(add12Hours('February 29 2004 9:15pm EST') === 'March 1 2004 9:15am EST');
 ```
 
-Should handle month change in a common years. `add12Hours("February 28 1999 3:15pm EST")` should return `"March 1 1999 3:15am EST"`
+Should handle month change in a common years. `add12Hours("February 28 1999 3:15pm EST")` sollte `"March 1 1999 3:15am EST"` zurückgeben
 
 ```js
 assert(add12Hours('February 28 1999 3:15pm EST') === 'March 1 1999 3:15am EST');
 ```
 
-Should handle year change. `add12Hours("December 31 2020 1:45pm EST")` should return `"January 1 2021 1:45am EST"`
+Should handle year change. `add12Hours("December 31 2020 1:45pm EST")` sollte `"January 1 2021 1:45am EST"` zurückgeben
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/day-of-the-week.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/day-of-the-week.md
index e41d1e48dae..498feec405f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/day-of-the-week.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/day-of-the-week.md
@@ -16,25 +16,25 @@ Write a function that takes a start year and an end year and return an array of
 
 # --hints--
 
-`findXmasSunday` should be a function.
+`findXmasSunday` sollte eine Funktion sein.
 
 ```js
 assert(typeof findXmasSunday === 'function');
 ```
 
-`findXmasSunday(2000, 2100)` should return an array.
+`findXmasSunday(2000, 2100)` sollte ein Array zurückgeben.
 
 ```js
 assert(typeof findXmasSunday(2000, 2100) === 'object');
 ```
 
-`findXmasSunday(1970, 2017)` should return `[1977, 1983, 1988, 1994, 2005, 2011, 2016]`
+`findXmasSunday(1970, 2017)` sollte `[1977, 1983, 1988, 1994, 2005, 2011, 2016]` zurückgeben
 
 ```js
 assert.deepEqual(findXmasSunday(1970, 2017), firstSolution);
 ```
 
-`findXmasSunday(2008, 2121)` should return `[2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]`
+`findXmasSunday(2008, 2121)` sollte `[2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]` zurückgeben
 
 ```js
 assert.deepEqual(findXmasSunday(2008, 2121), secondSolution);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deal-cards-for-freecell.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deal-cards-for-freecell.md
index b6a78ff636a..43ff89b7a2f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deal-cards-for-freecell.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deal-cards-for-freecell.md
@@ -35,7 +35,7 @@ The algorithm follows:
   <li>Deal all 52 cards, face up, across 8 columns. The first 8 cards go in 8 columns, the next 8 cards go on the first 8 cards, and so on.</li>
 </ol>
 
-**Example:**
+**Beispiel:**
 
 **Order to deal cards**
 
@@ -47,7 +47,7 @@ The algorithm follows:
 41 42 43 44 45 46 47 48
 49 50 51 52</pre>
 
-**Game #1**
+**Spiel #1**
 
 ```js
 [
@@ -61,7 +61,7 @@ The algorithm follows:
 ]
 ```
 
-**Game #617**
+**Spiel #617**
 
 ```js
 [
@@ -81,13 +81,13 @@ Write a function to take a deal number and deal cards in the same order as this
 
 # --hints--
 
-`dealFreeCell` should be a function.
+`dealFreeCell` sollte eine Funktion sein.
 
 ```js
 assert(typeof dealFreeCell === 'function');
 ```
 
-`dealFreeCell(seed)` should return an object.
+`dealFreeCell(seed)` sollte ein Objekt zurückgeben.
 
 ```js
 assert(typeof dealFreeCell(1) === 'object');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deepcopy.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deepcopy.md
index dc7666cee51..286e3d23f7a 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deepcopy.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/deepcopy.md
@@ -21,13 +21,13 @@ This task will not test for:
 
 # --hints--
 
-`deepcopy` should be a function.
+`deepcopy` sollte eine Funktion sein.
 
 ```js
 assert(typeof deepcopy === 'function');
 ```
 
-`deepcopy({test: "test"})` should return an object.
+`deepcopy({test: "test"})` sollte ein Objekt zurückgeben.
 
 ```js
 assert(typeof deepcopy(obj1) === 'object');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/define-a-primitive-data-type.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/define-a-primitive-data-type.md
index e7909424694..a04342ec054 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/define-a-primitive-data-type.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/define-a-primitive-data-type.md
@@ -19,13 +19,13 @@ Error handling:
 
 # --hints--
 
-`Num` should be a function.
+`Num` sollte eine Funktion sein.
 
 ```js
 assert(typeof Num === 'function');
 ```
 
-`new Num(4)` should return an object.
+`new Num(4)` sollte ein Objekt zurückgeben.
 
 ```js
 assert(typeof new Num(4) === 'object');
@@ -97,7 +97,7 @@ assert(new Num(3) < new Num(4));
 assert(!(new Num(3) > new Num(4)));
 ```
 
-`(new Num(5)).toString()` should return '5'
+`(new Num(5)).toString()` sollte '5' zurückgeben
 
 ```js
 assert.equal(new Num(5).toString(), '5');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/department-numbers.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/department-numbers.md
index 1117963ac08..5edd175be5e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/department-numbers.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/department-numbers.md
@@ -36,7 +36,7 @@ Write a program which outputs all valid combinations as an array.
 
 # --hints--
 
-`combinations` should be a function.
+`combinations` sollte eine Funktion sein.
 
 ```js
 assert(typeof combinations === 'function');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/discordian-date.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/discordian-date.md
index bff43ccc37e..7ebc72c1ca6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/discordian-date.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/discordian-date.md
@@ -29,13 +29,13 @@ Note that the day Chaos 1, 3188 YOLD in the Discordian calendar is the day Janua
 
 # --hints--
 
-`discordianDate` should be a function.
+`discordianDate` sollte eine Funktion sein.
 
 ```js
 assert(typeof discordianDate === 'function');
 ```
 
-`discordianDate(new Date(2010, 6, 22))` should return `"Pungenday, the 57th day of Confusion in the YOLD 3176"`.
+`discordianDate(new Date(2010, 6, 22))` sollte `"Pungenday, the 57th day of Confusion in the YOLD 3176"` zurückgeben.
 
 ```js
 assert(
@@ -44,7 +44,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2012, 1, 28))` should return `"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"`.
+`discordianDate(new Date(2012, 1, 28))` sollte `"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"` zurückgeben.
 
 ```js
 assert(
@@ -53,7 +53,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2012, 1, 29))` should return `"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\'s Day!"`.
+`discordianDate(new Date(2012, 1, 29))` sollte `"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\'s Day!"` zurückgeben.
 
 ```js
 assert(
@@ -62,7 +62,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2012, 2, 1))` should return `"Setting Orange, the 60th day of Chaos in the YOLD 3178"`.
+`discordianDate(new Date(2012, 2, 1))` sollte `"Setting Orange, the 60th day of Chaos in the YOLD 3178"` zurückgeben.
 
 ```js
 assert(
@@ -71,7 +71,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2010, 0, 5))` should return `"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"`.
+`discordianDate(new Date(2010, 0, 5))` sollte `"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"` zurückgeben.
 
 ```js
 assert(
@@ -80,7 +80,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2011, 4, 3))` should return `"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"`.
+`discordianDate(new Date(2011, 4, 3))` sollte `"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"` zurückgeben.
 
 ```js
 assert(
@@ -89,7 +89,7 @@ assert(
 );
 ```
 
-`discordianDate(new Date(2015, 9, 19))` should return `"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"`.
+`discordianDate(new Date(2015, 9, 19))` sollte `"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"` zurückgeben.
 
 ```js
 assert(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/dot-product.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/dot-product.md
index 0e0fb5c838a..d4b004d06bf 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/dot-product.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/dot-product.md
@@ -12,43 +12,43 @@ Create a function, to compute the **dot product**, also known as the **scalar pr
 
 # --hints--
 
-`dotProduct` should be a function.
+`dotProduct` sollte eine Funktion zurückgeben.
 
 ```js
 assert(typeof dotProduct == 'function');
 ```
 
-`dotProduct([1, 3, -5], [4, -2, -1])` should return a number.
+`dotProduct([1, 3, -5], [4, -2, -1])` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof dotProduct([1, 3, -5], [4, -2, -1]) == 'number');
 ```
 
-`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([1, 2, 3, 4, 5], [6, 7, 8, 9, 10])` should return `130`.
+`dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10])` sollte `130` zurückgeben.
 
 ```js
 assert.equal(dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]), 130);
 ```
 
-`dotProduct([5, 4, 3, 2], [7, 8, 9, 6])` should return `106`.
+`dotProduct([5, 4, 3, 2], [7, 8, 9, 6])` sollte `106` zurückgeben.
 
 ```js
 assert.equal(dotProduct([5, 4, 3, 2], [7, 8, 9, 6]), 106);
 ```
 
-`dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6])` should return `-36`.
+`dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6])` sollte `-36` zurückgeben.
 
 ```js
 assert.equal(dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6]), -36);
 ```
 
-`dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110])` should return `10392`.
+`dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110])` sollte `10392` zurückgeben.
 
 ```js
 assert.equal(dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110]), 10392);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/element-wise-operations.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/element-wise-operations.md
index 8f4b6d005a7..3417543165c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/element-wise-operations.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/element-wise-operations.md
@@ -24,13 +24,13 @@ The first parameter will be the operation to be performed, for example, "m_add"
 
 # --hints--
 
-`operation` should be a function.
+`operation` sollte eine Funktion sein.
 
 ```js
 assert(typeof operation === 'function');
 ```
 
-`operation("m_add",[[1,2],[3,4]],[[1,2],[3,4]])` should return `[[2,4],[6,8]]`.
+`operation("m_add",[[1,2],[3,4]],[[1,2],[3,4]])` sollte `[[2,4],[6,8]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -52,7 +52,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("s_add",[[1,2],[3,4]],2)` should return `[[3,4],[5,6]]`.
+`operation("s_add",[[1,2],[3,4]],2)` sollte `[[3,4],[5,6]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -71,7 +71,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("m_sub",[[1,2],[3,4]],[[1,2],[3,4]])` should return `[[0,0],[0,0]]`.
+`operation("m_sub",[[1,2],[3,4]],[[1,2],[3,4]])` sollte `[[0,0],[0,0]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -93,7 +93,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("m_mult",[[1,2],[3,4]],[[1,2],[3,4]])` should return `[[1,4],[9,16]]`.
+`operation("m_mult",[[1,2],[3,4]],[[1,2],[3,4]])` sollte `[[1,4],[9,16]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -115,7 +115,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("m_div",[[1,2],[3,4]],[[1,2],[3,4]])` should return `[[1,1],[1,1]]`.
+`operation("m_div",[[1,2],[3,4]],[[1,2],[3,4]])` sollte `[[1,1],[1,1]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -137,7 +137,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])` should return `[[1,4],[27,256]]`.
+`operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])` sollte `[[1,4],[27,256]]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -159,7 +159,7 @@ assert.deepEqual(
 );
 ```
 
-`operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])` should return `[[10,12,14,16],[18,20,22,24]]`.
+`operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])` sollte `[[10,12,14,16],[18,20,22,24]]` zurückgeben.
 
 ```js
 assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/emirp-primes.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/emirp-primes.md
index 97240396a41..c29f3ecdc96 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/emirp-primes.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/emirp-primes.md
@@ -25,13 +25,13 @@ The function should accept two parameters. The first will receive `n` or the ran
 
 # --hints--
 
-`emirps` should be a function.
+`emirps` sollte eine Funktion sein.
 
 ```js
 assert(typeof emirps === 'function');
 ```
 
-`emirps(20,true)` should return `[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]`
+`emirps(20,true)` sollte `[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]` zurückgeben
 
 ```js
 assert.deepEqual(emirps(20, true), [
@@ -58,13 +58,13 @@ assert.deepEqual(emirps(20, true), [
 ]);
 ```
 
-`emirps(1000)` should return `70529`
+`emirps(1000)` sollte `70529` zurückgeben
 
 ```js
 assert.deepEqual(emirps(1000), 70529);
 ```
 
-`emirps([7700,8000],true)` should return `[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]`
+`emirps([7700,8000],true)` sollte `[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]` zurückgeben
 
 ```js
 assert.deepEqual(emirps([7700, 8000], true), [
@@ -82,7 +82,7 @@ assert.deepEqual(emirps([7700, 8000], true), [
 ]);
 ```
 
-`emirps([7700,8000],false)` should return `11`
+`emirps([7700,8000],false)` sollte `11` zurückgeben
 
 ```js
 assert.deepEqual(emirps([7700, 8000], false), 11);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/entropy.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/entropy.md
index fa596bd4891..62f5f5533f0 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/entropy.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/entropy.md
@@ -18,43 +18,43 @@ where $count_i$ is the count of character $n_i$.
 
 # --hints--
 
-`entropy` should be a function.
+`entropy` sollte eine Funktion sein.
 
 ```js
 assert(typeof entropy === 'function');
 ```
 
-`entropy("0")` should return `0`
+`entropy("0")` sollte `0` zurückgeben
 
 ```js
 assert.equal(entropy('0'), 0);
 ```
 
-`entropy("01")` should return `1`
+`entropy("01")` sollte `1` zurückgeben
 
 ```js
 assert.equal(entropy('01'), 1);
 ```
 
-`entropy("0123")` should return `2`
+`entropy("0123")` sollte `2` zurückgeben
 
 ```js
 assert.equal(entropy('0123'), 2);
 ```
 
-`entropy("01234567")` should return `3`
+`entropy("01234567")` sollte `3` zurückgeben
 
 ```js
 assert.equal(entropy('01234567'), 3);
 ```
 
-`entropy("0123456789abcdef")` should return `4`
+`entropy("0123456789abcdef")` sollte `4` zurückgeben
 
 ```js
 assert.equal(entropy('0123456789abcdef'), 4);
 ```
 
-`entropy("1223334444")` should return `1.8464393446710154`
+`entropy("1223334444")` sollte `1.8464393446710154` zurückgeben
 
 ```js
 assert.equal(entropy('1223334444'), 1.8464393446710154);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/equilibrium-index.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/equilibrium-index.md
index 2076d7d75b0..3dca3753dce 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/equilibrium-index.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/equilibrium-index.md
@@ -46,43 +46,43 @@ Assume that the sequence may be very long.
 
 # --hints--
 
-`equilibrium` should be a function.
+`equilibrium` sollte eine Funktion sein.
 
 ```js
 assert(typeof equilibrium === 'function');
 ```
 
-`equilibrium([-7, 1, 5, 2, -4, 3, 0])` should return `[3,6]`.
+`equilibrium([-7, 1, 5, 2, -4, 3, 0])` sollte `[3,6]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[0]), ans[0]);
 ```
 
-`equilibrium([2, 4, 6])` should return `[]`.
+`equilibrium([2, 4, 6])` sollte `[]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[1]), ans[1]);
 ```
 
-`equilibrium([2, 9, 2])` should return `[1]`.
+`equilibrium([2, 9, 2])` sollte `[1]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[2]), ans[2]);
 ```
 
-`equilibrium([1, -1, 1, -1, 1, -1, 1])` should return `[0,1,2,3,4,5,6]`.
+`equilibrium([1, -1, 1, -1, 1, -1, 1])` sollte `[0,1,2,3,4,5,6]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[3]), ans[3]);
 ```
 
-`equilibrium([1])` should return `[0]`.
+`equilibrium([1])` sollte `[0]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[4]), ans[4]);
 ```
 
-`equilibrium([])` should return `[]`.
+`equilibrium([])` sollte `[]` zurückgeben.
 
 ```js
 assert.deepEqual(equilibrium(equilibriumTests[5]), ans[5]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ethiopian-multiplication.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ethiopian-multiplication.md
index a46d599aa1b..a63d09deca3 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ethiopian-multiplication.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/ethiopian-multiplication.md
@@ -10,7 +10,7 @@ dashedName: ethiopian-multiplication
 
 Ethiopian multiplication is a method of multiplying integers using only addition, doubling, and halving.
 
-**Method:**
+**Methode:**
 
 <ol>
   <li>Take two numbers to be multiplied and write them down at the top of two columns</li>
@@ -20,7 +20,7 @@ Ethiopian multiplication is a method of multiplying integers using only addition
   <li>Sum the values in the right-hand column that remain to produce the result of multiplying the original two numbers together</li>
 </ol>
 
-**For example:** `17 × 34`
+**Zum Beispiel:** `17 × 34`
 
 <pre>17   34
 </pre>
@@ -85,37 +85,37 @@ Use these functions to create a function that does Ethiopian multiplication.
 
 # --hints--
 
-`eth_mult` should be a function.
+`eth_mult` sollte eine Funktion sein.
 
 ```js
 assert(typeof eth_mult === 'function');
 ```
 
-`eth_mult(17,34)` should return `578`.
+`eth_mult(17,34)` sollte `578` zurückgeben.
 
 ```js
 assert.equal(eth_mult(17, 34), 578);
 ```
 
-`eth_mult(23,46)` should return `1058`.
+`eth_mult(23,46)` sollte `1058` zurückgeben.
 
 ```js
 assert.equal(eth_mult(23, 46), 1058);
 ```
 
-`eth_mult(12,27)` should return `324`.
+`eth_mult(12,27)` sollte `324` zurückgeben.
 
 ```js
 assert.equal(eth_mult(12, 27), 324);
 ```
 
-`eth_mult(56,98)` should return `5488`.
+`eth_mult(56,98)` sollte `5488` zurückgeben.
 
 ```js
 assert.equal(eth_mult(56, 98), 5488);
 ```
 
-`eth_mult(63,74)` should return `4662`.
+`eth_mult(63,74)` sollte `4662` zurückgeben.
 
 ```js
 assert.equal(eth_mult(63, 74), 4662);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/euler-method.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/euler-method.md
index 184c5a06891..49942e34bb6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/euler-method.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/euler-method.md
@@ -56,7 +56,7 @@ Newton's cooling law describes how an object of initial temperature $T(t_0) = T_
   <li><big>$\frac{dT(t)}{dt} = -k \, \Delta T$</big></li>
 </ul>
 
-or
+oder
 
 <ul style='list-style: none;'>
   <li><big>$\frac{dT(t)}{dt} = -k \, (T(t) - T_R)$</big></li>
@@ -76,7 +76,7 @@ Implement a routine of Euler's method and then use it to solve the given example
 
 <ul>
   <li><code>2 s</code></li>
-  <li><code>5 s</code> and</li>
+  <li><code>5 s</code> und</li>
   <li><code>10 s</code></li>
 </ul>
 
@@ -95,31 +95,31 @@ First parameter to the function is initial time, second parameter is initial tem
 
 # --hints--
 
-`eulersMethod` should be a function.
+`eulersMethod` sollte eine Funktion sein.
 
 ```js
 assert(typeof eulersMethod === 'function');
 ```
 
-`eulersMethod(0, 100, 100, 2)` should return a number.
+`eulersMethod(0, 100, 100, 2)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof eulersMethod(0, 100, 100, 2) === 'number');
 ```
 
-`eulersMethod(0, 100, 100, 2)` should return 20.0424631833732.
+`eulersMethod(0, 100, 100, 2)` sollte 20.0424631833732 zurückgeben.
 
 ```js
 assert.equal(eulersMethod(0, 100, 100, 2), 20.0424631833732);
 ```
 
-`eulersMethod(0, 100, 100, 5)` should return 20.01449963666907.
+`eulersMethod(0, 100, 100, 5)` sollte 20.01449963666907 zurückgeben.
 
 ```js
 assert.equal(eulersMethod(0, 100, 100, 5), 20.01449963666907);
 ```
 
-`eulersMethod(0, 100, 100, 10)` should return 20.000472392.
+`eulersMethod(0, 100, 100, 10)` sollte 20.000472392 zurückgeben.
 
 ```js
 assert.equal(eulersMethod(0, 100, 100, 10), 20.000472392);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.md
index 30eeec21ba6..e26a04f4673 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.md
@@ -16,37 +16,37 @@ $\\binom{n}{k} = \\frac{n!}{(n-k)!k!} = \\frac{n(n-1)(n-2)\\ldots(n-k+1)}{k(k-1)
 
 # --hints--
 
-`binom` should be a function.
+`binom` sollte eine Funktion sein.
 
 ```js
 assert(typeof binom === 'function');
 ```
 
-`binom(5,3)` should return 10.
+`binom(5,3)` sollte 10 zurückgeben.
 
 ```js
 assert.equal(binom(5, 3), 10);
 ```
 
-`binom(7,2)` should return 21.
+`binom(7,2)` sollte 21 zurückgeben.
 
 ```js
 assert.equal(binom(7, 2), 21);
 ```
 
-`binom(10,4)` should return 210.
+`binom(10,4)` sollte 210 zurückgeben.
 
 ```js
 assert.equal(binom(10, 4), 210);
 ```
 
-`binom(6,1)` should return 6.
+`binom(6,1)` sollte 6 zurückgeben.
 
 ```js
 assert.equal(binom(6, 1), 6);
 ```
 
-`binom(12,8)` should return 495.
+`binom(12,8)` sollte 495 zurückgeben.
 
 ```js
 assert.equal(binom(12, 8), 495);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.md
index 112483733bf..b7b6ae55e0e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.md
@@ -14,7 +14,7 @@ We have added in the background:
 
 The `rules` in the form of nested array, and the `data` in the form of array, too. And the desired `outputs`.
 
-The `rules`:
+Die `rules`:
 
 ```js
 let rules=[
@@ -76,37 +76,37 @@ Using Markov Algorithm, change the `data` into the desired `outputs` using the
 
 # --hints--
 
-`markov` should be a function.
+`markov` solle eine Funktion sein.
 
 ```js
 assert(typeof markov === 'function');
 ```
 
-`markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")` should return the string `I bought a bag of apples from my brother.`.
+`markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")` sollte den String `I bought a bag of apples from my brother.` zurückgeben.
 
 ```js
 assert.deepEqual(markov(rules[0], datas[0]), outputs[0]);
 ```
 
-`markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")` should return the string `I bought a bag of apples from T shop.`.
+`markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")` sollte den String `I bought a bag of apples from T shop.` zurückgeben.
 
 ```js
 assert.deepEqual(markov(rules[1], datas[1]), outputs[1]);
 ```
 
-`markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")` should return the string `I bought a bag of apples with my money from T shop.`.
+`markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")` sollte den String `I bought a bag of apples with my money from T shop.` zurückgeben.
 
 ```js
 assert.deepEqual(markov(rules[2], datas[2]), outputs[2]);
 ```
 
-`markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")` should return the string `11111111111111111111`.
+`markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")` sollte den String `11111111111111111111` zurückgeben.
 
 ```js
 assert.deepEqual(markov(rules[3], datas[3]), outputs[3]);
 ```
 
-`markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")` should return the string `00011H1111000`.
+`markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")` sollte den String `00011H1111000` zurückgeben.
 
 ```js
 assert.deepEqual(markov(rules[4], datas[4]), outputs[4]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/extensible-prime-generator.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/extensible-prime-generator.md
index d1f52b54af1..c8c77b714d1 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/extensible-prime-generator.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/extensible-prime-generator.md
@@ -23,13 +23,13 @@ The function should have two parameters. The first will receive `n` or the range
 
 # --hints--
 
-`primeGenerator` should be a function.
+`primeGenerator` sollte eine Funktion sein.
 
 ```js
 assert(typeof primeGenerator === 'function');
 ```
 
-`primeGenerator(20, true)` should return `[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]`.
+`primeGenerator(20, true)` sollte `[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]` zurückgeben.
 
 ```js
 assert.deepEqual(primeGenerator(20, true), [
@@ -56,7 +56,7 @@ assert.deepEqual(primeGenerator(20, true), [
 ]);
 ```
 
-`primeGenerator([100, 150], true)` should return `[101, 103, 107, 109, 113, 127, 131, 137, 139, 149]`.
+`primeGenerator([100, 150], true)` sollte `[101, 103, 107, 109, 113, 127, 131, 137, 139, 149]` zurückgeben.
 
 ```js
 assert.deepEqual(primeGenerator([100, 150], true), [
@@ -73,13 +73,13 @@ assert.deepEqual(primeGenerator([100, 150], true), [
 ]);
 ```
 
-`primeGenerator([7700, 8000], false)` should return `30`.
+`primeGenerator([7700, 8000], false)` sollte `30` zurückgeben.
 
 ```js
 assert.equal(primeGenerator([7700, 8000], false), 30);
 ```
 
-`primeGenerator(10000, false)` should return `104729`.
+`primeGenerator(10000, false)` sollte `104729` zurückgeben.
 
 ```js
 assert.equal(primeGenerator(10000, false), 104729);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factorial.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factorial.md
index a6a6e87f1aa..0ced6fb32e9 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factorial.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factorial.md
@@ -15,7 +15,7 @@ Factorial of a number is given by:
 <pre><big>n! = n * (n-1) * (n-2) * ..... * 1</big>
 </pre>
 
-For example:
+Zum Beispiel:
 
 <ul>
   <li><code>3! = 3 * 2 * 1 = 6</code></li>
@@ -26,31 +26,31 @@ For example:
 
 # --hints--
 
-`factorial` should be a function.
+`factorial` sollte eine Funktion sein.
 
 ```js
 assert(typeof factorial === 'function');
 ```
 
-`factorial(2)` should return a number.
+`factorial(2)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof factorial(2) === 'number');
 ```
 
-`factorial(3)` should return 6.
+`factorial(3)` sollte 6 zurückgeben.
 
 ```js
 assert.equal(factorial(3), 6);
 ```
 
-`factorial(5)` should return 120.
+`factorial(5)` sollte 120 zurückgeben.
 
 ```js
 assert.equal(factorial(5), 120);
 ```
 
-`factorial(10)` should return 3,628,800.
+`factorial(10)` sollte 3,628,800 zurückgeben.
 
 ```js
 assert.equal(factorial(10), 3628800);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-a-mersenne-number.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-a-mersenne-number.md
index 23502e37435..a7eb8ffb4ea 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-a-mersenne-number.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-a-mersenne-number.md
@@ -58,31 +58,31 @@ Using the above method find a factor of <code>2<sup>p</sup>-1</code>.
 
 # --hints--
 
-`check_mersenne` should be a function.
+`check_mersenne` sollte eine Funktion sein.
 
 ```js
 assert(typeof check_mersenne === 'function');
 ```
 
-`check_mersenne(3)` should return a string.
+`check_mersenne(3)` sollte einen String zurückgeben.
 
 ```js
 assert(typeof check_mersenne(3) == 'string');
 ```
 
-`check_mersenne(3)` should return the string `M3 = 2^3-1 is prime`.
+`check_mersenne(3)` sollte den String `M3 = 2^3-1 is prime` zurückgeben.
 
 ```js
 assert.equal(check_mersenne(3), 'M3 = 2^3-1 is prime');
 ```
 
-`check_mersenne(23)` should return the string `M23 = 2^23-1 is composite with factor 47`.
+`check_mersenne(23)` sollte den String `M23 = 2^23-1 is composite with factor 47` zurückgeben.
 
 ```js
 assert.equal(check_mersenne(23), 'M23 = 2^23-1 is composite with factor 47');
 ```
 
-`check_mersenne(929)` should return the string `M929 = 2^929-1 is composite with factor 13007`.
+`check_mersenne(929)` sollte den String `M929 = 2^929-1 is composite with factor 13007` zurückgeben.
 
 ```js
 assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-an-integer.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-an-integer.md
index 8de06b3c4f0..a228bfd5c8e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-an-integer.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/factors-of-an-integer.md
@@ -14,25 +14,25 @@ These factors are the positive integers by which the number being factored can b
 
 # --hints--
 
-`factors` should be a function.
+`factors` sollte eine Funktion sein.
 
 ```js
 assert(typeof factors === 'function');
 ```
 
-`factors(45)` should return `[1,3,5,9,15,45]`.
+`factors(45)` sollte `[1,3,5,9,15,45]` zurückgeben.
 
 ```js
 assert.deepEqual(factors(45), ans[0]);
 ```
 
-`factors(53)` should return `[1,53]`.
+`factors(53)` sollte `[1,53]` zurückgeben.
 
 ```js
 assert.deepEqual(factors(53), ans[1]);
 ```
 
-`factors(64)` should return `[1,2,4,8,16,32,64]`.
+`factors(64)` sollte `[1,2,4,8,16,32,64]` zurückgeben.
 
 ```js
 assert.deepEqual(factors(64), ans[2]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/farey-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/farey-sequence.md
index 71962b17362..999a95e0520 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/farey-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/farey-sequence.md
@@ -22,7 +22,7 @@ Each Farey sequence:
 The Farey sequences of orders `1` to `5` are:
 
 <ul>
-  <li style='list-style: none;'>${\bf\it{F}}_1 = \frac{0}{1}, \frac{1}{1}$</li>
+  <li style='list-style: none;'>${bfit{F}}_1 = frac{0}{1}, frac{1}{1}$</li>
   <li style='list-style: none;'>${\bf\it{F}}_2 = \frac{0}{1}, \frac{1}{2}, \frac{1}{1}$</li>
   <li style='list-style: none;'>${\bf\it{F}}_3 = \frac{0}{1}, \frac{1}{3}, \frac{1}{2}, \frac{2}{3}, \frac{1}{1}$</li>
   <li style='list-style: none;'>${\bf\it{F}}_4 = \frac{0}{1}, \frac{1}{4}, \frac{1}{3}, \frac{1}{2}, \frac{2}{3}, \frac{3}{4}, \frac{1}{1}$</li>
@@ -35,31 +35,31 @@ Write a function that returns the Farey sequence of order `n`. The function shou
 
 # --hints--
 
-`farey` should be a function.
+`Farey` sollte eine Funktion sein.
 
 ```js
 assert(typeof farey === 'function');
 ```
 
-`farey(3)` should return an array
+`Farey(3)` sollte ein Array zurückgeben
 
 ```js
 assert(Array.isArray(farey(3)));
 ```
 
-`farey(3)` should return `['0/1','1/3','1/2','2/3','1/1']`
+`farey(3)` sollte `['0/1','1/3','1/2','2/3','1/1']` zurückgeben
 
 ```js
 assert.deepEqual(farey(3),['0/1', '1/3', '1/2', '2/3', '1/1']);
 ```
 
-`farey(4)` should return `['0/1','1/4','1/3','1/2','2/3','3/4','1/1']`
+`farey(4)` sollte `['0/1','1/4','1/3','1/2','2/3','3/4','1/1']` zurückgeben
 
 ```js
 assert.deepEqual(farey(4), ['0/1', '1/4', '1/3', '1/2', '2/3', '3/4', '1/1']);
 ```
 
-`farey(5)` should return `['0/1','1/5','1/4','1/3','2/5','1/2','3/5','2/3','3/4','4/5','1/1']`
+`farey(5)` sollte `['0/1','1/5','1/4','1/3','2/5','1/2','3/5','2/3','3/4','4/5','1/1']` zurückgeben
 
 ```js
 assert.deepEqual(farey(5), [
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.md
index 540c7372b1e..9fcd02dfd3d 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.md
@@ -41,49 +41,49 @@ Write a function to generate Fibonacci $n$-step number sequences and Lucas seque
 
 # --hints--
 
-`fib_luc` should be a function.
+`fib_luc` sollte eine Funktion sein.
 
 ```js
 assert(typeof fib_luc === 'function');
 ```
 
-`fib_luc(2,10,"f")` should return `[1,1,2,3,5,8,13,21,34,55]`.
+`fib_luc(2,10,"f")` sollte `[1,1,2,3,5,8,13,21,34,55]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(2, 10, 'f'), ans[0]);
 ```
 
-`fib_luc(3,15,"f")` should return `[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]`.
+`fib_luc(3,15,"f")` sollte `[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(3, 15, 'f'), ans[1]);
 ```
 
-`fib_luc(4,15,"f")` should return `[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]`.
+`fib_luc(4,15,"f")` sollte `[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(4, 15, 'f'), ans[2]);
 ```
 
-`fib_luc(2,10,"l")` should return `[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]`.
+`fib_luc(2,10,"l")` sollte `[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(2, 10, 'l'), ans[3]);
 ```
 
-`fib_luc(3,15,"l")` should return `[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]`.
+`fib_luc(3,15,"l")` sollte `[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(3, 15, 'l'), ans[4]);
 ```
 
-`fib_luc(4,15,"l")` should return `[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]`.
+`fib_luc(4,15,"l")` sollte `[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(4, 15, 'l'), ans[5]);
 ```
 
-`fib_luc(5,15,"l")` should return `[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]`.
+`fib_luc(5,15,"l")` sollte `[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fib_luc(5, 15, 'l'), ans[6]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-sequence.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-sequence.md
index 4e60775b086..13e6d0ee6f4 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-sequence.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-sequence.md
@@ -20,13 +20,13 @@ Hence, the series is: 0, 1, 1, 2, 3, 5, 8, 13...
 
 # --hints--
 
-`fibonacci` should be a function.
+`fibonacci` sollte eine Funktion sein.
 
 ```js
 assert(typeof fibonacci === 'function');
 ```
 
-`fibonacci(2)` should return a number.
+`fibonacci(2)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof fibonacci(2) == 'number');
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-word.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-word.md
index 464f03b61b7..a05d8dc991f 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-word.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fibonacci-word.md
@@ -24,25 +24,25 @@ Write a function to return the first `n` Fibonacci Words. The number of `n` is p
 
 # --hints--
 
-`fibWord` should be a function.
+`fibWord` sollte eine Funktion sein.
 
 ```js
 assert(typeof fibWord === 'function');
 ```
 
-`fibWord(5)` should return an array.
+`fibWord(5)` sollte ein Array zurückgeben.
 
 ```js
 assert(Array.isArray(fibWord(5)));
 ```
 
-`fibWord(5)` should return `[{ N:1, Length:1, Entropy:0, Word:"1" },{ N:2, Length:1, Entropy:0, Word:"0" },{ N:3, Length:2, Entropy:1, Word:"01" },{ N:4, Length:3, Entropy:0.91829583, Word:"010" },{ N:5, Length:5, Entropy:0.97095059, Word:"01001" }]`.
+`fibWord(5)` sollte `[{ N:1, Length:1, Entropy:0, Word:"1" },{ N:2, Length:1, Entropy:0, Word:"0" },{ N:3, Length:2, Entropy:1, Word:"01" },{ N:4, Length:3, Entropy:0.91829583, Word:"010" },{ N:5, Length:5, Entropy:0.97095059, Word:"01001" }]` zurückgeben.
 
 ```js
 assert.deepEqual(fibWord(5), words5);
 ```
 
-`fibWord(7)` should return `[{ N:1, Length:1, Entropy:0, Word:"1" },{ N:2, Length:1, Entropy:0, Word:"0" },{ N:3, Length:2, Entropy:1, Word:"01" },{ N:4, Length:3, Entropy:0.91829583, Word:"010" },{ N:5, Length:5, Entropy:0.97095059, Word:"01001" }, { N:6, Length:8, Entropy:0.954434, Word:'01001010' }, { N:7, Length:13, Entropy:0.9612366, Word:'0100101001001' }]`.
+`fibWord(7)` sollte `[{ N:1, Length:1, Entropy:0, Word:"1" },{ N:2, Length:1, Entropy:0, Word:"0" },{ N:3, Length:2, Entropy:1, Word:"01" },{ N:4, Length:3, Entropy:0.91829583, Word:"010" },{ N:5, Length:5, Entropy:0.97095059, Word:"01001" }, { N:6, Length:8, Entropy:0.954434, Word:'01001010' }, { N:7, Length:13, Entropy:0.9612366, Word:'0100101001001' }]` zurückgeben.
 
 ```js
 assert.deepEqual(fibWord(7), words7);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fizzbuzz.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fizzbuzz.md
index 400625c512e..f9fcea908f3 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fizzbuzz.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fizzbuzz.md
@@ -8,7 +8,7 @@ dashedName: fizzbuzz
 
 # --description--
 
-Write a program that generates an array of integers from 1 to 100 (inclusive). But:
+Write a program that generates an array of integers from 1 to 100 (inclusive). Aber:
 
 <ul>
     <li>for multiples of 3, add <code>"Fizz"</code> to the array instead of the number</li>
@@ -22,13 +22,13 @@ Your program should return an array containing the results based on the rules ab
 
 # --hints--
 
-`fizzBuzz` should be a function.
+`fizzBuzz` sollte eine Funktion sein.
 
 ```js
 assert(typeof fizzBuzz == 'function');
 ```
 
-`fizzBuzz()` should return an Array.
+`fizzBuzz()` sollte ein Array zurückgeben.
 
 ```js
 assert(Array.isArray(fizzBuzz()) == true);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fractran.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fractran.md
index 4e3daccf125..60bb546cf1c 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fractran.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/fractran.md
@@ -39,7 +39,7 @@ Write a function that takes a fractran program as a string parameter and returns
 
 # --hints--
 
-`fractran` should be a function.
+`fractran` sollte eine Funktion sein.
 
 ```js
 assert(typeof fractran == 'function');
@@ -51,31 +51,31 @@ assert(typeof fractran == 'function');
 assert(Array.isArray(fractran('3/2, 1/3')));
 ```
 
-`fractran("3/2, 1/3")` should return `[ 2, 3, 1 ]`.
+`fractran("3/2, 1/3")` sollte `[ 2, 3, 1 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fractran('3/2, 1/3'), [2, 3, 1]);
 ```
 
-`fractran("3/2, 5/3, 1/5")` should return `[ 2, 3, 5, 1 ]`.
+`fractran("3/2, 5/3, 1/5")` sollte `[ 2, 3, 5, 1 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fractran('3/2, 5/3, 1/5'), [2, 3, 5, 1]);
 ```
 
-`fractran("3/2, 6/3")` should return `[ 2, 3, 6, 9, 18, 27, 54, 81, 162, 243 ]`.
+`fractran("3/2, 6/3")` sollte `[ 2, 3, 6, 9, 18, 27, 54, 81, 162, 243 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fractran('3/2, 6/3'), [2, 3, 6, 9, 18, 27, 54, 81, 162, 243]);
 ```
 
-`fractran("2/7, 7/2")` should return `[ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7 ]`.
+`fractran("2/7, 7/2")` sollte `[ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7 ]` zurückgeben.
 
 ```js
 assert.deepEqual(fractran('2/7, 7/2'), [2, 7, 2, 7, 2, 7, 2, 7, 2, 7]);
 ```
 
-`fractran("17/91, 78/85, 19/51, 23/38, 29/33, 77/29, 95/23, 77/19, 1/17, 11/13, 13/11, 15/14, 15/2, 55/1")` should return `[ 2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290 ]`.
+`fractran("17/91, 78/85, 19/51, 23/38, 29/33, 77/29, 95/23, 77/19, 1/17, 11/13, 13/11, 15/14, 15/2, 55/1")` sollte `[ 2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gamma-function.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gamma-function.md
index 91b6b01786a..f30a6d0833b 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gamma-function.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gamma-function.md
@@ -1,6 +1,6 @@
 ---
 id: 5a23c84252665b21eecc7e76
-title: Gamma function
+title: Gamma-Funktion
 challengeType: 1
 forumTopicId: 302271
 dashedName: gamma-function
@@ -10,49 +10,49 @@ dashedName: gamma-function
 
 Implement one algorithm (or more) to compute the Gamma function (in the real field only).
 
-The Gamma function can be defined as:
+Die Gamma-Funktion kann wie folgt definiert werden:
 
 <div style='padding-left: 4em;'><big><big>$\Gamma(x) = \displaystyle\int_0^\infty t^{x-1}e^{-t} dt$</big></big></div>
 
 # --hints--
 
-`gamma` should be a function.
+`gamma` sollte eine Funktion sein.
 
 ```js
 assert(typeof gamma == 'function');
 ```
 
-`gamma(.1)` should return a number.
+`gamma(.1)` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof gamma(0.1) == 'number');
 ```
 
-`gamma(.1)` should return `9.513507698668736`.
+`gamma(.1)` sollte `9.513507698668736` zurückgeben.
 
 ```js
 assert.equal(round(gamma(0.1)), round(9.513507698668736));
 ```
 
-`gamma(.2)` should return `4.590843711998803`.
+`gamma(.2)` sollte `4.590843711998803` zurückgeben.
 
 ```js
 assert.equal(round(gamma(0.2)), round(4.590843711998803));
 ```
 
-`gamma(.3)` should return `2.9915689876875904`.
+`gamma(.3)` sollte `2.9915689876875904` zurückgeben.
 
 ```js
 assert.equal(round(gamma(0.3)), round(2.9915689876875904));
 ```
 
-`gamma(.4)` should return `2.218159543757687`.
+`gamma(.4)` sollte `2.218159543757687` zurückgeben.
 
 ```js
 assert.equal(round(gamma(0.4)), round(2.218159543757687));
 ```
 
-`gamma(.5)` should return `1.7724538509055159`.
+`gamma(.5)` sollte `1.7724538509055159` zurückgeben.
 
 ```js
 assert.equal(round(gamma(0.5)), round(1.7724538509055159));
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gaussian-elimination.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gaussian-elimination.md
index 53b7860f1fc..6e938ba41ac 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gaussian-elimination.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gaussian-elimination.md
@@ -16,13 +16,13 @@ To improve accuracy, please use partial pivoting and scaling.
 
 # --hints--
 
-`gaussianElimination` should be a function.
+`gaussianElimination` sollte eine Funktion sein.
 
 ```js
 assert(typeof gaussianElimination == 'function');
 ```
 
-`gaussianElimination([[1,1],[1,-1]], [5,1])` should return an array.
+`gaussianElimination([[1,1],[1,-1]], [5,1])` sollte ein Array zurückgeben.
 
 ```js
 assert(
@@ -38,7 +38,7 @@ assert(
 );
 ```
 
-`gaussianElimination([[1,1],[1,-1]], [5,1])` should return `[ 3, 2 ]`.
+`gaussianElimination([[1,1],[1,-1]], [5,1])` sollte `[ 3, 2 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -53,7 +53,7 @@ assert.deepEqual(
 );
 ```
 
-`gaussianElimination([[2,3],[2,1]] , [8,4])` should return `[ 1, 2 ]`.
+`gaussianElimination([[2,3],[2,1]] , [8,4])` sollte `[ 1, 2 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -68,7 +68,7 @@ assert.deepEqual(
 );
 ```
 
-`gaussianElimination([[1,3],[5,-2]], [14,19])` should return `[ 5, 3 ]`.
+`gaussianElimination([[1,3],[5,-2]], [14,19])` sollte `[ 5, 3 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -83,7 +83,7 @@ assert.deepEqual(
 );
 ```
 
-`gaussianElimination([[1,1],[5,-1]] , [10,14])` should return `[ 4, 6 ]`.
+`gaussianElimination([[1,1],[5,-1]] , [10,14])` sollte `[ 4, 6 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
@@ -98,7 +98,7 @@ assert.deepEqual(
 );
 ```
 
-`gaussianElimination([[1,2,3],[4,5,6],[7,8,8]] , [6,15,23])` should return `[ 1, 1, 1 ]`.
+`gaussianElimination([[1,2,3],[4,5,6],[7,8,8]] , [6,15,23])` sollte `[ 1, 1, 1 ]` zurückgeben.
 
 ```js
 assert.deepEqual(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/general-fizzbuzz.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/general-fizzbuzz.md
index 168406d9457..e2ddee93d38 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/general-fizzbuzz.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/general-fizzbuzz.md
@@ -10,9 +10,9 @@ dashedName: general-fizzbuzz
 
 Write a generalized version of <a href="https://rosettacode.org/wiki/FizzBuzz" target="_blank" rel="noopener noreferrer nofollow">FizzBuzz</a> that works for any list of factors, along with their words.
 
-This is basically a "fizzbuzz" implementation where the rules of the game are supplied to the user. Create a function to implement this. The function should take two parameters.
+Dies ist im Grunde eine "Fizzbuzz"-Implementierung, bei der dem Benutzer die Spielregeln vorgegeben werden. Create a function to implement this. The function should take two parameters.
 
-The first will be an array with the FizzBuzz rules. For example: `[ [3, "Fizz"] , [5, "Buzz"] ]`.
+The first will be an array with the FizzBuzz rules. Zum Beispiel: `[ [3, "Fizz"] , [5, "Buzz"] ]`.
 
 This indicates that `Fizz` should be printed if the number is a multiple of 3 and `Buzz` if it is a multiple of 5. If it is a multiple of both then the strings should be concatenated in the order specified in the array. In this case, `FizzBuzz` if the number is a multiple of 3 and 5.
 
@@ -20,13 +20,13 @@ The second parameter is the number for which the function should return a string
 
 # --hints--
 
-`genFizzBuzz` should be a function.
+`genFizzBuzz` sollte eine Funktion sein.
 
 ```js
 assert(typeof genFizzBuzz == 'function');
 ```
 
-`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 6)` should return a string.
+`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 6)` sollte einen String zurückgeben.
 
 ```js
 assert(
@@ -40,7 +40,7 @@ assert(
 );
 ```
 
-`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 6)` should return `"Fizz"`.
+`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 6)` sollte `"Fizz"` zurückgeben.
 
 ```js
 assert.equal(
@@ -55,7 +55,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 10)` should return `"Buzz"`.
+`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 10)` sollte `"Buzz"` zurückgeben.
 
 ```js
 assert.equal(
@@ -70,7 +70,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 12)` should return `"Buzz"`.
+`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 12)` sollte `"Buzz"` zurückgeben.
 
 ```js
 assert.equal(
@@ -85,7 +85,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 13)` should return `"13"`.
+`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 13)` sollte `"13"`zurückgeben.
 
 ```js
 assert.equal(
@@ -100,7 +100,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 15)` should return `"BuzzFizz"`.
+`genFizzBuzz([[3, "Buzz"],[5, "Fizz"]], 15)` sollte `"BuzzFizz"` zurückgeben.
 
 ```js
 assert.equal(
@@ -115,7 +115,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 15)` should return `"FizzBuzz"`.
+`genFizzBuzz([[3, "Fizz"],[5, "Buzz"]], 15)` sollte `"FizzBuzz"` zurückgeben.
 
 ```js
 assert.equal(
@@ -130,7 +130,7 @@ assert.equal(
 );
 ```
 
-`genFizzBuzz([[3, "Fizz"],[5, "Buzz"],[7, "Baxx"]], 105)` should return `"FizzBuzzBaxx"`.
+`genFizzBuzz([[3, "Fizz"],[5, "Buzz"],[7, "Baxx"]], 105)` sollte `"FizzBuzzBaxx"` zurückgeben.
 
 ```js
 assert.equal(
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.md
index eb31c80170b..0a40666c41e 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.md
@@ -8,47 +8,47 @@ dashedName: generate-lower-case-ascii-alphabet
 
 # --description--
 
-Write a function to generate an array of lower case ASCII characters for a given range. For example, given the range `['a', 'd']`, the function should return `['a', 'b', 'c', 'd']`.
+Write a function to generate an array of lower case ASCII characters for a given range. Zum Beispiel: der Bereich `['a', 'd']` sollte die Funktion `['a', 'b', 'c', 'd']` zurückgeben.
 
 # --hints--
 
-`lascii` should be a function.
+`lascii` sollte eine Funktion sein.
 
 ```js
 assert(typeof lascii == 'function');
 ```
 
-`lascii("a","d")` should return an array.
+`lascii("a","d")` sollte ein Array zurückgeben.
 
 ```js
 assert(Array.isArray(lascii('a', 'd')));
 ```
 
-`lascii('a','d')` should return `[ 'a', 'b', 'c', 'd' ]`.
+`lascii('a','d')` sollte `[ 'a', 'b', 'c', 'd' ]` zurückgeben.
 
 ```js
 assert.deepEqual(lascii('a', 'd'), results[0]);
 ```
 
-`lascii('c','i')` should return `[ 'c', 'd', 'e', 'f', 'g', 'h', 'i' ]`.
+`lascii('c','i')` sollte `[ 'c', 'd', 'e', 'f', 'g', 'h', 'i' ]` zurückgeben.
 
 ```js
 assert.deepEqual(lascii('c', 'i'), results[1]);
 ```
 
-`lascii('m','q')` should return `[ 'm', 'n', 'o', 'p', 'q' ]`.
+`lascii('m','q')` sollte `[ 'm', 'n', 'o', 'p', 'q' ]` zurückgeben.
 
 ```js
 assert.deepEqual(lascii('m', 'q'), results[2]);
 ```
 
-`lascii('k','n')` should return `[ 'k', 'l', 'm', 'n' ]`.
+`lascii('k','n')` sollte `[ 'k', 'l', 'm', 'n' ]` zurückgeben.
 
 ```js
 assert.deepEqual(lascii('k', 'n'), results[3]);
 ```
 
-`lascii('t','z')` should return `[ 't', 'u', 'v', 'w', 'x', 'y', 'z' ]`.
+`lascii('t','z')` sollte `[ 't', 'u', 'v', 'w', 'x', 'y', 'z' ]` zurückgeben.
 
 ```js
 assert.deepEqual(lascii('t', 'z'), results[4]);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generator-exponential.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generator-exponential.md
index 6b15a7ca62e..52559a26ef6 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generator-exponential.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/generator-exponential.md
@@ -24,43 +24,43 @@ For example for \\(n=7\\), the function should return 81 as the sequence would b
 
 # --hints--
 
-`exponentialGenerator` should be a function.
+`exponentialGenerator` sollte eine Funktion sein.
 
 ```js
 assert(typeof exponentialGenerator == 'function');
 ```
 
-`exponentialGenerator()` should return a number.
+`exponentialGenerator()` sollte eine Zahl zurückgeben.
 
 ```js
 assert(typeof exponentialGenerator(10) == 'number');
 ```
 
-`exponentialGenerator(10)` should return `144`.
+`exponentialGenerator(10)` sollte `144` zurückgeben.
 
 ```js
 assert.equal(exponentialGenerator(10), 144);
 ```
 
-`exponentialGenerator(12)` should return `196`.
+`exponentialGenerator(12)` sollte `196` zurückgeben.
 
 ```js
 assert.equal(exponentialGenerator(12), 196);
 ```
 
-`exponentialGenerator(14)` should return `256`.
+`exponentialGenerator(14)` sollte `256` zurückgeben.
 
 ```js
 assert.equal(exponentialGenerator(14), 256);
 ```
 
-`exponentialGenerator(20)` should return `484`.
+`exponentialGenerator(20)` sollte `484` zurückgeben.
 
 ```js
 assert.equal(exponentialGenerator(20), 484);
 ```
 
-`exponentialGenerator(25)` should return `784`.
+`exponentialGenerator(25)` sollte `784` zurückgeben.
 
 ```js
 assert.equal(exponentialGenerator(25), 784);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gray-code.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gray-code.md
index ded11f5cac0..429058ca805 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gray-code.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/gray-code.md
@@ -32,7 +32,7 @@ else
   g[i] = b[i]
 </pre>
 
-Or:
+Oder:
 
 <pre>g = b xor (b logically right shifted 1 time)
 </pre>
@@ -40,55 +40,55 @@ Or:
 Decoding (MSB is bit 0, b is binary, g is Gray code):
 
 <pre>b[0] = g[0]<br>
-for other bits:
+für andere Bits:
 b[i] = g[i] xor b[i-1]
 </pre>
 
 # --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
             <i>j<sub>A</sub> =</i>
           </td>
           <td style="border:none">
-            <i><code>Name</code> (i.e. column 1)</i>
+            <i><code>Name</code> (z.B. Spalte 1)</i>
           </td>
           <td style="border:none">
             <i>j<sub>B</sub> =</i>
           </td>
           <td style="border:none">
-            <i><code>Character</code> (i.e. column 0)</i>
+            <i><code>Character</code> (z.B. Spalte 0)</i>
           </td>
         </tr>
       </table>
@@ -143,13 +143,13 @@ The order of the rows in the output table is not significant.
 
 # --hints--
 
-`hashJoin` should be a function.
+`hashJoin` sollte eine Funktion sein.
 
 ```js
 assert(typeof hashJoin === 'function');
 ```
 
-`hashJoin([{ age: 27, name: "Jonah" }, { age: 18, name: "Alan" }, { age: 28, name: "Glory" }, { age: 18, name: "Popeye" }, { age: 28, name: "Alan" }], [{ character: "Jonah", nemesis: "Whales" }, { character: "Jonah", nemesis: "Spiders" }, { character: "Alan", nemesis: "Ghosts" }, { character:"Alan", nemesis: "Zombies" }, { character: "Glory", nemesis: "Buffy" }, { character: "Bob", nemesis: "foo" }])` should return `[{"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Whales"}, {"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Spiders"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}, {"A_age": 28,"A_name": "Glory", "B_character": "Glory", "B_nemesis": "Buffy"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}]`
+`hashJoin([{ age: 27, name: "Jonah" }, { age: 18, name: "Alan" }, { age: 28, name: "Glory" }, { age: 18, name: "Popeye" }, { age: 28, name: "Alan" }], [{ character: "Jonah", nemesis: "Whales" }, { character: "Jonah", nemesis: "Spiders" }, { character: "Alan", nemesis: "Ghosts" }, { character:"Alan", nemesis: "Zombies" }, { character: "Glory", nemesis: "Buffy" }, { character: "Bob", nemesis: "foo" }])` sollte `[{"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Whales"}, {"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Spiders"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}, {"A_age": 28,"A_name": "Glory", "B_character": "Glory", "B_nemesis": "Buffy"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}]` zurückgeben
 
 ```js
 assert.deepEqual(hashJoin(hash1, hash2), res);
diff --git a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/heronian-triangles.md b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/heronian-triangles.md
index 35c83855e3c..4cf513bbfad 100644
--- a/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/heronian-triangles.md
+++ b/curriculum/challenges/german/10-coding-interview-prep/rosetta-code/heronian-triangles.md
@@ -34,31 +34,31 @@ Implement a function based on Hero's formula that returns the first <code>n<sub>
 
 # --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
 <li><span>Look</span> at the number, visually grouping consecutive runs of the same digit.</li>
 <li><span>Say</span> the number, from left to right, group by group; as how many of that digit there are - followed by the digit grouped.</li></ul><span> This becomes the next number of the sequence.</span>
 
-An example:
+Ein Beispiel:
 
 <ul><li>Starting with the number 1, you have <span>one</span> 1 which produces 11</li>
-<li>Starting with 11, you have <span>two</span> 1's. I.E.: 21</li>
+<li>Starting with 11, you have <span>two</span> 1's. z.B.: 21</li>
 <li>Starting with 21, you have <span>one</span> 2, then <span>one</span> 1. I.E.: (12)(11) which becomes 1211</li>
 <li>Starting with 1211, you have <span>one</span> 1, <span>one</span> 2, then <span>two</span> 1's. I.E.: (11)(12)(21) which becomes 111221</li></ul>
 
@@ -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
 
 <code style='margin-left: 2em;'><span style='color:blue;font-weight:bold'>2</span> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...</code>
 
-(Loop)
+(Schleife)
 
 <ul>
   <li>Take the first member of the resultant array as the next ludic number <span style='color:blue;font-weight:bold'>2</span>.</li>
@@ -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', '<code>ludic</code> 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
   <li> Taking the second, fourth ... and every other even digit in the reversed digits:</li>
     <ol>
       <li>Multiply each digit by two and sum the digits if the answer is greater than nine to form partial sums for the even digits.</li>
-      <li>Sum the partial sums of the even digits to form s2.</li>
+      <li>Addiere die Teilsummen der geraden Ziffern, um s2 zu bilden.</li>
     </ol>
   <li>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.</li>
 </ol>
@@ -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 &lt; 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:
 
 <ul>
-  <li>[<i>a</i>, <i>b</i>]: {<i>x</i> | <i>a</i> ≤ <i>x</i> and <i>x</i> ≤ <i>b</i> }</li>
-  <li>(<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> < <i>x</i> and <i>x</i> < <i>b</i> }</li>
-  <li>[<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> ≤ <i>x</i> and <i>x</i> < <i>b</i> }</li>
-  <li>(<i>a</i>, <i>b</i>]: {<i>x</i> | <i>a</i> < <i>x</i> and <i>x</i> ≤ <i>b</i> }</li>
+  <li>[<i>a</i>, <i>b</i>]: {<i>x</i> | <i>a</i> ≤ <i>x</i> und <i>x</i> ≤ <i>b</i> }</li>
+  <li>(<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> < <i>x</i> und <i>x</i> < <i>b</i> }</li>
+  <li>[<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> ≤ <i>x</i> und <i>x</i> < <i>b</i> }</li>
+  <li>(<i>a</i>, <i>b</i>]: {<i>x</i> | <i>a</i> < <i>x</i> und <i>x</i> ≤ <i>b</i> }</li>
 </ul>
 
 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:
 
-<pre>Before:
+<pre>Vorher:
 <b>6 7 8 9</b> 2 5 3 4 1<br>
-After:
+Nachher:
 <b>9 8 7 6</b> 2 5 3 4 1
 </pre>
 
@@ -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 <em>names</em> and <em>addresses</em>. This means that the person who filled in the <em>name</em>, can focus on how it sounds instead of correcting the spelling of <em>names</em>.
 
-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 <em>person</em> without the need for adding every spelling.
 
-Here is the rules: 
+Hier sind die Regeln: 
 
 <ul>
   <li>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.</li>
@@ -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:
 
 <pre><b>123 + 4 - 5 + 67 - 89   =   100</b></pre>
 
 # --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:
 
-1<sup>3</sup> + 12<sup>3</sup> and
+1<sup>3</sup> + 12<sup>3</sup> und
 
 9<sup>3</sup> + 10<sup>3</sup>.
 
@@ -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: <a href="https://codepen.io/freeCodeCamp/full/KzXQgy/" target="_blank" rel="noopener noreferrer nofollow">https://codepen.io/freeCodeCamp/full/KzXQgy/</a>.
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie <a href="https://codepen.io/freeCodeCamp/full/KzXQgy/" target="_blank" rel="noopener noreferrer nofollow">https://codepen.io/freeCodeCamp/full/KzXQgy/</a> 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: <a href="https://p2p-video-chat-application.freecodecamp.rocks/" target="_blank" rel="noopener noreferrer nofollow">https://p2p-video-chat-application.freecodecamp.rocks/</a>.
+**Aufgabe:** Erstelle eine Anwendung, die eine ähnliche Funktionalität wie <a href="https://p2p-video-chat-application.freecodecamp.rocks/" target="_blank" rel="noopener noreferrer nofollow">https://p2p-video-chat-application.freecodecamp.rocks/</a> 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 <a href="https://colab.research.google.com/drive/1hg7ecxGT20B8HR2mV7
 
 ## --text--
 
-What is log<sub>5</sub>(25)?
+Was ist Log<sub>5</sub>(25)?
 
 ## --answers--
 
diff --git a/curriculum/challenges/german/17-college-algebra-with-python/learn-ratios-and-proportions/ratios-and-proportions-extra.md b/curriculum/challenges/german/17-college-algebra-with-python/learn-ratios-and-proportions/ratios-and-proportions-extra.md
index 663f0cc63e5..c94c30816bd 100644
--- a/curriculum/challenges/german/17-college-algebra-with-python/learn-ratios-and-proportions/ratios-and-proportions-extra.md
+++ b/curriculum/challenges/german/17-college-algebra-with-python/learn-ratios-and-proportions/ratios-and-proportions-extra.md
@@ -22,7 +22,7 @@ What is another way to write 0.9999... (repeating 9)?
 
 ## --answers--
 
-99 percent
+99 Prozent
 
 ---
 
diff --git a/curriculum/challenges/italian/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md b/curriculum/challenges/italian/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
index 148ff6f8b48..974fa81942d 100644
--- a/curriculum/challenges/italian/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
+++ b/curriculum/challenges/italian/03-front-end-development-libraries/jquery/remove-an-element-using-jquery.md
@@ -10,7 +10,7 @@ dashedName: remove-an-element-using-jquery
 
 Ora rimuoviamo un elemento HTML dalla pagina usando jQuery.
 
-jQuery has a function called `.remove()` that will remove an HTML element entirely.
+jQuery ha una funzione chiamata `.remove()` che rimuove del tutto un elemento HTML.
 
 Rimuovi l'elemento `#target4` dalla pagina utilizzando la funzione `.remove()`.
 
diff --git a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-244-sliders.md b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-244-sliders.md
index 3f7759e5a46..ea6f390f5cd 100644
--- a/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-244-sliders.md
+++ b/curriculum/challenges/italian/18-project-euler/project-euler-problems-201-to-300/problem-244-sliders.md
@@ -10,29 +10,29 @@ dashedName: problem-244-sliders
 
 Probabilmente conosci il gioco Fifteen Puzzle. Qui, invece di piastrelle numerate, abbiamo sette piastrelle rosse e otto piastrelle blu.
 
-A move is denoted by the uppercase initial of the direction (Left, Right, Up, Down) in which the tile is slid, e.g. starting from configuration ($S$), by the sequence $LULUR$ we reach the configuration ($E$):
+Una mossa è indicata dall'iniziale maiuscola della direzione in inglese (L per sinistra, R per destra, U per su, D per giù) in cui la piastrella è fatta scorrere, ad esempio, partendo dalla configurazione ($S$), con la sequenza $LULUR$ raggiungiamo la configurazione ($E$):
 
-($S$) <img class="img-responsive" alt="configuration S" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-1.gif" style="display: inline-block; background-color: white; padding: 10px;" />, ($E$) <img class="img-responsive" alt="configuration E" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-2.gif" style="display: inline-block; background-color: white; padding: 10px;" />
+($S$) <img class="img-responsive" alt="configuration S" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-1.gif" style="display: inline-block; background-color: white; padding: 10px;" />, ($E$) <img class="img-responsive" alt="configurazione E" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-2.gif" style="display: inline-block; background-color: white; padding: 10px;" />
 
-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$) <img class="img-responsive center-block" alt="configuration S" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-3.gif" style="display: inline-block; background-color: white; padding: 10px;" />, ($T$) <img class="img-responsive center-block" alt="configuration T" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-4.gif" style="display: inline-block; background-color: white; padding: 10px;" />
+($S$) <img class="img-responsive center-block" alt="configuration S" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-3.gif" style="display: inline-block; background-color: white; padding: 10px;" />, ($T$) <img class="img-responsive center-block" alt="configurazione T" src="https://cdn.freecodecamp.org/curriculum/project-euler/sliders-4.gif" style="display: inline-block; background-color: white; padding: 10px;" />
 
-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 &lt; n ≤ 2 × {10}^{11}$, for which $C(n)$ is a unit fraction.
+Trova la somma di tutti i numeri interi $1 &lt; 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.
 
-<img class="img-responsive center-block" alt="animation of ellipse construction" src="https://cdn.freecodecamp.org/curriculum/project-euler/tangents-to-an-ellipse-1.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="animazione della costruzione di un'ellisse" src="https://cdn.freecodecamp.org/curriculum/project-euler/tangents-to-an-ellipse-1.gif" style="background-color: white; padding: 10px;" />
 
-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.
 
-<img class="img-responsive center-block" alt="circle c with the centre M, radius 15000, and point P outsie of ellipse e; from point P two tangents t_1 and t_2 are drawn to the ellipse, with points touching ellipse are R and S" src="https://cdn.freecodecamp.org/curriculum/project-euler/tangents-to-an-ellipse-2.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="cerchio c con centro M, raggio 15000 e un punto P al di fuori dell'ellisse e; dal punto P due tangenti t_1 e t_2 sono disegnate sull'ellisse, con i punti R e S che toccano l'ellisse" src="https://cdn.freecodecamp.org/curriculum/project-euler/tangents-to-an-ellipse-2.gif" style="background-color: white; padding: 10px;" />
 
-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$.
 
-<img class="img-responsive center-block" alt="diagram with squares under the hyperbola" src="https://cdn.freecodecamp.org/curriculum/project-euler/squares-under-a-hyperbola.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="diagramma con quadrati sotto un'iperbole" src="https://cdn.freecodecamp.org/curriculum/project-euler/squares-under-a-hyperbola.gif" style="background-color: white; padding: 10px;" />
 
-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.
 
-<img class="img-responsive center-block" alt="set of twenty points and convex holes on plane" src="https://cdn.freecodecamp.org/curriculum/project-euler/convex-holes.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="insieme di venti punti e fori convessi sul piano" src="https://cdn.freecodecamp.org/curriculum/project-euler/convex-holes.gif" style="background-color: white; padding: 10px;" />
 
-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 &lt; {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 &lt; {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:
 
-<img class="img-responsive center-block" alt="two arrangements of mats in 4x4 room" src="https://cdn.freecodecamp.org/curriculum/project-euler/tatami-free-rooms.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="due disposizioni di tatami in una stanza 4x4" src="https://cdn.freecodecamp.org/curriculum/project-euler/tatami-free-rooms.gif" style="background-color: white; padding: 10px;" />
 
-The arrangement on the left is acceptable, whereas the one on the right is not: a red "<strong><span style="color: red;">X</span></strong>" in the middle, marks the point where four tatami meet.
+La disposizione a sinistra è accettabile, mentre quello a destra non lo è: una "<strong><span style="color: red;">X</span></strong>" 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).
 
-<img class="img-responsive center-block" alt="triangle ABC, with angular bisectors intersecting sides at the points E, F and G" src="https://cdn.freecodecamp.org/curriculum/project-euler/angular-bisectors.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="triangolo ABC, con bisettrici angolari intersecanti i lati nei punti E, F e G" src="https://cdn.freecodecamp.org/curriculum/project-euler/angular-bisectors.gif" style="background-color: white; padding: 10px;" />
 
-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:
 
 <table>
   <tbody>
@@ -34,18 +34,18 @@ A(8, 1), B(1, -8), C(-4, 7)<br>
 A(2, 9), B(9, -2), C(-6, -7)<br>
 A(9, 2), B(2, -9), C(-6, 7)<br>
       </td>
-      <td><img class="img-responsive center-block" alt="nine triangles ABC with perimeter ≤ 50" src="https://cdn.freecodecamp.org/curriculum/project-euler/triangle-centres.gif" style="background-color: white; padding: 10px;"></td>
+      <td><img class="img-responsive center-block" alt="nove triangoli ABC con perimetro ≤ 50" src="https://cdn.freecodecamp.org/curriculum/project-euler/triangle-centres.gif" style="background-color: white; padding: 10px;"></td>
     </tr>
   </tbody>
 </table>
 
-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:
 
-<img class="img-responsive center-block" alt="two circular arrangements for N = 3" src="https://cdn.freecodecamp.org/curriculum/project-euler/binary-circles.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="due disposizioni circolari per N = 3" src="https://cdn.freecodecamp.org/curriculum/project-euler/binary-circles.gif" style="background-color: white; padding: 10px;" />
 
-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).
 
-<img class="img-responsive center-block" alt="ways to cut 2x2 square, counting reflections and rotations as distinct" src="https://cdn.freecodecamp.org/curriculum/project-euler/cutting-squares.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="modi di tagliare un quadrato 2x2, contando riflessioni e rotazioni come distinte" src="https://cdn.freecodecamp.org/curriculum/project-euler/cutting-squares.gif" style="background-color: white; padding: 10px;" />
 
-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 &lt; 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 &lt; 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 &lt; 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 &lt; 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 <u>not</u> 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$, <u>non</u> 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:
 
-<img class="img-responsive center-block" alt="18 balanced sculptures of order 6" src="https://cdn.freecodecamp.org/curriculum/project-euler/balanced-sculptures.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="18 sculture bilanciate di ordine 6" src="https://cdn.freecodecamp.org/curriculum/project-euler/balanced-sculptures.gif" style="background-color: white; padding: 10px;" />
 
-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 &lt; a_1 &lt; a_2 &lt; \ldots &lt; 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 &lt; a_1 &lt; a_2 &lt; \ldots &lt; 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 &lt; q &lt; r &lt; 5000$.
+Trova $\sum f(pq,pr,qr)$, dove $p$, $q$ e $r$ sono numeri primi e $p &lt; q &lt; r &lt; 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:
 
-<img class="img-responsive center-block" alt="animation with 16 ways to have 3 different toppings on 2 slices each" src="https://cdn.freecodecamp.org/curriculum/project-euler/pizza-toppings.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="animazione con 16 modi per avere 3 condimenti diversi, ciascuno su 2 pezzi" src="https://cdn.freecodecamp.org/curriculum/project-euler/pizza-toppings.gif" style="background-color: white; padding: 10px;" />
 
-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):
 
-<img class="img-responsive center-block" alt="4x4 image with colored marks denoting place where split can occur" src="https://cdn.freecodecamp.org/curriculum/project-euler/quadtree-encoding-a-simple-compression-algorithm.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Immagine 4x4 con segni colorati che indicano il luogo in cui può verificarsi la divisione" src="https://cdn.freecodecamp.org/curriculum/project-euler/quadtree-encoding-a-simple-compression-algorithm.gif" style="background-color: white; padding: 10px;" />
 
-This image can be described by several sequences, for example : "<strong><span style="color: red">0</span></strong><strong><span style="color: blue">0</span></strong>10101010<strong><span style="color: green">0</span></strong>1011111011<strong><span style="color: orange">0</span></strong>10101010", of length 30, or "<strong><span style="color: red">0</span></strong>10<strong><span style="color: green">0</span></strong>101111101110", of length 16, which is the minimal sequence for this image.
+Questa immagine può essere descritta da diverse sequenze, ad esempio: "<strong><span style="color: red">0</span></strong><strong><span style="color: blue">0</span></strong>10101010<strong><span style="color: green">0</span></strong>1011111011<strong><span style="color: orange">0</span></strong>10101010", di lunghezza 30, o "<strong><span style="color: red">0</span></strong>10<strong><span style="color: green">0</span></strong>101111101110", 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 &lt; m$, $0 ≤ y &lt; 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 &lt; m$, $0 ≤ y &lt; 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.
 
-<img class="img-responsive center-block" alt="Eulerian cycle E(3, 3) and Eulerian non-crossing path" src="https://cdn.freecodecamp.org/curriculum/project-euler/eulerian-cycles.gif" style="background-color: white; padding: 10px;" />
+<img class="img-responsive center-block" alt="Ciclo euleriano E(3, 3) e percorso euleriano senza incroci" src="https://cdn.freecodecamp.org/curriculum/project-euler/eulerian-cycles.gif" style="background-color: white; padding: 10px;" />
 
-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 &lt; {10}^{18}$ have the property that the sum of the digits of $n$ equals the sum of digits of $137n$?
+Quanti interi $0 ≤ n &lt; {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 <dfn>selection sort</dfn>. 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 <dfn>ordenação de seleção</dfn>. 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 <dfn>insertion sort</dfn>. 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 <dfn>ordenação de inserção</dfn>. 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`);