
Bulgarian: 
Това е функция на JavaScript, 
която генерира
n-тото число на Фибоначи, 
като използва рекурсия
и мемоизация (запаметяване).
Сега ще я разгледаме, 
за да видим какво точно
прави компютърът зад кулисите.
На първо място функцията декларира 
тази структура от данни,
която представлява празен JavaScript обект, 
наречен „мемо".
Именно тук по-късно ще се случва мемоизацията.
След това се дефинира самата 
функция на Фибоначи (фиб функция).
Накрая фиб функцията се повиква с
начална стойност 5 (пет).
И така се оказваме във фиб функция, 
където N = 5.
Първото условие не е изпълнено (то е "невярно"), 
защото N не е 0 и не е 1.
Второто условие също не е изпълнено, 
защото 5
липсва в структурата "мемо", 
която е съвсем празна.
При което попадаме в третото условие.
Но всъщност това не е условие, нали?
Функцията влиза в този else цикъл 
и иска да сметне

English: 
- [Instructor] This is a
JavaScript function that generates
the nth fibonacci number using recursion
as well as memoization.
So we're gonna go through
it and see what the computer
actually does behind the scenes.
So the first thing it does is
declare this data structure
which is an empty JavaScript
object called memo
and that's where the memoization
is going to happen later.
Then it defines the fib function.
And finally it calls the fib
function with the input value
of five, so the first thing
that happens is that we're
in fib function with N of five.
This first condition is false
'cause N is not zero and it's
not one, the second condition
is false because five
is not in the memo data
structure which is completely
empty and this third condition
is where we're gonna go into.
Well it's not really a condition is it?
So we go into this else block
and it wants to calculate

Bulgarian: 
колко е Фибоначи (5), 
като извиква N и смята
fib за (n - 1) и fib за (n - 2).
Следователно първо извиква fib = (n - 1),
а именно fib = 4.
Веднага вика четворката
и вече сме във фиб функция, 
където N = 4.
Понеже първото и второто условие 
не са изпълнени,
сега иска да намери колко е 
fib 3 плюс fib 2.
Затова първо извиква fib 3 
и имаме fib за fib = 3.
Тези двете не са изпълнени
и сега ще изчислим fib 3 
като fib 2 + fib 1.
Веднага повиква fib 2 
и сега сме във фиб функция, където N = 2,
тези две условия не са изпълнени, 
затова ще изчисли
fib 2 = fib 1 +  fib 0.
Веднага след това повиква fib 1 и най-после 
това е изпълнено,
затова ще ни върне N, което отново е 1.

English: 
what fibonacci five is by
calling fib of N minus one
plus fib of N minus two.
So what it first does is call
fib of N minus one so that's
gonna be fib of four so it
immediately calls that and now
we're in the fib function
with N equals four.
This is false, this is
false, so we're here again
and this time it wants to
calculate the result of fib three
plus fib two.
So it first calls fib three
and we're in fib for fib equals
three, this is false, this
is false, and now we're gonna
calculate fib three as
being fib two plus fib one.
It immediately calls fib two
so we're in fib for N equals
two this is false, this is
false, and it's gonna calculate
fib two as being fib one plus fib zero.
So it immediately calls fib one
and now finally this is true
so it's gonna return N which is one again.

English: 
And it'll end up going back
to the fib function when N
was two because now it's
got the result of that first
fib call.
So now it needs to call fib
zero and get that result.
So we're in fib for N equals
zero, now that first condition
is true again so it's going
to return N which is zero
and come back to when fib
was two, when N was two
and now it has a result, so
now it can update the memo
object with the result for N
of two and we can see indeed
that the object updates over there.
And then it returns
the result for fib two.
All right so now we're back
up to fib three and fib three
we've called fib two so now
it wants to call fib one.
So we're back in when N
equals one, it once again
returns one and now it knows
what fib three is it's got

Bulgarian: 
Сега ще се върне на фиб функцията с N = 2,
защото това вече има резултата 
от първото повикване на fib.
Сега трябва да повика fib 0 
и да получи този резултат.
Така имаме фиб функция, където N = 0,
сега първото условие отново е изпълнено 
и ще върне N, което е 0.
После ще се върне там, 
където N беше 2.
Сега има резултат, 
затова може да актуализира мемото
с резултата за N = 2.
И наистина обектът е актуализиран – ето тук.
После връща резултата за fib 2.
Добре, сега сме обратно на fib 3,
но вече сме викали fib 2, 
затова ще повика fib 1.
Ето ни обратно на N = 1, връща ни
още веднъж 1 и сега знае кое е fib 3.

English: 
a result of two, it can update
the memo structure with that
result and return it.
So now we're back in when
N was four and it already
calculated fib three, so
now it needs to call fib two
and this time when it calls
fib two and N equals two,
it finds that N is indeed
in the memo data structure
so it can return the value
for N equals two from that
structure so it's going
to get that result of one
and it doesn't have to do
the recursive calculation.
So now we're back with N equals
four and now we know what
fib four is it's three, we can
update the memo and return.
Now finally we're back up
to when N is five in the fib
function it's called fib four
and then it just needs to call
fib three, so we see it's
false but then here three

Bulgarian: 
Това е полученият резултат 2. 
Вече може да актуализира мемото
с този резултат и да го върне.
Сега сме обратно в случая, когато N = 4,
но вече fib 3 е изчислено 
и трябва да повика fib 2.
Този път вика fib 2 и при N = 2 открива,
че N наистина е в мемото,
затова може да върне стойността
за N = 2 от това мемо,
ще получи резултат 1,
и повече не трябва да прави 
рекурсивното изчисление.
Сега се връщаме в случая, когато N = 4. 
Вече знаем колко е fib 4,
а именно 3, затова можем да актуализираме 
мемото и да върнем тази стойност.
Накрая се връщаме във фиб функцията 
за N = 5.
fib 4 вече е викано, затова трябва 
просто да повика fib 3.
Виждаме, че това не изпълнено, но тук

Bulgarian: 
3 е в мемото, затова може да върне 
стойността от мемото, която е 2,
и да дойде обратно тук.
Сега знае, че fib от 5 е 5, 
затова може да актуализира
мемото с този резултат и да го върне.
Ух, най-после цялата рекурсивна 
мемоизирана функция е изпълнена.

English: 
is in the memo structure
so it can return the value
in the memo structure which
is two and go back up here.
Now it knows that fib of five
is five and it can update
the memo structure with
that result and return it.
Whew and now the whole memoized
recursive function is done.
