diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
@@ -1,6 +1,6 @@
-By definition, a factorial `n!` can be written as `n * (n-1)!`.

-In other words, the result of `factorial(n)` can be calculated as `n` multiplied by the result of `factorial(n-1)`. And the call for `n-1` can recursively descend lower, and lower, till `1`.

```js run
function factorial(n) {
@@ -10,7 +10,7 @@ function factorial(n) {
alert( factorial(5) ); // 120
```

-The basis of recursion is the value `1`. We can also make `0` the basis here, doesn't matter much, but gives one more recursive step:

```js run
function factorial(n) {

diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
@@ -1,6 +1,6 @@
-The first solution we could try here is the recursive one.

-Fibonacci numbers are recursive by definition:

```js run
function fib(n) {
@@ -9,14 +9,14 @@ function fib(n) {

alert( fib(3) ); // 2
alert( fib(7) ); // 13
-// fib(77); // will be extremely slow!
```

-...But for big values of `n` it's very slow. For instance, `fib(77)` may hang up the engine for some time eating all CPU resources.

-That's because the function makes too many subcalls. The same values are re-evaluated again and again.

-For instance, let's see a piece of calculations for `fib(5)`:

```js no-beautify
...
@@ -25,68 +25,68 @@ fib(4) = fib(3) + fib(2)
...
```

-Here we can see that the value of `fib(3)` is needed for both `fib(5)` and `fib(4)`. So `fib(3)` will be called and evaluated two times completely independently.

-Here's the full recursion tree:

![fibonacci recursion tree](fibonacci-recursion-tree.svg)

-We can clearly notice that `fib(3)` is evaluated two times and `fib(2)` is evaluated three times. The total amount of computations grows much faster than `n`, making it enormous even for `n=77`.

-We can optimize that by remembering already-evaluated values: if a value of say `fib(3)` is calculated once, then we can just reuse it in future computations.

-Another variant would be to give up recursion and use a totally different loop-based algorithm.

-Instead of going from `n` down to lower values, we can make a loop that starts from `1` and `2`, then gets `fib(3)` as their sum, then `fib(4)` as the sum of two previous values, then `fib(5)` and goes up and up, till it gets to the needed value. On each step we only need to remember two previous values.

-Here are the steps of the new algorithm in details.

-The start:

```js
-// a = fib(1), b = fib(2), these values are by definition 1
let a = 1, b = 1;

-// get c = fib(3) as their sum
let c = a + b;

-/* we now have fib(1), fib(2), fib(3)
a  b  c
1, 1, 2
*/
```

-Now we want to get `fib(4) = fib(2) + fib(3)`.

-Let's shift the variables: `a,b` will get `fib(2),fib(3)`, and `c` will get their sum:

```js no-beautify
a = b; // now a = fib(2)
b = c; // now b = fib(3)
c = a + b; // c = fib(4)

-/* now we have the sequence:
   a  b  c
1, 1, 2, 3
*/
```

-The next step gives another sequence number:

```js no-beautify
a = b; // now a = fib(3)
b = c; // now b = fib(4)
c = a + b; // c = fib(5)

-/* now the sequence is (one more number):
      a  b  c
1, 1, 2, 3, 5
*/
```

-...And so on until we get the needed value. That's much faster than recursion and involves no duplicate computations.

-The full code:

```js run
function fib(n) {
@@ -105,6 +105,6 @@ alert( fib(7) ); // 13
alert( fib(77) ); // 5527939700884757
```

-The loop starts with `i=3`, because the first and the second sequence values are hard-coded into variables `a=1`, `b=1`.

-The approach is called [dynamic programming bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming).
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
@@ -2,24 +2,24 @@ importance: 5

---

-# Fibonacci numbers

-The sequence of [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number) has the formula <code>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub></code>. In other words, the next number is a sum of the two preceding ones.

-First two numbers are `1`, then `2(1+1)`, then `3(1+2)`, `5(2+3)` and so on: `1, 1, 2, 3, 5, 8, 13, 21...`.

-Fibonacci numbers are related to the [Golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) and many natural phenomena around us.

-Write a function `fib(n)` that returns the `n-th` Fibonacci number.

-An example of work:

```js
-function fib(n) { /* your code */ }

alert(fib(3)); // 2
alert(fib(7)); // 13
alert(fib(77)); // 5527939700884757
```

-P.S. The function should be fast. The call to `fib(77)` should take no more than a fraction of a second.