You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
The first solution we could try here is the recursive one.
1
+
Спершу ми можемо спробувати рекурсію.
2
2
3
-
Fibonacci numbers are recursive by definition:
3
+
Числа Фібоначчі є рекурсивними за визначенням:
4
4
5
5
```js run
6
6
functionfib(n) {
@@ -9,14 +9,14 @@ function fib(n) {
9
9
10
10
alert( fib(3) ); // 2
11
11
alert( fib(7) ); // 13
12
-
// fib(77); // will be extremely slow!
12
+
// fib(77); // екстремально повільно!
13
13
```
14
14
15
-
...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.
15
+
...Але для великих значень `n`це дуже повільно. Наприклад, `fib(77)`може заморозити роботу рушія на деякий час, споживаючи всі ресурси центрального процесора.
16
16
17
-
That's because the function makes too many subcalls. The same values are re-evaluated again and again.
17
+
При цьому, що функція продовжує широке дерево вкладених викликів. Тей самий ряд значень обчислюється знову і знову.
18
18
19
-
For instance, let's see a piece of calculations for`fib(5)`:
19
+
Наприклад, подивимось на уривок обчислень`fib(5)`:
20
20
21
21
```js no-beautify
22
22
...
@@ -25,68 +25,68 @@ fib(4) = fib(3) + fib(2)
25
25
...
26
26
```
27
27
28
-
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.
28
+
Тут ми спостерігаємо що значення `fib(3)`потрібне для обох `fib(5)`та`fib(4)`. Тож`fib(3)`буде викликано два рази абсолютно незалежно.
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`.
34
+
Ми можемо чітко простежити, що`fib(3)`вираховується двічі, а `fib(2)`-- тричі. Загальна кількість обчислень росте набагато швидше, ніж `n`, що робить його величезним навіть для`n=77`.
35
35
36
-
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.
36
+
Ми можемо оптимізувати це, запам’ятовуючи вже обчислені результати: якщо значення, скажімо, `fib(3)`обчислюється один раз, ми можемо просто повторно використовувати його в майбутніх обчисленнях.
37
37
38
-
Another variant would be to give up recursion and use a totally different loop-based algorithm.
38
+
Як інший варіант, ми можемо відмовитись від рекурсії та використати зовсім інший алгоритм на основі циклу.
39
39
40
-
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.
40
+
Замість переходу від `n`до нижчих значень ми можемо створити цикл, який починається з `1`і`2`, потім отримує`fib(3)`як їхню суму, а потім `fib(4)`як суму двох попередніх значень, потім`fib(5)`і йде вгору і вгору, поки не досягне потрібного значення. На кожному кроці нам потрібно лише запам’ятати два попередні значення.
41
41
42
-
Here are the steps of the new algorithm in details.
42
+
Ось кроки нового алгоритму в деталях.
43
43
44
-
The start:
44
+
Початок:
45
45
46
46
```js
47
-
// a = fib(1), b = fib(2), these values are by definition 1
47
+
// a = fib(1), b = fib(2), ці значення типово дорівнюють одиниці
48
48
let a =1, b =1;
49
49
50
-
// get c = fib(3) as their sum
50
+
// get c = fib(3) як їх сума
51
51
let c = a + b;
52
52
53
-
/*we now have fib(1), fib(2), fib(3)
53
+
/*тепер ми маємо fib(1), fib(2), fib(3)
54
54
a b c
55
55
1, 1, 2
56
56
*/
57
57
```
58
58
59
-
Now we want to get`fib(4) = fib(2) + fib(3)`.
59
+
Тепер ми хочемо отримати`fib(4) = fib(2) + fib(3)`.
60
60
61
-
Let's shift the variables: `a,b`will get`fib(2),fib(3)`, and`c`will get their sum:
61
+
Зсуньмо змінні: `a,b`і отримаємо`fib(2),fib(3)` та`c`отримає їх суму:
62
62
63
63
```js no-beautify
64
-
a = b; //now a = fib(2)
65
-
b = c; //now b = fib(3)
64
+
a = b; //тепер a = fib(2)
65
+
b = c; //тепер b = fib(3)
66
66
c = a + b; // c = fib(4)
67
67
68
-
/*now we have the sequence:
68
+
/*тепер ми маємо таку послідовність:
69
69
a b c
70
70
1, 1, 2, 3
71
71
*/
72
72
```
73
73
74
-
The next step gives another sequence number:
74
+
Наступний крок дає нове число послідовності:
75
75
76
76
```js no-beautify
77
-
a = b; //now a = fib(3)
78
-
b = c; //now b = fib(4)
77
+
a = b; //тепер a = fib(3)
78
+
b = c; //тепер b = fib(4)
79
79
c = a + b; // c = fib(5)
80
80
81
-
/*now the sequence is (one more number):
81
+
/*тепер послідовність така (на одне число більше):
82
82
a b c
83
83
1, 1, 2, 3, 5
84
84
*/
85
85
```
86
86
87
-
...And so on until we get the needed value. That's much faster than recursion and involves no duplicate computations.
87
+
...І так далі, поки не отримаємо потрібне значення. Це набагато швидше, ніж рекурсія, і не вимагає повторних обчислень.
88
88
89
-
The full code:
89
+
Повний код:
90
90
91
91
```js run
92
92
functionfib(n) {
@@ -105,6 +105,6 @@ alert( fib(7) ); // 13
105
105
alert( fib(77) ); // 5527939700884757
106
106
```
107
107
108
-
The loop starts with `i=3`, because the first and the second sequence values are hard-coded into variables`a=1`, `b=1`.
108
+
Цикл починається з `i=3`, тому що перше та друге значення послідовності жорстко закодовані в змінних`a=1`, `b=1`.
109
109
110
-
The approach is called [dynamic programming bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming).
110
+
Підхід називається [динамічне програмування знизу вгору](https://uk.wikipedia.org/wiki/Динамічне_програмування).
Copy file name to clipboardExpand all lines: 1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
+8-8Lines changed: 8 additions & 8 deletions
Original file line number
Diff line number
Diff line change
@@ -2,24 +2,24 @@ importance: 5
2
2
3
3
---
4
4
5
-
# Fibonacci numbers
5
+
# Числа Фібоначчі
6
6
7
-
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.
7
+
Послідовність [чисел Фібоначчі](https://uk.wikipedia.org/wiki/Послідовність_Фібоначчі) має формулу <code>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub></code>. Іншими словами, наступне число є сумою двох попередніх.
8
8
9
-
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...`.
9
+
Перші два числа: `1`, потім`2(1+1)`, потім`3(1+2)`, `5(2+3)`і так далі: `1, 1, 2, 3, 5, 8, 13, 21...`.
10
10
11
-
Fibonacci numbers are related to the [Golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) and many natural phenomena around us.
11
+
Числа Фібоначчі пов’язані із [золотим перетином](https://uk.wikipedia.org/wiki/Золотий_перетин) і багатьма природними явищами навколо нас.
12
12
13
-
Write a function `fib(n)` that returns the `n-th`Fibonacci number.
13
+
Напишіть функцію `fib(n)`, яка повертає `n-th`число Фібоначчі.
14
14
15
-
An example of work:
15
+
Приклад:
16
16
17
17
```js
18
-
functionfib(n) { /*your code*/ }
18
+
functionfib(n) { /*твій код*/ }
19
19
20
20
alert(fib(3)); // 2
21
21
alert(fib(7)); // 13
22
22
alert(fib(77)); // 5527939700884757
23
23
```
24
24
25
-
P.S. The function should be fast. The call to `fib(77)`should take no more than a fraction of a second.
25
+
P.S. Функція повинна бути швидкою. Виклик `fib(77)`має тривати не більше частки секунди.
Copy file name to clipboardExpand all lines: 1-js/06-advanced-functions/01-recursion/article.md
+6-6Lines changed: 6 additions & 6 deletions
Original file line number
Diff line number
Diff line change
@@ -66,9 +66,9 @@ pow(x, n) =
66
66
```
67
67
68
68
1. Якщо `n == 1`, то все тривіально. Це називається *база* рекурсії, оскільки вона негайно виробляє очевидний результат:`pow(x, 1)` дорівнює `x`.
69
-
2. Інакше ми можемо представляти `pow(x, n)` як `x * pow(x, n)`. У математиці можна написати <code>x<sup>n</sup>= x * x<sup>n-1</sup></code>. Це називається *рекурсивний крок*: ми перетворюємо завдання на простішу дію (множення за допомогою `x`) та на простий виклик того ж завдання (`pow` з меньшим`n`). Наступні кроки спрощують його далі і далі до `n`, що дорівнює `1`.
69
+
2. Інакше ми можемо представляти `pow(x, n)` як `x * pow(x, n)`. У математиці можна написати <code>x<sup>n</sup>= x * x<sup>n-1</sup></code>. Це називається *рекурсивний крок*: ми перетворюємо завдання на простішу дію (множення за допомогою `x`) та на простий виклик того ж завдання (`pow` з меншим`n`). Наступні кроки спрощують його далі і далі до `n`, що дорівнює `1`.
70
70
71
-
Ми також можемо сказати, що `pow`*рекурсивно викликаэ себе* до`n == 1`.
71
+
Ми також можемо сказати, що `pow`*рекурсивно викликає себе* до`n == 1`.
72
72
73
73
74
74
@@ -117,11 +117,11 @@ function pow(x, n) {
117
117
- Вкладений виклик виконується.
118
118
- Після закінчення, старий контекст виконання витягується з стека, і зовнішня функція відновлюється з того місця, де вона зупинилася.
119
119
120
-
Давайте подивимося, що відбувається під час виклика`pow(2, 3)`.
120
+
Давайте подивимося, що відбувається під час виклику`pow(2, 3)`.
121
121
122
122
### pow(2, 3)
123
123
124
-
На початку виклика`pow(2, 3)` контекст виконання буде зберігати змінні:`x = 2, n = 3`, потік виконання знаходиться на рядку `1` функції.
124
+
На початку виклику`pow(2, 3)` контекст виконання буде зберігати змінні:`x = 2, n = 3`, потік виконання знаходиться на рядку `1` функції.
0 commit comments