fix(curriculum): rework Project Euler 69 (#41974)

* fix: rework challenge to use argument in function

* fix: use mathjax for consistent phi letter

* fix: add solution

* fix: re-align table formatting

curriculum/challenges/english/10-coding-interview-prep/project-euler/problem-69-totient-maximum.md

@@ -8,40 +8,58 @@ dashedName: problem-69-totient-maximum
 
 # --description--
 
-Euler's Totient function, φ(`n`) \[sometimes called the phi function], is used to determine the number of numbers less than `n` which are relatively prime to `n`. For example, as 1, 2, 4, 5, 7, and 8, are all less than nine and relatively prime to nine, φ(9)=6.
+Euler's Totient function, ${\phi}(n)$ (sometimes called the phi function), is used to determine the number of numbers less than `n` which are relatively prime to `n`. For example, as 1, 2, 4, 5, 7, and 8, are all less than nine and relatively prime to nine, ${\phi}(9) = 6$.
 
 <div style='margin-left: 4em;'>
 
-| <var>n</var> | Relatively Prime | φ(<var>n</var>) | <var>n</var>/φ(<var>n</var>) |
+| $n$ | $\text{Relatively Prime}$ | $\displaystyle{\phi}(n)$ | $\displaystyle\frac{n}{{\phi}(n)}$ |
-| ------------ | ---------------- | --------------- | ---------------------------- |
+| --- | ------------------------- | ------------------------ | ---------------------------------- |
-| 2            | 1                | 1               | 2                            |
+| 2   | 1                         | 1                        | 2                                  |
-| 3            | 1,2              | 2               | 1.5                          |
+| 3   | 1,2                       | 2                        | 1.5                                |
-| 4            | 1,3              | 2               | 2                            |
+| 4   | 1,3                       | 2                        | 2                                  |
-| 5            | 1,2,3,4          | 4               | 1.25                         |
+| 5   | 1,2,3,4                   | 4                        | 1.25                               |
-| 6            | 1,5              | 2               | 3                            |
+| 6   | 1,5                       | 2                        | 3                                  |
-| 7            | 1,2,3,4,5,6      | 6               | 1.1666...                    |
+| 7   | 1,2,3,4,5,6               | 6                        | 1.1666...                          |
-| 8            | 1,3,5,7          | 4               | 2                            |
+| 8   | 1,3,5,7                   | 4                        | 2                                  |
-| 9            | 1,2,4,5,7,8      | 6               | 1.5                          |
+| 9   | 1,2,4,5,7,8               | 6                        | 1.5                                |
-| 10           | 1,3,7,9          | 4               | 2.5                          |
+| 10  | 1,3,7,9                   | 4                        | 2.5                                |
 
 </div>
 
-It can be seen that `n`=6 produces a maximum `n`/φ(`n`) for `n` ≤ 10.
+It can be seen that `n` = 6 produces a maximum $\displaystyle\frac{n}{{\phi}(n)}$ for `n` ≤ 10.
 
-Find the value of `n` ≤ 1,000,000 for which n/φ(`n`) is a maximum.
+Find the value of `n` ≤ `limit` for which $\displaystyle\frac{n}{{\phi(n)}}$ is a maximum.
 
 # --hints--
 
-`totientMaximum()` should return a number.
+`totientMaximum(10)` should return a number.
 
 ```js
-assert(typeof totientMaximum() === 'number');
+assert(typeof totientMaximum(10) === 'number');
 ```
 
-`totientMaximum()` should return 510510.
+`totientMaximum(10)` should return `6`.
 
 ```js
-assert.strictEqual(totientMaximum(), 510510);
+assert.strictEqual(totientMaximum(10), 6);
+```
+
+`totientMaximum(10000)` should return `2310`.
+
+```js
+assert.strictEqual(totientMaximum(10000), 2310);
+```
+
+`totientMaximum(500000)` should return `30030`.
+
+```js
+assert.strictEqual(totientMaximum(500000), 30030);
+```
+
+`totientMaximum(1000000)` should return `510510`.
+
+```js
+assert.strictEqual(totientMaximum(1000000), 510510);
 ```
 
 # --seed--
@@ -49,16 +67,44 @@ assert.strictEqual(totientMaximum(), 510510);
 ## --seed-contents--
 
 ```js
-function totientMaximum() {
+function totientMaximum(limit) {
 
   return true;
 }
 
-totientMaximum();
+totientMaximum(10);
 ```
 
 # --solutions--
 
 ```js
-// solution required
+function totientMaximum(limit) {
+  function getSievePrimes(max) {
+    const primesMap = new Array(max).fill(true);
+    primesMap[0] = false;
+    primesMap[1] = false;
+    const primes = [];
+    for (let i = 2; i < max; i = i + 2) {
+      if (primesMap[i]) {
+        primes.push(i);
+        for (let j = i * i; j < max; j = j + i) {
+          primesMap[j] = false;
+        }
+      }
+      if (i === 2) {
+        i = 1;
+      }
+    }
+    return primes;
+  }
+
+  const MAX_PRIME = 50;
+  const primes = getSievePrimes(MAX_PRIME);
+  let result = 1;
+
+  for (let i = 0; result * primes[i] < limit; i++) {
+    result *= primes[i];
+  }
+  return result;
+}
 ```