Merge pull request #76 from Adham-Niazy/master

Recursion and Stack

Author: OmarioHassan

1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md

@@ -1,4 +1,4 @@
-The solution using a loop:
+الحل بإستخدام الحلقة: 
 
 ```js run
 function sumTo(n) {
@@ -12,7 +12,7 @@ function sumTo(n) {
 alert( sumTo(100) );
 ```
 
-The solution using recursion:
+الحل بإستخدام التكرار: 
 
 ```js run
 function sumTo(n) {
@@ -22,8 +22,8 @@ function sumTo(n) {
 
 alert( sumTo(100) );
 ```
+الحل بإستخدام هذه المعادلة: `sumTo(n) = n*(n+1)/2`:
 
-The solution using the 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!
+1. منطقياً حل المعادلة هو أسرع حل لأننا نستخدم ثلاث عمليات فقط لأي رقم `n`.‘إذا الرياضة تساعد
 
-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.
+الدالة المتكررة تأتي في المرتبة الاخيرة في السرعة ببساطة لأنها نفذت الكثير من النداءات و ذلك تطلب الكثير من سياقات التنفيذ و كومة سياقات التنفيذ لذلك فإنها الأبطأ
 
-P.P.S. Some engines support the "tail call" optimization: if a recursive call is the very last one in the function (like in `sumTo` above), 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, so counting `sumTo(100000)` becomes possible. 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.
+2. يعض المحركات تدعم تحسين "tail call": أذا كان النداء المتكرر هو الأخير في الدالة (مثلما في`sumTo` ) إذا فالدالة الخارجية لن تحتاج إلي مواصلة التنفيذ وبالتالي فإن المحرك لا يحتاج إلي تذكر سياق التنفيذ. ذلك يزبل العبء عن الذاكرة لذلك العد إلي `sumTo(100000)` ممكناً. لكن محرك جافاسكريبت لا يدعم هذا التحسين أو المعظم لا يدعم, لذلك سيكون هناك خطأ: لقد تخطيت الحجم الأقصي لكومة سياق التنفيذ.

1-js/06-advanced-functions/01-recursion/01-sum-to/task.md

@@ -2,11 +2,13 @@ importance: 5
 
 ---
 
-# Sum all numbers till the given one
+# أجمع كل الأرقام إلي الرقم المُعطى
+
+أكتب دالة `sumTo(n)` لحساب مجموع الارقام هكذا numbers `1 + 2 + ... + n`.
 
 Write a function `sumTo(n)` that calculates the sum of numbers `1 + 2 + ... + n`.
 
-For instance:
+مثلاً:
 
 ```js no-beautify
 sumTo(1) = 1
@@ -17,20 +19,20 @@ sumTo(4) = 4 + 3 + 2 + 1 = 10
 sumTo(100) = 100 + 99 + ... + 2 + 1 = 5050
 ```
 
-Make 3 solution variants:
+أستخدم ثلاث طرق مختلفة:
 
