Translate numbers to AR

Author: Ahmed-Adel3

1-js/05-data-types/02-number/1-sum-interface/solution.md

@@ -7,6 +7,4 @@ let b = +prompt("The second number?", "");
 alert( a + b );
 ```
 
-Note the unary plus `+` before `prompt`. It immediately converts the value to a number.
-
-Otherwise, `a` and `b` would be string their sum would be their concatenation, that is: `"1" + "2" = "12"`.
+لاحظ عامل الجمع الأحادي `+` قبل `prompt`. يحوِّل القيم إلى أعداد. وإلا فإن `a` و `b` ستكون نصوصًا وسيكون مجموعهما بدمجهما: `"1" + "2" = "12"`.

1-js/05-data-types/02-number/1-sum-interface/task.md

@@ -1,11 +1,10 @@
-importance: 5
+الأهمية: 5
 
 ---
 
-# Sum numbers from the visitor
+# جمع الأعداد من الزائر
 
-Create a script that prompts the visitor to enter two numbers and then shows their sum.
+انشِئ سكربت يتيح للمستخدم ادخال رقمين ثم أعرض مجموعهما.
 
 [demo]
 
-P.S. There is a gotcha with types.

1-js/05-data-types/02-number/2-why-rounded-down/solution.md

@@ -1,33 +1,30 @@
-Internally the decimal fraction `6.35` is an endless binary. As always in such cases, it is stored with a precision loss.
-
-Let's see:
+الجزء `6.35` هو عبارة عن عدد غير منتهي في الصيغة الثنائية. وكجميع الحالات المشابهة، يُخَزَّن مع ضياع في الدقة. لنرَ:
 
 ```js run
 alert( 6.35.toFixed(20) ); // 6.34999999999999964473
 ```
 
-The precision loss can cause both increase and decrease of a number. In this particular case the number becomes a tiny bit less, that's why it rounded down.
-
-And what's for `1.35`?
+قد يتسبب ضياع الدقة في زيادة أو نقصان أي عدد. يكون العدد في هذه الحالة أقل بقليل من قيمته الفعلية، ولهذا يُدَوَّر للأسفل. ماذا عن العدد `1.35`؟
 
 ```js run
 alert( 1.35.toFixed(20) ); // 1.35000000000000008882
 ```
 
-Here the precision loss made the number a little bit greater, so it rounded up.
+جعل ضياع الدقة هذا الرقم أكبر بقليل مما هو عليه مما تسبب في تقريبه للأعلى.
+
+**كيف يمكننا حل مشكلة تقريب العدد `6.35` حتى يُدَوَّر بالشكل الصحيح**
 
-**How can we fix the problem with `6.35` if we want it to be rounded the right way?**
+يجب أن نحوله إلى عدد صحيح قبل التقريب:
 
-We should bring it closer to an integer prior to rounding:
 
 ```js run
 alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000
 ```
 
-Note that `63.5` has no precision loss at all. That's because the decimal part `0.5` is actually `1/2`. Fractions divided by powers of `2` are exactly represented in the binary system, now we can round it:
+لاحظ عدم وجود أي ضياع في دقة العدد `63.5`. ذلك لأن الجزء العشري `0.5` يساوي `1/2`. يمكن تمثيل الأجزاء المقسومة على `2` تُمَثَّل بشكل صحيح في النظام الثنائي. يمكننا تقريب العدد الآن:
 
 
 ```js run
-alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
+alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(مقرب) -> 6.4
 ```
 

1-js/05-data-types/02-number/2-why-rounded-down/task.md

@@ -1,22 +1,24 @@
-importance: 4
+الأهمية: 4
 
 ---
 
-# Why 6.35.toFixed(1) == 6.3?
+#  لماذا ‎6.35.toFixed(1) == 6.3؟
 
-According to the documentation `Math.round` and `toFixed` both round to the nearest number: `0..4` lead down while `5..9` lead up.
 
-For instance:
+تُدَوِّر كلًا من `Math.round` و `toFixed` العدد إلى أقرب عدد له وفقًا للتوثيق: الأجزاء من `0..4` تُدَوَّر للأسفل، بينما الأجزاء `5..9` تثدَوَّر للأعلى.
+
+مثلًا:
+
 
 ```js run
 alert( 1.35.toFixed(1) ); // 1.4
 ```
 
-In the similar example below, why is `6.35` rounded to `6.3`, not `6.4`?
+في المثال المشابه  أدناه، لِمَ تُدَوَّر `6.35` إلى `6.3`، وليس `6.4`؟
 
 ```js run
 alert( 6.35.toFixed(1) ); // 6.3
 ```
 
-How to round `6.35` the right way?
+كيف نُدَوِّر `6.35` بالطريقة الصحيحة؟
 

1-js/05-data-types/02-number/3-repeat-until-number/task.md

@@ -1,14 +1,12 @@
-importance: 5
+الأهمية: 5
 
 ---
 
-# Repeat until the input is a number
+#  كرر حتى يصبح المُدخَل عددًا
 
-Create a function `readNumber` which prompts for a number until the visitor enters a valid numeric value.
+أنشِئ الدالة `readNumber` والتي تطلب من الزائر إدخال عدد حتى يقوم بإدخال قيمة عددية صحيحة. يجب أن تكون القيمة المُرجَعة عددًا.
 
-The resulting value must be returned as a number.
-
-The visitor can also stop the process by entering an empty line or pressing "CANCEL". In that case, the function should return `null`.
+يمكن للزائر إيقاف العملية بإدخال سطر فارغ أو الضغط على "CANCEL". يجب أن تُرجِع الدالة `null` في هذه الحالة.
 
 [demo]
 

1-js/05-data-types/02-number/4-endless-loop-error/solution.md

@@ -1,6 +1,4 @@
-That's because `i` would never equal `10`.
-
-Run it to see the *real* values of `i`:
+ذلك لأن `i` لن  يساوي `10` أبدًا. نفذ الشيفرة التالية لرؤية قيم `i`:
 
 ```js run
 let i = 0;
@@ -10,8 +8,4 @@ while (i < 11) {
 }
 ```
 
-None of them is exactly `10`.
-
-Such things happen because of the precision losses when adding fractions like `0.2`.
-
-Conclusion: evade equality checks when working with decimal fractions.
+لا توجد قيمة تساوي `10` تمامًا. تحدث مثل هذه الأمور بسبب ضياع الدقة عند إضافة الأجزاء مثل `0.2`. الخلاصة، تجنب التحقق من المساواة عند التعامل مع الأجزاء العشرية.

1-js/05-data-types/02-number/4-endless-loop-error/task.md

@@ -1,10 +1,10 @@
-importance: 4
+الأهمية: 4
 
 ---
 
-# An occasional infinite loop
+# حلقة غير منتهية أحيانًا
 
-This loop is infinite. It never ends. Why?
+الحلقة التالية غير منتهية، ولا تتوقف أبدًا. لماذا؟
 
 ```js
 let i = 0;

1-js/05-data-types/02-number/8-random-min-max/solution.md

@@ -1,11 +1,9 @@
-We need to "map" all values from the interval 0..1 into values from `min` to `max`.
+نريد تعيين جميع القيم من الفترة 0…1 إلى القيم من `min` إلى `max`. يمكن القيام بذلك في مرحلتين:
+1. إذا ضربنا قيمة عشوائية من 0…1 في `max-min`. فإن فترة القيم الممكنة تزيد `0..1` إلى `0..max-min`.
+2. إذا أضفنا `min` الآن، تصبح الفترة من `min` إلى `max`.
 
-That can be done in two stages:
+الدالة:
 
