diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md index 11667f940..e9bba26f3 100644 --- a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md +++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md @@ -1,4 +1,4 @@ -The solution using a loop: +Soluția folosind un loop: ```js run function sumTo(n) { @@ -12,7 +12,7 @@ function sumTo(n) { alert( sumTo(100) ); ``` -The solution using recursion: +Soluția folosind recursivitatea: ```js run function sumTo(n) { @@ -23,7 +23,7 @@ function sumTo(n) { alert( sumTo(100) ); ``` -The solution using the formula: `sumTo(n) = n*(n+1)/2`: +Soluția folosind formula: `sumTo(n) = n*(n+1)/2`: ```js run function sumTo(n) { @@ -33,8 +33,8 @@ function sumTo(n) { alert( sumTo(100) ); ``` -P.S. Naturally, the formula is the fastest solution. It uses only 3 operations for any number `n`. The math helps! +P.S. Firește, formula este cea mai rapidă soluție. Ea folosește doar 3 operații pentru orice număr `n`. Matematica ajută! -The loop variant is the second in terms of speed. In both the recursive and the loop variant we sum the same numbers. But the recursion involves nested calls and execution stack management. That also takes resources, so it's slower. +Varianta cu bucle este a doua în ceea ce privește viteza. Atât în varianta recursivă cât și în varianta loop adunăm aceleași numere. Dar recursivitatea implică apeluri nested și gestionare de execution stack. Și asta necesită resurse, deci este mai lent. -P.P.S. Some engines support the "tail call" optimization: if a recursive call is the very last one in the function, with no other calculations performed, then the outer function will not need to resume the execution, so the engine doesn't need to remember its execution context. That removes the burden on memory. But if the JavaScript engine does not support tail call optimization (most of them don't), there will be an error: maximum stack size exceeded, because there's usually a limitation on the total stack size. +P.P.S. Unele motoare suportă optimizarea "tail call": dacă un apel recursiv este chiar ultimul din funcție, fără alte calcule efectuate, atunci funcția exterioară nu va trebui să reia execuția, astfel încât motorul nu trebuie să își amintească contextul de execuție. Asta elimină povara asupra memoriei. Dar dacă motorul JavaScript nu acceptă optimizarea tail call (majoritatea nu o fac), va apărea o eroare: maximum stack size exceeded, deoarece există de obicei o limitare a dimensiunii totale din stack. diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md index cabc13290..c9c665e45 100644 --- a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md +++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md @@ -2,11 +2,11 @@ importance: 5 --- -# Sum all numbers till the given one +# Însumați toate numerele până la cel dat -Write a function `sumTo(n)` that calculates the sum of numbers `1 + 2 + ... + n`. +Scrieți o funcție `sumTo(n)` care calculează suma numerelor `1 + 2 + ... + n`. -For instance: +De exemplu: ```js no-beautify sumTo(1) = 1 @@ -17,20 +17,20 @@ sumTo(4) = 4 + 3 + 2 + 1 = 10 sumTo(100) = 100 + 99 + ... + 2 + 1 = 5050 ``` -Make 3 solution variants: +Faceți 3 variante de soluție: -1. Using a for loop. -2. Using a recursion, cause `sumTo(n) = n + sumTo(n-1)` for `n > 1`. -3. Using the [arithmetic progression](https://en.wikipedia.org/wiki/Arithmetic_progression) formula. +1. Folosind un for loop. +2. Folosind o recursiune, cauza `sumTo(n) = n + sumTo(n-1)` pentru `n > 1`. +3. Folosind formula de [progresie aritmetică](https://en.wikipedia.org/wiki/Arithmetic_progression). -An example of the result: +Un exemplu de rezultat: ```js -function sumTo(n) { /*... your code ... */ } +function sumTo(n) { /*... codul tău ... */ } alert( sumTo(100) ); // 5050 ``` -P.S. Which solution variant is the fastest? The slowest? Why? +P.S. Care variantă de soluție este cea mai rapidă? Cea mai lentă? De ce? -P.P.S. Can we use recursion to count `sumTo(100000)`? +P.P.S. Putem folosi recursivitatea pentru a număra `sumTo(100000)`? 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 index 09e511db5..cb33bf782 100644 --- 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)!`. +Prin definiție, un factorial `n!` poate fi scris ca `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`. +Cu alte cuvinte, rezultatul `factorial(n)` poate fi calculat ca `n` înmulțit cu rezultatul lui `factorial(n-1)`. Iar apelul pentru `n-1` poate coborâ recursiv tot mai jos, tot mai jos, până la `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: +Baza recursivității este valoarea `1`. De asemenea putem face ca `0` să fie baza aici, nu contează prea mult, dar oferă încă un pas recursiv: ```js run function factorial(n) { diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md index d2aef2d90..4c8508e0c 100644 --- a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md +++ b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md @@ -2,17 +2,17 @@ importance: 4 --- -# Calculate factorial +# Calculează factorialul -The [factorial](https://en.wikipedia.org/wiki/Factorial) of a natural number is a number multiplied by `"number minus one"`, then by `"number minus two"`, and so on till `1`. The factorial of `n` is denoted as `n!` +[Factorialul](https://en.wikipedia.org/wiki/Factorial) unui număr natural este un număr înmulțit cu `"numărul minus unu"`, apoi cu `"numărul minus doi"`, și așa mai departe până la `1`. Factorialul lui `n` se notează cu `n!`. -We can write a definition of factorial like this: +Putem scrie o definiție a factorialului în felul următor: ```js n! = n * (n - 1) * (n - 2) * ...*1 ``` -Values of factorials for different `n`: +Valori ale factorialelor pentru diferite `n`: ```js 1! = 1 @@ -22,10 +22,10 @@ Values of factorials for different `n`: 5! = 5 * 4 * 3 * 2 * 1 = 120 ``` -The task is to write a function `factorial(n)` that calculates `n!` using recursive calls. +Sarcina este de a scrie o funcție `factorial(n)` care să calculeze `n!` folosind apeluri recursive. ```js alert( factorial(5) ); // 120 ``` -P.S. Hint: `n!` can be written as `n * (n-1)!` For instance: `3! = 3*2! = 3*2*1! = 6` +P.S. Indiciu: `n!` poate fi scris ca `n * (n-1)!` De exemplu: `3! = 3*2! = 3*2*1! = 6` 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 index 36524a45a..36ff11e33 100644 --- 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. +Prima soluție pe care am putea-o încerca aici este cea recursivă. -Fibonacci numbers are recursive by definition: +Numerele Fibonacci sunt recursive prin definiție: ```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! +// fib(77); // va fi extrem de lent! ``` -...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. +...Dar pentru valori mari ale lui `n` este foarte lent. De exemplu, `fib(77)` poate bloca motorul pentru o perioadă de timp, consumând toate resursele CPU. -That's because the function makes too many subcalls. The same values are re-evaluated again and again. +Asta pentru că funcția face prea multe subapelări. Aceleași valori sunt reevaluate din nou și din nou. -For instance, let's see a piece of calculations for `fib(5)`: +De exemplu, să vedem o bucată de calcule pentru `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. +Aici putem vedea că valoarea lui `fib(3)` este necesară atât pentru `fib(5)` cât și pentru `fib(4)`. Deci `fib(3)` va fi apelat și evaluat de două ori în mod complet independent. -Here's the full recursion tree: +Iată arborele de recursivitate complet: ![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`. +Putem observa în mod clar că `fib(3)` este evaluat de două ori, iar `fib(2)` este evaluat de trei ori. Suma totală a calculelor crește mult mai repede decât `n`, devenind enormă chiar și pentru `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. +Putem optimiza acest lucru prin memorarea valorilor deja evaluate: dacă o valoare de exemplu `fib(3)` este calculată o dată, atunci o putem reutiliza în calculele viitoare. -Another variant would be to give up recursion and use a totally different loop-based algorithm. +O altă variantă ar fi să renunțăm la recursivitate și să folosim un algoritm complet diferit bazat pe loop. -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. +În loc să mergem de la `n` în jos la valori mai mici, putem face un loop care pornește de la `1` și `2`, apoi obține `fib(3)` ca sumă a acestora, apoi `fib(4)` ca sumă a două valori anterioare, apoi `fib(5)` și merge în sus și în sus, până când ajunge la valoarea necesară. La fiecare pas trebuie să ne amintim doar două valori anterioare. -Here are the steps of the new algorithm in details. +Iată pașii noului algoritm în detaliu. -The start: +Începutul: ```js -// a = fib(1), b = fib(2), these values are by definition 1 +// a = fib(1), b = fib(2), aceste valori sunt prin definiție 1 let a = 1, b = 1; -// get c = fib(3) as their sum +// obțineți c = fib(3) ca sumă a acestora let c = a + b; -/* we now have fib(1), fib(2), fib(3) +/* acum avem fib(1), fib(2), fib(3) a b c 1, 1, 2 */ ``` -Now we want to get `fib(4) = fib(2) + fib(3)`. +Acum dorim să obținem `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: +Să schimbăm variabilele: `a,b` vor obține `fib(2),fib(3)`, iar `c` va obține suma lor: ```js no-beautify -a = b; // now a = fib(2) -b = c; // now b = fib(3) +a = b; // acum a = fib(2) +b = c; // acum b = fib(3) c = a + b; // c = fib(4) -/* now we have the sequence: +/* acum avem secvența: a b c 1, 1, 2, 3 */ ``` -The next step gives another sequence number: +Următorul pas oferă un alt număr de secvență: ```js no-beautify -a = b; // now a = fib(3) -b = c; // now b = fib(4) +a = b; // acum a = fib(3) +b = c; // acum b = fib(4) c = a + b; // c = fib(5) -/* now the sequence is (one more number): +/* acum secvența este (încă un număr): 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. +...Și așa mai departe până când obținem valoarea necesară. Acest lucru este mult mai rapid decât recursivitatea și nu implică calcule duplicate. -The full code: +Codul complet: ```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`. +Bucla începe cu `i=3`, deoarece prima și a doua valoare a secvenței sunt hard-coded în variabilele `a=1`, `b=1`. -The approach is called [dynamic programming bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming). +Abordarea se numește [programare dinamică de jos în sus](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 index 3cdadd219..6bead323a 100644 --- 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 +# Numere Fibonacci -The sequence of [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number) has the formula Fn = Fn-1 + Fn-2. In other words, the next number is a sum of the two preceding ones. +Secvența [numerelor Fibonacci](https://en.wikipedia.org/wiki/Fibonacci_number) are formula Fn = Fn-1 + Fn-2. Cu alte cuvinte, următorul număr este suma celor două numere precedente. -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...`. +Primele două numere sunt `1`, apoi `2(1+1)`, apoi `3(1+2)`, `5(2+3)` și așa mai departe: `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. +Numerele Fibonacci sunt legate de [Golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) și de multe fenomene naturale din jurul nostru. -Write a function `fib(n)` that returns the `n-th` Fibonacci number. +Scrieți o funcție `fib(n)` care să returneze al `n-lea` număr Fibonacci. -An example of work: +Un exemplu de lucrare: ```js -function fib(n) { /* your code */ } +function fib(n) { /* codul tău */ } } 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. +P.S. Funcția ar trebui să fie rapidă. Apelul la `fib(77)` nu ar trebui să dureze mai mult de o fracțiune de secundă. diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md index cfcbffea5..e5dd322ff 100644 --- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md +++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md @@ -1,6 +1,6 @@ -# Loop-based solution +# Soluție bazată pe loop -The loop-based variant of the solution: +Varianta soluției bazată pe loop: ```js run let list = { @@ -30,7 +30,7 @@ function printList(list) { printList(list); ``` -Please note that we use a temporary variable `tmp` to walk over the list. Technically, we could use a function parameter `list` instead: +Vă rugăm să rețineți că folosim o variabilă temporară `tmp` pentru a parcurge lista. Din punct de vedere tehnic, am putea folosi în schimb un parametru de funcție `list`: ```js function printList(list) { @@ -43,15 +43,15 @@ function printList(list) { } ``` -...But that would be unwise. In the future we may need to extend a function, do something else with the list. If we change `list`, then we lose such ability. +...Dar asta ar fi neînțelept. În viitor s-ar putea să avem nevoie să extindem o funcție, să facem altceva cu lista. Dacă schimbăm `list`, atunci pierdem o astfel de abilitate. -Talking about good variable names, `list` here is the list itself. The first element of it. And it should remain like that. That's clear and reliable. +Vorbind despre nume de variabile bune, `list` aici este lista însăși. Primul element al acesteia. Și ar trebui să rămână așa. Este clar și de încredere. -From the other side, the role of `tmp` is exclusively a list traversal, like `i` in the `for` loop. +De cealaltă parte, rolul lui `tmp` este exclusiv o traversare a listei, ca și `i` în bucla `for`. -# Recursive solution +# Soluție recursivă -The recursive variant of `printList(list)` follows a simple logic: to output a list we should output the current element `list`, then do the same for `list.next`: +Varianta recursivă a `printList(list)` urmează o logică simplă: pentru a scoate o listă trebuie să scoatem elementul curent `list`, apoi să facem același lucru pentru `list.next`: ```js run let list = { @@ -70,10 +70,10 @@ let list = { function printList(list) { - alert(list.value); // output the current item + alert(list.value); // afișează elementul curent if (list.next) { - printList(list.next); // do the same for the rest of the list + printList(list.next); // procedează la fel pentru restul listei } } @@ -81,8 +81,8 @@ function printList(list) { printList(list); ``` -Now what's better? +Acum ce este mai bine? -Technically, the loop is more effective. These two variants do the same, but the loop does not spend resources for nested function calls. +Din punct de vedere tehnic, un loop este mai eficient. Aceste două variante fac același lucru, dar loop-ul nu consumă resurse pentru apeluri de funcții nested. -From the other side, the recursive variant is shorter and sometimes easier to understand. +De partea cealaltă, varianta recursivă este mai scurtă și uneori mai ușor de înțeles. diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md index 1076b952a..a851a6c4f 100644 --- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md +++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Output a single-linked list +# Scoate un singur linked list -Let's say we have a single-linked list (as described in the chapter ): +Să presupunem că avem un singur linked list (așa cum este descris în capitolul ): ```js let list = { @@ -22,8 +22,8 @@ let list = { }; ``` -Write a function `printList(list)` that outputs list items one-by-one. +Scrieți o funcție `printList(list)` care scoate elementele din listă unul câte unul. -Make two variants of the solution: using a loop and using recursion. +Realizați două variante ale soluției: folosind un loop și folosind recursivitatea. -What's better: with recursion or without it? +Ce este mai bine: cu recursivitate sau fără ea? diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md index 0eb76ea1c..cc97f5b1d 100644 --- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md +++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md @@ -1,8 +1,8 @@ -# Using a recursion +# Folosind o recursiune -The recursive logic is a little bit tricky here. +Logica recursivă este un pic mai înșelătore aici. -We need to first output the rest of the list and *then* output the current one: +Trebuie să scoatem mai întâi restul listei și *apoi* să o scoatem pe cea curentă: ```js run let list = { @@ -31,13 +31,13 @@ function printReverseList(list) { printReverseList(list); ``` -# Using a loop +# Utilizarea unui loop -The loop variant is also a little bit more complicated than the direct output. +Varianta loop este de asemenea un pic mai complicată decât scoaterea directă. -There is no way to get the last value in our `list`. We also can't "go back". +Nu există nicio modalitate de a obține ultima valoare din `list`. De asemenea nu putem "merge înapoi". -So what we can do is to first go through the items in the direct order and remember them in an array, and then output what we remembered in the reverse order: +Așadar, ceea ce putem face este să parcurgem mai întâi elementele în ordine directă și să le reținem într-un array, iar apoi să scoatem ceea ce am reținut în ordine inversă: ```js run let list = { @@ -71,4 +71,4 @@ function printReverseList(list) { printReverseList(list); ``` -Please note that the recursive solution actually does exactly the same: it follows the list, remembers the items in the chain of nested calls (in the execution context stack), and then outputs them. +Vă rugăm să notați că soluția recursivă face de fapt exact la fel: urmărește lista, își amintește elementele din lanțul de apeluri nested (în execution context stack) și apoi le scoate. diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md index 81b1f3e33..35ebe01ae 100644 --- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md +++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md @@ -2,8 +2,8 @@ importance: 5 --- -# Output a single-linked list in the reverse order +# Scoate un singur linked list în ordine inversă -Output a single-linked list from the previous task in the reverse order. +Scoate un singur linked list din sarcina anterioară în ordine inversă. -Make two solutions: using a loop and using a recursion. +Realizați două soluții: folosind un loop și folosind o recursivitate. diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md index 5ae894474..dae5daad3 100644 --- a/1-js/06-advanced-functions/01-recursion/article.md +++ b/1-js/06-advanced-functions/01-recursion/article.md @@ -1,18 +1,18 @@ -# Recursion and stack +# Recursion și stack -Let's return to functions and study them more in-depth. +Să ne întoarcem la funcții și să le studiem mai în profunzime. -Our first topic will be *recursion*. +Primul nostru subiect va fi *recursiunea*. -If you are not new to programming, then it is probably familiar and you could skip this chapter. +Dacă nu sunteți noi în programare, atunci probabil că vă este familiar și puteți sări peste acest capitol. -Recursion is a programming pattern that is useful in situations when a task can be naturally split into several tasks of the same kind, but simpler. Or when a task can be simplified into an easy action plus a simpler variant of the same task. Or, as we'll see soon, to deal with certain data structures. +Recursiunea este un tipar de programare care este util în situațiile în care o sarcină poate fi împărțită în mod natural în mai multe sarcini de același tip, dar mai simple. Sau atunci când o sarcină poate fi simplificată într-o acțiune ușoară plus o variantă mai simplă a aceleiași sarcini. Sau, după cum vom vedea în curând, pentru a trata anumite structuri de date. -When a function solves a task, in the process it can call many other functions. A partial case of this is when a function calls *itself*. That's called *recursion*. +Atunci când o funcție îndeplinește o sarcină, în acest proces poate apela multe alte funcții. Un caz parțial este atunci când o funcție se apelează pe sine *însăși*. Acest lucru se numește *recursiune*. -## Two ways of thinking +## Două moduri de a gândi -For something simple to start with -- let's write a function `pow(x, n)` that raises `x` to a natural power of `n`. In other words, multiplies `x` by itself `n` times. +Pentru a începe cu ceva simplu -- să scriem o funcție `pow(x, n)` care ridică `x` la o putere naturală a lui `n`. Cu alte cuvinte, înmulțește `x` cu el însuși de `n` ori. ```js pow(2, 2) = 4 @@ -20,15 +20,15 @@ pow(2, 3) = 8 pow(2, 4) = 16 ``` -There are two ways to implement it. +Există două moduri de a o implementa. -1. Iterative thinking: the `for` loop: +1. Gândire iterativă: `for` loop: ```js run function pow(x, n) { let result = 1; - // multiply result by x n times in the loop + // înmulțește rezultatul cu x de n ori în loop for (let i = 0; i < n; i++) { result *= x; } @@ -39,7 +39,7 @@ There are two ways to implement it. alert( pow(2, 3) ); // 8 ``` -2. Recursive thinking: simplify the task and call self: +2. Gândire recursivă: simplificând sarcină și apelânduse pe sine: ```js run function pow(x, n) { @@ -53,9 +53,9 @@ There are two ways to implement it. alert( pow(2, 3) ); // 8 ``` -Please note how the recursive variant is fundamentally different. +Vă rugăm să observați că varianta recursivă este fundamental diferită. -When `pow(x, n)` is called, the execution splits into two branches: +Atunci când `pow(x, n)` este apelată, execuția se împarte în două ramuri: ```js if n==1 = x @@ -65,27 +65,27 @@ pow(x, n) = else = x * pow(x, n - 1) ``` -1. If `n == 1`, then everything is trivial. It is called *the base* of recursion, because it immediately produces the obvious result: `pow(x, 1)` equals `x`. -2. Otherwise, we can represent `pow(x, n)` as `x * pow(x, n - 1)`. In maths, one would write xn = x * xn-1. This is called *a recursive step*: we transform the task into a simpler action (multiplication by `x`) and a simpler call of the same task (`pow` with lower `n`). Next steps simplify it further and further until `n` reaches `1`. +1. Dacă `n == 1`, atunci totul este trivial. Se numește *baza* recursiunii, pentru că produce imediat rezultatul cel evident: `pow(x, 1)` egal cu `x`. +2. În caz contrar, putem reprezenta `pow(x, n)` ca și `x * pow(x, n - 1)`. În matematică, am putea scrie xn = x * xn-1. Acesta se numește *un pas recursiv*: transformăm sarcina într-o acțiune mai simplă (multiplicare cu `x`) și un apel mai simplu al aceleiași sarcini (`pow` cu `n` mai mic). Următorii pași o simplifică mai mult și mai mult până când `n` ajunge la `1`. -We can also say that `pow` *recursively calls itself* till `n == 1`. +Putem de asemenea spune că `pow` *se apelează recursiv pe sine* până când `n == 1`. ![recursive diagram of pow](recursion-pow.svg) -For example, to calculate `pow(2, 4)` the recursive variant does these steps: +De exemplu, pentru a calcula `pow(2, 4)`, varianta recursivă face acești pași: 1. `pow(2, 4) = 2 * pow(2, 3)` 2. `pow(2, 3) = 2 * pow(2, 2)` 3. `pow(2, 2) = 2 * pow(2, 1)` 4. `pow(2, 1) = 2` -So, the recursion reduces a function call to a simpler one, and then -- to even more simpler, and so on, until the result becomes obvious. +Așadar, recursivitatea reduce un apel de funcție la unul mai simplu, și apoi -- la unul și mai simplu, și așa mai departe, până când rezultatul devine evident. -````smart header="Recursion is usually shorter" -A recursive solution is usually shorter than an iterative one. +````smart header="Recursiunea este de obicei mai scurtă" +O soluție recursivă este de obicei mai scurtă decât una iterativă. -Here we can rewrite the same using the conditional operator `?` instead of `if` to make `pow(x, n)` more terse and still very readable: +Aici putem rescrie același lucru folosind operatorul condițional `?` în loc de `if` pentru a face `pow(x, n)` mai consic și totuși foarte ușor de citit: ```js run function pow(x, n) { @@ -94,45 +94,45 @@ function pow(x, n) { ``` ```` -The maximal number of nested calls (including the first one) is called *recursion depth*. In our case, it will be exactly `n`. +Numărul maxim de apeluri nested (inclusiv primul apel) se numește *profunzime de recursiune*. În cazul nostru, acesta va fi exact `n`. -The maximal recursion depth is limited by JavaScript engine. We can rely on it being 10000, some engines allow more, but 100000 is probably out of limit for the majority of them. There are automatic optimizations that help alleviate this ("tail calls optimizations"), but they are not yet supported everywhere and work only in simple cases. +Profunzimea maximă de recursivitate este limitată de motorul JavaScript. Ne putem baza pe faptul că este 10000, unele motoare permit mai mult, dar 100000 este probabil în afara limitei pentru majoritatea acestora. Există optimizări automate care ajută la atenuarea acestui aspect ("tail calls optimizations"), dar acestea nu sunt încă acceptate peste tot și funcționează doar în cazuri simple. -That limits the application of recursion, but it still remains very wide. There are many tasks where recursive way of thinking gives simpler code, easier to maintain. +Acest lucru limitează aplicarea recursivității, dar aceasta rămâne totuși foarte largă. Există multe sarcini în care modul recursiv de gândire oferă un cod mai simplu, mai ușor de întreținut. -## The execution context and stack +## Execution context și stack -Now let's examine how recursive calls work. For that we'll look under the hood of functions. +Acum să examinăm modul în care funcționează apelurile recursive. Pentru aceasta ne vom uita sub capota funcțiilor. -The information about the process of execution of a running function is stored in its *execution context*. +Informațiile despre procesul de execuție a unei funcții în curs de execuție sunt stocate în *execution context* al acesteia. -The [execution context](https://tc39.github.io/ecma262/#sec-execution-contexts) is an internal data structure that contains details about the execution of a function: where the control flow is now, the current variables, the value of `this` (we don't use it here) and few other internal details. +[Execution context](https://tc39.github.io/ecma262/#sec-execution-contexts) este o structură internă de date care conține detalii despre execuția unei funcții: unde se află acum fluxul de control, variabilele curente, valoarea lui `this` (nu o folosim aici) și alte câteva detalii interne. -One function call has exactly one execution context associated with it. +Un apel de funcție are asociat exact un context de execuție. -When a function makes a nested call, the following happens: +Atunci când o funcție face un apel nested, se întâmplă următoarele: -- The current function is paused. -- The execution context associated with it is remembered in a special data structure called *execution context stack*. -- The nested call executes. -- After it ends, the old execution context is retrieved from the stack, and the outer function is resumed from where it stopped. +- Funcția curentă este pusă pe pauză. +- Contextul de execuție asociat acesteia este reținut într-o structură de date specială numită *execution context stack*. +- Se execută apelul nested. +- După ce se termină, vechiul context de execuție este regăsit din stack, iar funcția exterioară este reluată de unde s-a oprit. -Let's see what happens during the `pow(2, 3)` call. +Să vedem ce se întâmplă în timpul apelului `pow(2, 3)`. ### pow(2, 3) -In the beginning of the call `pow(2, 3)` the execution context will store variables: `x = 2, n = 3`, the execution flow is at line `1` of the function. +La începutul apelului `pow(2, 3)` contextul de execuție va stoca variabilele: `x = 2, n = 3`, fluxul de execuție se află la linia `1` a funcției. -We can sketch it as: +Îl putem schița precum:
  • - Context: { x: 2, n: 3, at line 1 } + Context: { x: 2, n: 3, la linia 1 } pow(2, 3)
-That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`: +Asta este când funcția începe să se execute. Condiția `n == 1` este falsy, așa că fluxul continuă în a doua ramură a lui `if`: ```js run function pow(x, n) { @@ -149,76 +149,76 @@ alert( pow(2, 3) ); ``` -The variables are same, but the line changes, so the context is now: +Variabilele sunt aceleași, dar linia se schimbă, deci contextul este acum:
  • - Context: { x: 2, n: 3, at line 5 } + Context: { x: 2, n: 3, la linia 5 } pow(2, 3)
-To calculate `x * pow(x, n - 1)`, we need to make a subcall of `pow` with new arguments `pow(2, 2)`. +Pentru a calcula `x * pow(x, n - 1)`, trebuie să facem un subapel la `pow` cu noi argumente `pow(2, 2)`. ### pow(2, 2) -To do a nested call, JavaScript remembers the current execution context in the *execution context stack*. +Pentru a efectua un apel nested, JavaScript își amintește contextul de execuție curent în *execution context stack*. -Here we call the same function `pow`, but it absolutely doesn't matter. The process is the same for all functions: +Aici apelăm aceeași funcție `pow`, dar acest lucru nu contează absolut deloc. Procesul este același pentru toate funcțiile: -1. The current context is "remembered" on top of the stack. -2. The new context is created for the subcall. -3. When the subcall is finished -- the previous context is popped from the stack, and its execution continues. +1. Contextul curent este "reținut" deasupra stack-ului. +2. Noul context este creat pentru subapelare. +3. Când subapelul este terminat -- contextul anterior este săltat din stack, iar execuția sa continuă. -Here's the context stack when we entered the subcall `pow(2, 2)`: +Acesta este context stack când am intrat în subapelul `pow(2, 2)`:
  • - Context: { x: 2, n: 2, at line 1 } + Context: { x: 2, n: 2, la linia 1 } pow(2, 2)
  • - Context: { x: 2, n: 3, at line 5 } + Context: { x: 2, n: 3, la linia 5 } pow(2, 3)
-The new current execution context is on top (and bold), and previous remembered contexts are below. +Noul context de execuție curent este în partea de sus (cu caractere îngroșate), iar contextele memorate anterior sunt mai jos. -When we finish the subcall -- it is easy to resume the previous context, because it keeps both variables and the exact place of the code where it stopped. +Când terminăm subapelul -- este ușor să reluăm contextul anterior, deoarece acesta păstrează atât variabilele cât și locul exact al codului în care s-a oprit. ```smart -Here in the picture we use the word "line", as in our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`. +Aici în imagine folosim cuvântul "linie", deoarece în exemplul nostru există un singur subapel în linie, dar în general o singură linie de cod poate conține mai multe subapelări, cum ar fi `pow(...) + pow(...) + somethingElse(…)`. -So it would be more precise to say that the execution resumes "immediately after the subcall". +Deci ar fi mai precis să spunem că execuția se reia "imediat după subapelare". ``` ### pow(2, 1) -The process repeats: a new subcall is made at line `5`, now with arguments `x=2`, `n=1`. +Procesul se repetă: se face un nou subapel la linia `5`, acum cu argumentele `x=2`, `n=1`. -A new execution context is created, the previous one is pushed on top of the stack: +Se creează un nou context de execuție, iar cel anterior este împins în partea de sus a stack-ului:
  • - Context: { x: 2, n: 1, at line 1 } + Context: { x: 2, n: 1, la linia 1 } pow(2, 1)
  • - Context: { x: 2, n: 2, at line 5 } + Context: { x: 2, n: 2, la linia 5 } pow(2, 2)
  • - Context: { x: 2, n: 3, at line 5 } + Context: { x: 2, n: 3, la linia 5 } pow(2, 3)
-There are 2 old contexts now and 1 currently running for `pow(2, 1)`. +Acum există 2 contexte vechi și 1 în curs de desfășurare pentru `pow(2, 1)`. -### The exit +### Ieșirea -During the execution of `pow(2, 1)`, unlike before, the condition `n == 1` is truthy, so the first branch of `if` works: +În timpul execuției lui `pow(2, 1)`, spre deosebire de înainte, condiția `n == 1` este truthy, astfel încât prima ramură din `if` funcționează: ```js function pow(x, n) { @@ -232,42 +232,42 @@ function pow(x, n) { } ``` -There are no more nested calls, so the function finishes, returning `2`. +Nu mai există alte apeluri nested, așa că funcția se termină, returnând `2`. -As the function finishes, its execution context is not needed anymore, so it's removed from the memory. The previous one is restored off the top of the stack: +Deoarece funcția se termină, contextul său de execuție nu mai este necesar, așa că este șters din memorie. Cel anterior este restaurat din vârful stack-ului:
  • - Context: { x: 2, n: 2, at line 5 } + Context: { x: 2, n: 2, la linia 5 } pow(2, 2)
  • - Context: { x: 2, n: 3, at line 5 } + Context: { x: 2, n: 3, la linia 5 } pow(2, 3)
-The execution of `pow(2, 2)` is resumed. It has the result of the subcall `pow(2, 1)`, so it also can finish the evaluation of `x * pow(x, n - 1)`, returning `4`. +Se reia execuția lui `pow(2, 2)`. Ea are rezultatul subapelării `pow(2, 1)`, astfel încât poate termina evaluarea lui `x * pow(x, n - 1)`, returnând `4`. -Then the previous context is restored: +Apoi se restabilește contextul anterior:
  • - Context: { x: 2, n: 3, at line 5 } + Context: { x: 2, n: 3, la linia 5 } pow(2, 3)
-When it finishes, we have a result of `pow(2, 3) = 8`. +Când se termină, avem un rezultat `pow(2, 3) = 8`. -The recursion depth in this case was: **3**. +Adâncimea de recursivitate în acest caz a fost: **3**. -As we can see from the illustrations above, recursion depth equals the maximal number of context in the stack. +După cum putem vedea din ilustrațiile de mai sus, adâncimea de recursivitate este egală cu numărul maxim de contexte din stack. -Note the memory requirements. Contexts take memory. In our case, raising to the power of `n` actually requires the memory for `n` contexts, for all lower values of `n`. +Observați cerințele de memorie. Contextele ocupă memorie. În cazul nostru, ridicarea la puterea lui `n` necesită de fapt memorie pentru `n` contexte, pentru toate valorile mai mici ale lui `n`. -A loop-based algorithm is more memory-saving: +Un algoritm bazat pe loop este mai economic pentru memorie: ```js function pow(x, n) { @@ -281,19 +281,19 @@ function pow(x, n) { } ``` -The iterative `pow` uses a single context changing `i` and `result` in the process. Its memory requirements are small, fixed and do not depend on `n`. +Iterativul `pow` utilizează un singur context care schimbă `i` și `result` în timpul procesului. Cerințele sale de memorie sunt mici, fixe și nu depind de `n`. -**Any recursion can be rewritten as a loop. The loop variant usually can be made more effective.** +**Orice recursivitate poate fi rescrisă ca un loop. De obicei, varianta loop poate fi făcută mai eficientă.** -...But sometimes the rewrite is non-trivial, especially when a function uses different recursive subcalls depending on conditions and merges their results or when the branching is more intricate. And the optimization may be unneeded and totally not worth the efforts. +...Dar uneori rescrierea nu este trivială, în special atunci când o funcție utilizează diferite subapelări recursive în funcție de condiții și fuzionează rezultatele acestora sau când ramificarea este mai complexă. Iar optimizarea poate fi inutilă și nu merită în totalitate eforturile depuse. -Recursion can give a shorter code, easier to understand and support. Optimizations are not required in every place, mostly we need a good code, that's why it's used. +Recursivitatea poate oferi un cod mai scurt, ușor de înțeles și de susținut. Optimizările nu sunt necesare în orice loc, de cele mai multe ori avem nevoie de un cod bun, de aceea este folosit. -## Recursive traversals +## Traversări recursive -Another great application of the recursion is a recursive traversal. +O altă aplicație excelentă a recursivității este traversarea recursivă. -Imagine, we have a company. The staff structure can be presented as an object: +Imaginați-vă, că avem o companie. Structura personalului poate fi prezentată ca un obiect: ```js let company = { @@ -322,34 +322,34 @@ let company = { }; ``` -In other words, a company has departments. +Cu alte cuvinte, o companie are departamente. -- A department may have an array of staff. For instance, `sales` department has 2 employees: John and Alice. -- Or a department may split into subdepartments, like `development` has two branches: `sites` and `internals`. Each of them has their own staff. -- It is also possible that when a subdepartment grows, it divides into subsubdepartments (or teams). +- Un departament poate avea o serie de angajați. De exemplu, departamentul `sales` are 2 angajați: John și Alice. +- Sau un departament poate fi împărțit în subdepartamente, cum ar fi `development` care are două ramuri: `sites` și `internals`. Fiecare dintre ele are propriul personal. +- De asemenea este posibil ca atunci când un subdepartament se dezvoltă, să se împartă în subdepartamente (sau echipe). - For instance, the `sites` department in the future may be split into teams for `siteA` and `siteB`. And they, potentially, can split even more. That's not on the picture, just something to have in mind. + De exemplu, în viitor departamentul `sites` se poate împărți în echipe pentru `siteA` și `siteB`. Și acestea, potențial, se pot împărți și mai mult. Asta nu este pe imagine, doar ceva de avut în vedere. -Now let's say we want a function to get the sum of all salaries. How can we do that? +Acum să spunem că dorim o funcție care să obțină suma tuturor salariilor. Cum putem face acest lucru? -An iterative approach is not easy, because the structure is not simple. The first idea may be to make a `for` loop over `company` with nested subloop over 1st level departments. But then we need more nested subloops to iterate over the staff in 2nd level departments like `sites`... And then another subloop inside those for 3rd level departments that might appear in the future? If we put 3-4 nested subloops in the code to traverse a single object, it becomes rather ugly. +O abordare iterativă nu este ușoară, deoarece structura nu este simplă. Prima idee ar putea fi să facem un `for` loop pe `company` cu o subbuclă nested pe departamentele de nivelul 1. Dar apoi avem nevoie de mai multe bucle secundare nested pentru a itera peste personalul din departamentele de al doilea nivel cum ar fi `sites`... Și apoi o altă sub buclă în interiorul acestora pentru departamentele de al treilea nivel care ar putea apărea în viitor? Dacă punem 3-4 subbucle nested în cod pentru a traversa un singur obiect, devine destul de urât. -Let's try recursion. +Să încercăm recursivitatea. -As we can see, when our function gets a department to sum, there are two possible cases: +După cum putem vedea, atunci când funcția noastră primește un departament pentru a însuma, există două cazuri posibile: -1. Either it's a "simple" department with an *array* of people -- then we can sum the salaries in a simple loop. -2. Or it's *an object* with `N` subdepartments -- then we can make `N` recursive calls to get the sum for each of the subdeps and combine the results. +1. Fie este vorba de un departament "simplu" cu un *array* de persoane -- atunci putem însuma salariile într-un simplu loop. +2. Fie este *un obiect* cu `N` subdepartamente -- atunci putem face `N` apeluri recursive pentru a obține suma pentru fiecare dintre subdepartamente și combina rezultatele. -The 1st case is the base of recursion, the trivial case, when we get an array. +Primul caz este baza recursivității, cazul trivial, când obținem un array. -The 2nd case when we get an object is the recursive step. A complex task is split into subtasks for smaller departments. They may in turn split again, but sooner or later the split will finish at (1). +Al 2-lea caz, când obținem un obiect, este pasul recursiv. O sarcină complexă este împărțită în subsarcini pentru departamente mai mici. La rândul lor acestea se pot împăsți din nou, dar mai devreme sau mai târziu împărțirea se va termina la (1). -The algorithm is probably even easier to read from the code: +Algoritmul este probabil și mai ușor de citit din cod: ```js run -let company = { // the same object, compressed for brevity +let company = { // același obiect, comprimat pentru simplificare sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 1600 }], development: { sites: [{name: 'Peter', salary: 2000}, {name: 'Alex', salary: 1800 }], @@ -357,15 +357,15 @@ let company = { // the same object, compressed for brevity } }; -// The function to do the job +// Funcția care face treaba *!* function sumSalaries(department) { - if (Array.isArray(department)) { // case (1) - return department.reduce((prev, current) => prev + current.salary, 0); // sum the array - } else { // case (2) + if (Array.isArray(department)) { // cazul (1) + return department.reduce((prev, current) => prev + current.salary, 0); // însumează array-ul + } else { // cazul (2) let sum = 0; for (let subdep of Object.values(department)) { - sum += sumSalaries(subdep); // recursively call for subdepartments, sum the results + sum += sumSalaries(subdep); // apelează recursiv pentru subdepartamente, însumează rezultatele } return sum; } @@ -375,62 +375,62 @@ function sumSalaries(department) { alert(sumSalaries(company)); // 7700 ``` -The code is short and easy to understand (hopefully?). That's the power of recursion. It also works for any level of subdepartment nesting. +Codul este scurt și ușor de înțeles (sperăm?). Aceasta este puterea recursivității. Funcționează de asemenea pentru orice nivel nested a subdepartamentului. -Here's the diagram of calls: +Iată diagrama de apeluri: ![recursive salaries](recursive-salaries.svg) -We can easily see the principle: for an object `{...}` subcalls are made, while arrays `[...]` are the "leaves" of the recursion tree, they give immediate result. +Putem vedea cu ușurință principiul: pentru un obiect `{...}` se fac subapeluri, în timp ce array-urile `[...]` sunt "frunzele" din recursion tree, ele dau un rezultat imediat. -Note that the code uses smart features that we've covered before: +Observați că codul folosește caracteristici inteligente pe care le-am mai acoperit: -- Method `arr.reduce` explained in the chapter to get the sum of the array. -- Loop `for(val of Object.values(obj))` to iterate over object values: `Object.values` returns an array of them. +- Metoda `arr.reduce` explicată în capitolul pentru a obține suma array-ului. +- Bucla `for(val of Object.values(obj))` pentru a itera peste valorile obiectului: `Object.values` returnează un array al acestora. -## Recursive structures +## Structuri recursive -A recursive (recursively-defined) data structure is a structure that replicates itself in parts. +O structură de date recursivă (definită în mod recursiv) este o structură care se reproduce pe sine în părți. -We've just seen it in the example of a company structure above. +Tocmai am văzut-o în exemplul structurii unei companii de mai sus. -A company *department* is: -- Either an array of people. -- Or an object with *departments*. +Un *departament* al unei companii este: +- Fie un array de persoane. +- Ori un obiect cu *departamente*. -For web-developers there are much better-known examples: HTML and XML documents. +Pentru dezvoltatorii web există exemple mult mai bine cunoscute: Documentele HTML și XML. -In the HTML document, an *HTML-tag* may contain a list of: -- Text pieces. -- HTML-comments. -- Other *HTML-tags* (that in turn may contain text pieces/comments or other tags etc). +În documentul HTML, un *HTML-tag* poate conține o listă de: +- Bucăți de text. +- Comentarii HTML. +- Alte *tag-uri HTML* (care, la rândul lor, pot conține bucăți de text/comentarii sau alte tag-uri etc). -That's once again a recursive definition. +Aceasta este din nou o definiție recursivă. -For better understanding, we'll cover one more recursive structure named "Linked list" that might be a better alternative for arrays in some cases. +Pentru o mai bună înțelegere, vom acoperi încă o structură recursivă numită "Linked list" care ar putea fi o alternativă mai bună pentru array-uri în anumite cazuri. ### Linked list -Imagine, we want to store an ordered list of objects. +Imaginați-vă, că dorim să stocăm o listă ordonată de obiecte. -The natural choice would be an array: +Alegerea naturală ar fi un array: ```js let arr = [obj1, obj2, obj3]; ``` -...But there's a problem with arrays. The "delete element" and "insert element" operations are expensive. For instance, `arr.unshift(obj)` operation has to renumber all elements to make room for a new `obj`, and if the array is big, it takes time. Same with `arr.shift()`. +...Dar există o problemă cu array-urile. Operațiile "delete element" și "insert element" sunt costisitoare. De exemplu, operația `arr.unshift(obj)` trebuie să renumere toate elementele pentru a face loc unui nou `obj`, iar dacă array-ul este mare, durează mult. La fel cu `arr.shift()`. -The only structural modifications that do not require mass-renumbering are those that operate with the end of array: `arr.push/pop`. So an array can be quite slow for big queues, when we have to work with the beginning. +Singurele modificări structurale care nu necesită renumerotare în masă sunt cele care operează la sfârșitul array-ului: `arr.push/pop`. Deci un array poate fi destul de lent pentru cozile mari, atunci când trebuie să lucrăm cu începutul. -Alternatively, if we really need fast insertion/deletion, we can choose another data structure called a [linked list](https://en.wikipedia.org/wiki/Linked_list). +Alternativ, dacă avem cu adevărat nevoie de inserție/ștergere rapidă, putem alege o altă structură de date numită [linked list](https://en.wikipedia.org/wiki/Linked_list). -The *linked list element* is recursively defined as an object with: +*Elementul linked list* este definit recursiv ca un obiect cu: - `value`. -- `next` property referencing the next *linked list element* or `null` if that's the end. +- proprietatea `next` care face referire la următorul *element din linked list* sau `null` dacă acesta este sfârșitul. -For instance: +De exemplu: ```js let list = { @@ -448,11 +448,11 @@ let list = { }; ``` -Graphical representation of the list: +Reprezentarea grafică a listei: ![linked list](linked-list.svg) -An alternative code for creation: +Un cod alternativ pentru creare: ```js no-beautify let list = { value: 1 }; @@ -462,9 +462,9 @@ list.next.next.next = { value: 4 }; list.next.next.next.next = null; ``` -Here we can even more clearly see that there are multiple objects, each one has the `value` and `next` pointing to the neighbour. The `list` variable is the first object in the chain, so following `next` pointers from it we can reach any element. +Aici putem vedea și mai clar că există mai multe obiecte, fiecare dintre ele având `value` și `next` care indică vecinul. Variabila `list` este primul obiect din lanț, deci urmărind indicatoarele `next` de la ea putem ajunge la orice element. -The list can be easily split into multiple parts and later joined back: +Lista poate fi ușor împărțită în mai multe părți și ulterior reunită la loc: ```js let secondList = list.next.next; @@ -473,15 +473,15 @@ list.next.next = null; ![linked list split](linked-list-split.svg) -To join: +Pentru a se uni: ```js list.next.next = secondList; ``` -And surely we can insert or remove items in any place. +Și cu siguranță putem introduce sau elimina elemente în orice loc. -For instance, to prepend a new value, we need to update the head of the list: +De exemplu, pentru a o prelungi cu o valoare nouă, trebuie să actualizăm capul listei: ```js let list = { value: 1 }; @@ -490,14 +490,14 @@ list.next.next = { value: 3 }; list.next.next.next = { value: 4 }; *!* -// prepend the new value to the list +// se prelungește noua valoare la listă list = { value: "new item", next: list }; */!* ``` ![linked list](linked-list-0.svg) -To remove a value from the middle, change `next` of the previous one: +Pentru a elimina o valoare din mijloc, schimbați `next` din cea anterioară: ```js list.next = list.next.next; @@ -505,38 +505,38 @@ list.next = list.next.next; ![linked list](linked-list-remove-1.svg) -We made `list.next` jump over `1` to value `2`. The value `1` is now excluded from the chain. If it's not stored anywhere else, it will be automatically removed from the memory. +Am făcut ca `list.next` să sară peste `1` la valoarea `2`. Valoarea `1` este acum exclusă din lanț. Dacă nu este stocată în altă parte, ea va fi eliminată automat din memorie. -Unlike arrays, there's no mass-renumbering, we can easily rearrange elements. +Spre deosebire de array-uri, nu există o renumerotare în masă, putem rearanja cu ușurință elementele. -Naturally, lists are not always better than arrays. Otherwise everyone would use only lists. +Firește, listele nu sunt întotdeauna mai bune decât array-urile. Altfel toată lumea ar folosi numai liste. -The main drawback is that we can't easily access an element by its number. In an array that's easy: `arr[n]` is a direct reference. But in the list we need to start from the first item and go `next` `N` times to get the Nth element. +Principalul dezavantaj este că nu putem accesa cu ușurință un element prin numărul său. Într-un array asta este ușor: `arr[n]` este o referință directă. Dar în listă trebuie să începem de la primul element și să parcurgem `next` de `N` ori pentru a obține al N-lea element. -...But we don't always need such operations. For instance, when we need a queue or even a [deque](https://en.wikipedia.org/wiki/Double-ended_queue) -- the ordered structure that must allow very fast adding/removing elements from both ends, but access to its middle is not needed. +...Dar nu avem întotdeauna nevoie de astfel de operații. De exemplu, când avem nevoie de un queue sau chiar de un [deque](https://en.wikipedia.org/wiki/Double-ended_queue) -- structura ordonată care trebuie să permită adăugarea/eliminarea foarte rapidă a elementelor de la ambele capete, dar accesul la mijlocul ei nu este necesar. -Lists can be enhanced: -- We can add property `prev` in addition to `next` to reference the previous element, to move back easily. -- We can also add a variable named `tail` referencing the last element of the list (and update it when adding/removing elements from the end). -- ...The data structure may vary according to our needs. +Listele pot fi îmbunătățite: +- Putem adăuga proprietatea `prev` în plus față de `next` pentru a face referire la elementul anterior, pentru a ne deplasa cu ușurință înapoi. +- De asemenea putem adăuga o variabilă numită `tail` care să facă referire la ultimul element al listei (și să o actualizăm atunci când adăugăm/eliminăm elemente de la sfârșit). +- ...Structura datelor poate varia în funcție de nevoile noastre. -## Summary +## Sumar -Terms: -- *Recursion* is a programming term that means calling a function from itself. Recursive functions can be used to solve tasks in elegant ways. +Termeni: +- *Recursiune* este un termen de programare care înseamnă apelarea unei funcții din ea însăși. Funcțiile recursive pot fi utilizate pentru a rezolva sarcini în moduri elegante. - When a function calls itself, that's called a *recursion step*. The *basis* of recursion is function arguments that make the task so simple that the function does not make further calls. + Atunci când o funcție se apelează pe sine însăși, acest lucru se numește un *pas de recursivitate*. *Baza* recursivității o constituie argumentele funcției care fac sarcina atât de simplă încât funcția nu mai face apeluri ulterioare. -- A [recursively-defined](https://en.wikipedia.org/wiki/Recursive_data_type) data structure is a data structure that can be defined using itself. +- O structură de date [definită recursiv](https://en.wikipedia.org/wiki/Recursive_data_type) este o structură de date care poate fi definită folosindu-se pe ea însăși. - For instance, the linked list can be defined as a data structure consisting of an object referencing a list (or null). + De exemplu, linked list poate fi definită ca o structură de date care constă dintr-un obiect care face referire la o listă (sau null). ```js list = { value, next -> list } ``` - Trees like HTML elements tree or the department tree from this chapter are also naturally recursive: they have branches and every branch can have other branches. + Arborii cum ar fi arborele elementelor HTML sau arborele departamentelor din acest capitol sunt de asemenea recursivi în mod natural: au ramuri și fiecare ramură poate avea alte ramuri. - Recursive functions can be used to walk them as we've seen in the `sumSalary` example. + Funcțiile recursive pot fi folosite pentru a le parcurge așa cum am văzut în exemplul `sumSalary`. -Any recursive function can be rewritten into an iterative one. And that's sometimes required to optimize stuff. But for many tasks a recursive solution is fast enough and easier to write and support. +Orice funcție recursivă poate fi rescrisă într-una iterativă. Iar acest lucru este uneori necesar pentru a optimiza lucrurile. Dar pentru multe sarcini o soluție recursivă este suficient de rapidă și mai ușor de scris și de susținut. diff --git a/1-js/06-advanced-functions/01-recursion/recursion-pow.svg b/1-js/06-advanced-functions/01-recursion/recursion-pow.svg index 2b970a04a..b465b3b2d 100644 --- a/1-js/06-advanced-functions/01-recursion/recursion-pow.svg +++ b/1-js/06-advanced-functions/01-recursion/recursion-pow.svg @@ -1 +1 @@ -pow(x,n)xx * pow(x, n-1)n == 1 ?YesNorecursive call until n==1 \ No newline at end of file +pow(x,n)xx * pow(x, n-1)n == 1 ?DaNuapelează recursiv până n==1 \ No newline at end of file