diff --git a/curriculum/challenges/english/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md b/curriculum/challenges/english/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
index 7c0ecc19d0..065f0b748d 100644
--- a/curriculum/challenges/english/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
+++ b/curriculum/challenges/english/10-coding-interview-prep/project-euler/problem-92-square-digit-chains.md
@@ -12,27 +12,45 @@ A number chain is created by continuously adding the square of the digits in a n
 
 For example,
 
-<div style='margin-left: 4em;'>
-  44 → 32 → 13 → 10 → <strong>1</strong> → <strong>1</strong><br>
-  85 → <strong>89</strong> → 145 → 42 → 20 → 4 → 16 → 37 → 58 → <strong>89</strong>
-</div>
+$$\begin{align}
+  & 44 → 32 → 13 → 10 → \boldsymbol{1} → \boldsymbol{1}\\\\
+  & 85 → \boldsymbol{89} → 145 → 42 → 20 → 4 → 16 → 37 → 58 → \boldsymbol{89}\\\\
+\end{align}$$
 
 Therefore any chain that arrives at 1 or 89 will become stuck in an endless loop. What is most amazing is that EVERY starting number will eventually arrive at 1 or 89.
 
-How many starting numbers below ten million will arrive at 89?
+How many starting numbers below `limit` will arrive at 89?
 
 # --hints--
 
-`squareDigitChains()` should return a number.
+`squareDigitChains(100)` should return a number.
 
 ```js
-assert(typeof squareDigitChains() === 'number');
+assert(typeof squareDigitChains(100) === 'number');
 ```
 
-`squareDigitChains()` should return 8581146.
+`squareDigitChains(100)` should return `80`.
 
 ```js
-assert.strictEqual(squareDigitChains(), 8581146);
+assert.strictEqual(squareDigitChains(100), 80);
+```
+
+`squareDigitChains(1000)` should return `857`.
+
+```js
+assert.strictEqual(squareDigitChains(1000), 857);
+```
+
+`squareDigitChains(100000)` should return `85623`.
+
+```js
+assert.strictEqual(squareDigitChains(100000), 85623);
+```
+
+`squareDigitChains(10000000)` should return `8581146`.
+
+```js
+assert.strictEqual(squareDigitChains(10000000), 8581146);
 ```
 
 # --seed--
@@ -40,16 +58,98 @@ assert.strictEqual(squareDigitChains(), 8581146);
 ## --seed-contents--
 
 ```js
-function squareDigitChains() {
+function squareDigitChains(limit) {
 
   return true;
 }
 
-squareDigitChains();
+squareDigitChains(100);
 ```
 
 # --solutions--
 
 ```js
-// solution required
+function squareDigitChains(limit) {
+  // Based on https://www.xarg.org/puzzle/project-euler/problem-92/
+  function getCombinations(neededDigits, curDigits) {
+    if (neededDigits === curDigits.length) {
+      return [curDigits];
+    }
+    const combinations = [];
+    const lastDigit = curDigits.length !== 0 ? curDigits[0] : 9;
+    for (let i = 0; i <= lastDigit; i++) {
+      const results = getCombinations(neededDigits, [i].concat(curDigits));
+      combinations.push(...results);
+    }
+    return combinations;
+  }
+
+  function getPossibleSums(limit) {
+    const digitsCount = getDigits(limit).length - 1;
+    const possibleSquaredSums = [false];
+    for (let i = 1; i <= 81 * digitsCount; i++) {
+      let curVal = i;
+      while (curVal !== 1 && curVal !== 89) {
+        curVal = addSquaredDigits(curVal);
+      }
+      possibleSquaredSums[i] = curVal === 89;
+    }
+    return possibleSquaredSums;
+  }
+
+  function addSquaredDigits(num) {
+    const digits = getDigits(num);
+    let result = 0;
+    for (let i = 0; i < digits.length; i++) {
+      result += digits[i] ** 2;
+    }
+    return result;
+  }
+
+  function getDigits(number) {
+    const digits = [];
+    while (number > 0) {
+      digits.push(number % 10);
+      number = Math.floor(number / 10);
+    }
+    return digits;
+  }
+
+  function getFactorials(number) {
+    const factorials = [1];
+    for (let i = 1; i < number; i++) {
+      factorials[i] = factorials[i - 1] * i;
+    }
+    return factorials;
+  }
+
+  const neededDigits = getDigits(limit).length - 1;
+  const combinations = getCombinations(neededDigits, []);
+  const possibleSquaredDigitsSums = getPossibleSums(limit);
+  const factorials = getFactorials(neededDigits + 1);
+
+  let endingWith89 = 0;
+
+  for (let i = 0; i < combinations.length; i++) {
+    let counts = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let digits = combinations[i];
+    let curSum = 0;
+    for (let j = 0; j < digits.length; j++) {
+      const curDigit = digits[j];
+      curSum += curDigit ** 2;
+      counts[curDigit]++;
+    }
+
+    if (possibleSquaredDigitsSums[curSum]) {
+      let denominator = 1;
+      for (let j = 0; j < counts.length; j++) {
+        denominator = denominator * factorials[counts[j]];
+      }
+      endingWith89 += Math.floor(
+        factorials[factorials.length - 1] / denominator
+      );
+    }
+  }
+  return endingWith89;
+}
 ```