-1. If we multiply a random number from 0..1 by `max-min`, then the interval of possible values increases `0..1` to `0..max-min`.
-2. Now if we add `min`, the possible interval becomes from `min` to `max`.
-
-The function:
 
 ```js run
 function random(min, max) {

1-js/05-data-types/02-number/8-random-min-max/task.md

@@ -1,14 +1,13 @@
-importance: 2
+الأهمية: 2
 
 ---
 
-# A random number from min to max
+#  رقم عشوائي من العدد الأدنى إلى الأقصى
 
-The built-in function `Math.random()` creates a random value from `0` to `1` (not including `1`).
+تُنشِئ الدالة `Math.random()‎` المُضَمَنَة في اللغة قيمة عشوائية بين `0` و `1` (ليس بما في ذلك `1`). اكتب الدالة `random(min, max)‎` لتوليد عدد عشري عشوائي من `min` إلى `max` (بما لا يتضمن `max`).
 
-Write the function `random(min, max)` to generate a random floating-point number from `min` to `max` (not including `max`).
+أمثلة عن عملها:
 
-Examples of its work:
 
 ```js
 alert( random(1, 5) ); // 1.2345623452

1-js/05-data-types/02-number/9-random-int-min-max/solution.md

@@ -1,6 +1,6 @@
-# The simple but wrong solution
+# الطريقة السهلة والخطأ
 
-The simplest, but wrong solution would be to generate a value from `min` to `max` and round it:
+الحل الأسهل لكنه خطأ سيكون بتوليد قيمة من `min` إلى `max` وتقريبها:
 
 ```js run
 function randomInteger(min, max) {
@@ -11,28 +11,26 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-The function works, but it is incorrect. The probability to get edge values `min` and `max` is two times less than any other.
+الدالة تعمل لكنها خطأ. احتمال ظهور القيم الطرفية `min` و `max` أقل بمرتين من باقي القيم. إن شغلنا المثال أعلاه لعدة مرات، فينرى ظهور `2` بصورة أكبر.
 
-If you run the example above many times, you would easily see that `2` appears the most often.
-
-That happens because `Math.round()` gets random numbers from the interval `1..3` and rounds them as follows:
+يحدث ذلك لأن `Math.round()‎` تأخذ رقما من الفترة `1..3` وتُدَوِرها كما يلي:
 
 ```js no-beautify
 values from 1    ... to 1.4999999999  become 1
 values from 1.5  ... to 2.4999999999  become 2
 values from 2.5  ... to 2.9999999999  become 3
 ```
 
-Now we can clearly see that `1` gets twice less values than `2`. And the same with `3`.
+نلاحظ الآن أن لدى `1` قيم أقل بمرتين من `2` وكذلك `3`.
 
-# The correct solution
+# الطريقة الصحيحة
 
-There are many correct solutions to the task. One of them is to adjust interval borders. To ensure the same intervals, we can generate values from `0.5 to 3.5`, thus adding the required probabilities to the edges:
+يوجد العديد من الطرق الصحيحة لحل هذه المهمة. إحداها هو بتعديل حدود الفترة. للتأكد من وجود  فرص متساوية، نُوَلِّد قيمًا من `0.5` إلى `3.5`، ثم إضافة الاحتمالات الممكنة للأطراف:
 
 ```js run
 *!*
 function randomInteger(min, max) {
-  // now rand is from  (min-0.5) to (max+0.5)
+  // (max+0.5) إلى (min-0.5) التقريب الآن من
   let rand = min - 0.5 + Math.random() * (max - min + 1);
   return Math.round(rand);
 }
@@ -41,12 +39,12 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-An alternative way could be to use `Math.floor` for a random number from `min` to `max+1`:
+طريقة بديلة هي استخدام الدالة `Math.floor` لرقم عشوائي من `min` إلى `max+1`:
 
 ```js run
 *!*
 function randomInteger(min, max) {
-  // here rand is from min to (max+1)
+  // (max+1) إلى min التقريب الآن من 
   let rand = min + Math.random() * (max + 1 - min);
   return Math.floor(rand);
 }
@@ -55,12 +53,12 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-Now all intervals are mapped this way:
+جميع الفترات أصبحت متوازنة الآن:
 
 ```js no-beautify
 values from 1  ... to 1.9999999999  become 1
 values from 2  ... to 2.9999999999  become 2
 values from 3  ... to 3.9999999999  become 3
 ```
 
-All intervals have the same length, making the final distribution uniform.
+لدى جميع الفترات الطول ذاته مما يجعل التوزيع النهائي موحدًا.