beautify 1st part of the tutorial

1-js/2-first-steps/8-operators/1-increment-order/solution.md

@@ -1,7 +1,7 @@
 # Разъяснения
 
 ```js
-//+ run
+//+ run no-beautify
 var a = 1, b = 1, c, d; 
 
 // префиксная форма сначала увеличивает a до 2, а потом возвращает 

1-js/2-first-steps/8-operators/1-increment-order/task.md

@@ -5,7 +5,7 @@
 Посмотрите, понятно ли вам, почему код ниже работает именно так?
 
 ```js
-//+ run
+//+ run no-beautify
 var a = 1, b = 1, c, d; 
 
 c = ++a; alert(c); // 2

1-js/2-first-steps/8-operators/article.md

@@ -24,14 +24,14 @@ var x = 1;
 *!*
 x = -x;
 */!*
-alert( x );     // -1, применили унарный минус
+alert( x ); // -1, применили унарный минус
 ```
 
 </li>
 <li>*Бинарным* называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:
 
 ```js
-//+ run
+//+ run no-beautify
 var x = 1, y = 3;
 alert( y - x ); // 2, бинарный минус
 ```
@@ -47,7 +47,7 @@ alert( y - x ); // 2, бинарный минус
 
 ```js
 var a = "моя" + "строка";
-alert(a); // моястрока
+alert( a ); // моястрока
 ```
 
 Иначе говорят, что "плюс производит конкатенацию (сложение) строк".
@@ -71,7 +71,7 @@ alert( 2 + '1' ); // "21"
 ```js
 //+ run
 alert( 2 - '1' ); // 1
-alert( 6 / '2'); // 3 
+alert( 6 / '2' ); // 3
 ```
 
 
@@ -109,7 +109,7 @@ alert( apples + oranges ); // "23", так как бинарный плюс ск
 var apples = "2";
 var oranges = "3";
 
-alert( +apples + +oranges); // 5, число, оба операнда предварительно преобразованы в числа
+alert( +apples + +oranges ); // 5, число, оба операнда предварительно преобразованы в числа
 ```
 
 С точки зрения математики такое изобилие плюсов может показаться странным. С точки зрения программирования -- никаких разночтений: сначала выполнятся унарные плюсы, приведут строки к числам, а затем -- бинарный `'+'` их сложит.
@@ -152,7 +152,7 @@ alert( +apples + +oranges); // 5, число, оба операнда предв
 ```js
 var x = 2 * 2 + 1;
 
-alert(x); // 5
+alert( x ); // 5
 ```
 
 **Возможно присваивание по цепочке:**
@@ -165,9 +165,9 @@ var a, b, c;
 a = b = c = 2 + 2;
 */!*
 
-alert(a); // 4
-alert(b); // 4
-alert(c); // 4
+alert( a ); // 4
+alert( b ); // 4
+alert( c ); // 4
 ```
 
 Такое присваивание работает справа-налево, то есть сначала вычислятся самое правое выражение `2+2`, присвоится в `c`, затем выполнится `b = c` и, наконец, `a = b`.
@@ -186,8 +186,8 @@ var b = 2;
 var c = 3 - (a = b + 1);
 */!*
 
-alert(a); // 3
-alert(c); // 0
+alert( a ); // 3
+alert( c ); // 0
 ```
 
 В примере выше результатом `(a = b + 1)` является значение, которое записывается в `a` (т.е. `3`). Оно используется для вычисления `c`.
@@ -208,9 +208,9 @@ alert(c); // 0
 
 ```js
 //+ run
-alert(5 % 2); // 1, остаток от деления 5 на 2 
-alert(8 % 3); // 2, остаток от деления 8 на 3
-alert(6 % 3); // 0, остаток от деления 6 на 3
+alert( 5 % 2 ); // 1, остаток от деления 5 на 2 
+alert( 8 % 3 ); // 2, остаток от деления 8 на 3
+alert( 6 % 3 ); // 0, остаток от деления 6 на 3
 ```
 
 
@@ -223,7 +223,7 @@ alert(6 % 3); // 0, остаток от деления 6 на 3
 <li>**Инкремент** `++` увеличивает на 1:
 
 ```js
-//+ run
+//+ run no-beautify
 var i = 2;
 i++;      // более короткая запись для i = i + 1.
 alert(i); // 3
@@ -233,7 +233,7 @@ alert(i); // 3
 <li>**Декремент** `--` уменьшает на 1:
 
 ```js
-//+ run
+//+ run no-beautify
 var i = 2;
 i--;      // более короткая запись для i = i - 1.
 alert(i); // 1
@@ -283,9 +283,9 @@ alert(a); // *!*1*/!*
 ```js
 //+ run
 var i = 0;
-i++; 
-++i; 
-alert(i); // 2
+i++;
+++i;
+alert( i ); // 2
 ```
 
 </li>
@@ -366,7 +366,7 @@ i++;
 
 ```js
 var n = 2;
-n = n + 5;  
+n = n + 5;
 n = n * 2;
 ```
 
@@ -378,7 +378,7 @@ var n = 2;
 n += 5; // теперь n=7 (работает как n = n + 5)
 n *= 2; // теперь n=14 (работает как n = n * 2)
 
-alert(n); // 14
+alert( n ); // 14
 ```
 
 Так можно сделать для операторов `+,-,*,/` и бинарных `<<,>>,>>>,&,|,^`.
@@ -388,9 +388,9 @@ alert(n); // 14
 ```js
 //+ run
 var n = 2;
-n *= 3 + 5; 
+n *= 3 + 5;
 
-alert(n); // 16  (n = 2 * 8)
+alert( n ); // 16  (n = 2 * 8)
 ```
 
 
@@ -406,7 +406,7 @@ alert(n); // 16  (n = 2 * 8)
 a = (5, 6);
 */!*
 
-alert(a);
+alert( a );
 ```
 
 Запятая позволяет перечислять выражения, разделяя их запятой `','`. Каждое из них -- вычисляется и отбрасывается, за исключением последнего, которое возвращается.