-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. استخدم حلقة `for`.
+2. استخدم التكرار (مساعدة: `sumTo(n) = n + sumTo(n-1)` for `n > 1`)
+3. استخدم [المتتالية العددية](https://en.wikipedia.org/wiki/Arithmetic_progression).
 
-An example of the result:
+مثال علي الناتج: 
 
 ```js
 function sumTo(n) { /*... your code ... */ }
 
 alert( sumTo(100) ); // 5050
 ```
 
-P.S. Which solution variant is the fastest? The slowest? Why?
+1. ما الحل الاسرع؟ وما الابطأ؟ ولماذا؟
 
-P.P.S. Can we use recursion to count `sumTo(100000)`? 
+2. نستطيع إستخدام التكرار للعد `sumTo(100000)`?

1-js/06-advanced-functions/01-recursion/02-factorial/solution.md

@@ -1,6 +1,9 @@
-By definition, a factorial is `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`.
+
+الحل يكمن في التعريف `n!` يساوي `n * (n-1)`.
+
+
+بطريقة أخري, ناتج `factorial(n)` يمكن أن نحسبه علي هذه الطريقة `n` مضروب في ناتج `factorial(n-1)`. ومناداة `n-1`  يمكن أن تنادي نفسها بتكرار أصغر فأصغر حتي نصل إلي`1`
 
 ```js run
 function factorial(n) {
@@ -10,7 +13,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:
+الاساس التكراري هنا هو `1` يمكن أيضاً ان يكون `0` ولكن هذا لا يهم هذا يعطينا مناداة إضافية فقط:
 
 ```js run
 function factorial(n) {

1-js/06-advanced-functions/01-recursion/02-factorial/task.md

@@ -2,17 +2,20 @@ importance: 4
 
 ---
 
-# Calculate factorial
+# إحسب المضروب
 
-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!`
+الـ [مضروب](https://en.wikipedia.org/wiki/Factorial) هو عدد طبيعي يعتبر حاصل ضرب الرقم في نفس الرقم - 1 ثم في نفسه - 2 وهكذا حتي نصل إلي 1.
+
+مضروب العدد `n` يكتب رياضياً علي هذا الشكل and so on till `1`. The factorial of `n` is denoted as `n!`
+
+يمكننا أن نعرفها بهذه الطريقة: 
 
-We can write a definition of factorial like this:
 
 ```js
 n! = n * (n - 1) * (n - 2) * ...*1
 ```
 
-Values of factorials for different `n`:
+قيم مضروب أرقام مختلفة : للـ `n`
 
 ```js
 1! = 1
@@ -22,10 +25,12 @@ 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.
+المهمة هي أن تكتب دالة `factorial(n)` التي تقوم بحساب `n!` بإستخدام الداءات المتكررة.
 
 ```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`
+مساعدة: `n!` يمكن كتابته علي هذا الشكل `n * (n-1)!`
+مثلاً: `3! = 3*2! = 3*2*1! = 6`
+

1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md

@@ -1,6 +1,8 @@
-The first solution we could try here is the recursive one.
 
-Fibonacci numbers are recursive by definition:
+الحل الأول الذي مكن تجربته هنا هو الحل المتكرر.
+
+أعداد فيبوناتشي متكررة وذلك واضح من التعريف:
+
 
 ```js run
 function fib(n) {
@@ -12,36 +14,37 @@ 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.
+لكن القيم الكبيرة من الـ `n` سيكون بطئ جداً مثلاً `fib(77)` يمكن أن تعطل المحركلمد من الزمن
 
-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)`:
+مثلاً لنري قطعة من حساب `fib(5)`:
 
 ```js no-beautify
 ...
 fib(5) = fib(4) + fib(3)
 fib(4) = fib(3) + fib(2)
 ...
 ```
+`fib(5)` و `fib(4)` كلاهما يحتاج لحساب `fib(3)` إذن هذا الدالة سوف تنادي مراتان ليس لهما علاقة ببعضهما.
 
-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`.
+واضح هنا أن `fib(3)` تمت مناداتها مرتين و `fib(2)` سيتم مناداتها وتنفيذها ثلاث مرات. لذلك سيكون عدد الدوال التي تم تنفيذها سيكون هائل جداً حتي إذا كان `n=77`.
+
+يمكننا تحسين هذا عن طريق تذكر القيم التي تم حسابها من قبل: مثلاإذا وجدنا `fib(3)` تم حسابها من قبل نأتي بقيمتها فوراً ولا نقوم بتنفيذها مرة أخري
 
-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.
+ذلك يضع أمامنا خيار أخر وهو أن نتخلي عن التكرار واستخدام طريقة حل مبنية علي الـ Array مختلفة تماماً
 
-Another variant would be to give up recursion and use a totally different loop-based algorithm.
+بدلاً من أن نذهب من `n` أسفل للقيم الأقل, يمكن أن نصنع حلقة تبدأ من `1` و `2`, ثم نأتي بـ `fib(3)` بأعتبار أن ناتجها هو مجموعهم, ثم `fib(4)` بأعتبار أن ناتجها مجموع القيماتان السابقان ثم `fib(5)` تذهب لأعلي ثم أعلي حتي تصل إلي القيمة المطلوبة. كل ما نحتاج تذكره هو الرقمين السابقين.
 
-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
@@ -55,10 +58,10 @@ a  b  c
 1, 1, 2
 */
 ```
+الأن نحن نريد الحصول علي `fib(4) = fib(2) + fib(3)`.
 
-Now we want to get `fib(4) = fib(2) + fib(3)`.
+الأن نحتاج إلي تبديل المتغيرات `a,b` سيصبحوا `fib(2),fib(3)` و `c` سيكون مجموعهم : 
 
-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)
@@ -71,7 +74,8 @@ c = a + b; // c = fib(4)
 */
 ```
 
-The next step gives another sequence number:
+الخطوة التالية تعطينا تسلسل أخر للأرقام: 
+
 
 ```js no-beautify
 a = b; // now a = fib(3)
@@ -84,9 +88,10 @@ c = a + b; // c = fib(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) {
@@ -104,7 +109,7 @@ alert( fib(3) ); // 2
 alert( fib(7) ); // 13
 alert( fib(77) ); // 5527939700884757
 ```
+الحلقة تبدأ من `i=3`, لأننا نعرف قيمة العددين الأولين `a=1`, `b=1`.
 
-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).
+هذا الحل يسمي [البرمجة الديناميكية](https://en.wikipedia.org/wiki/Dynamic_programming).

1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md

@@ -2,17 +2,17 @@ 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.
+متسلسلة [فيبوناتشي](https://en.wikipedia.org/wiki/Fibonacci_number) لها قانون  <code>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub></code>. أو بمعني أخر الرقم القادم يساوي مجموع الرقمين الذان يسبقانه
 
-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...`.
+أول رقمين هما `1` ثم `2(1+1)` ثم `3(1+2)` ثم `5(2+3)` وهكذا:  `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.
+أعداد فيبوناتشي مرتبطة بالـ [نسبة الذهبية ](https://en.wikipedia.org/wiki/Golden_ratio) وكثير من الظواهر الطبيعية.
 
-Write a function `fib(n)` that returns the `n-th` Fibonacci number.
+أكتب دالة `fib(n)` تُعطيك `n-th` العدد الموجود في هذا الترتيب
 
-An example of work:
+مثلاً: 
 
 ```js
 function fib(n) { /* your code */ }
@@ -22,4 +22,5 @@ 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.
+ملحوظة: الدالة يجب أن تكون سريعة. نداء `fib(77)` يجب ألا يأخذ أكثر من أجزاء من الثانية
+

1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md

@@ -1,6 +1,6 @@
-# Loop-based solution
+# حل مبني علي الحلقة
 
-The loop-based variant of the solution:
+الحل:
 
 ```js run
 let list = {
@@ -29,8 +29,8 @@ function printList(list) {
 
 printList(list);
 ```
+يرجي ملاحظة أننا نستخدم المتغير المؤقت `tmp` للمرور خلال القائمة. من الناحية الفنية, يمكن أن نستخدم عامل الدالة `list`:
 
-Please note that we use a temporary variable `tmp` to walk over the list. Technically, we could use a function parameter `list` instead:
 
 ```js
 function printList(list) {
@@ -43,15 +43,20 @@ 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.
+لكن هذا لن يكون محبذاً في المستقبل لأنه بسبب ما من الممكن أن نمد الدالة لفعل شئ أخر للقائمة.
 
-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.
+لو غيرنا الـ `list` سنخسر هذه الميزة.
+
+بمناسبة الحديث عن التسمية الجيدة للمتغيرات, `list` تعتبر الـ القائمة نفسها. بمعني أدق العنصر الأول فيها. وهو يجب أن يبقي هكذا.
+
+علي صعيد أخر, دور `tmp` يهتم فقط بالانتقال بين عناصر القائمة, مثل `i` الموجود في حلقة `for`
 
 From the other side, the role of `tmp` is exclusively a list traversal, like `i` in the `for` loop.
 
-# Recursive solution
+# الحل التكراري
+
+الحل التكراري للدالة `printList(list)` يتبع منطق بسيط لطباعة القائمة: يجب طباعة العنصر الحالي `list` ثم إعادة الموضوع للباقي `list.next` حتي تنتهي القائمة :
 
-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`:
 
 ```js run
 let list = {
@@ -81,8 +86,8 @@ function printList(list) {
 printList(list);
 ```
 
-Now what's better?
+الأن من هو الأفضل؟
 
-Technically, the loop is more effective. These two variants do the same, but the loop does not spend resources for nested function calls.
+عملياً الحلقة أكثر كفاءة بالرغم من أنهم يقومون بنفس المهمة, لكن الحلقة لا تستطيع عمل أكثر من نداء متداخل.
 
-From the other side, the recursive variant is shorter and sometimes easier to understand.
+علي الجانب الأخر التكرار يعتبر أسهل للفهم وأقصر

1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md

@@ -2,9 +2,10 @@ importance: 5
 
 ---
 
-# Output a single-linked list
+# طباعة قائمة متصلة فردية
+
+هذه هي القائمة المتصلة كما ذكرناها في هذا الفصل <info:recursion>: 
 
-Let's say we have a single-linked list (as described in the chapter <info:recursion>):
 
 ```js
 let list = {
@@ -21,9 +22,10 @@ let list = {
   }
 };
 ```
+إكتب دالة `printList(list)` التي تقوم بطباعة القائمة واحداً تلو الأخر.
 
-Write a function `printList(list)` that outputs list items one-by-one.
-
-Make two variants of the solution: using a loop and using recursion.
+قم بحلها بطريقتين: 
+1. مرة بإستخدام الحلقة:
+2. مرة بإستخدام التكرار:
 
-What's better: with recursion or without it?
+ماهو الأفضل: بالتكرار أم بدون التكرار؟