feat(20-arithmetics): перенос теории из Python и адаптация под java

modules/20-arithmetics/10-basics/ru/README.md

@@ -1,23 +1,31 @@
-На базовом уровне компьютеры оперируют только числами. Даже в прикладных программах на высокоуровневых языках внутри много чисел и операций над ними.
+На базовом уровне компьютеры работают только с числами. Даже когда вы пишете большое приложение на современном языке, внутри постоянно идут вычисления. Программа складывает, вычитает, умножает и делит числа тысячи раз в секунду.
 
-К счастью, для старта достаточно знать обычную арифметику — с нее и начнем.
+Сумма товаров в корзине интернет-магазина, координаты персонажа в игре, длительность видео в секундах. За всем этим стоят обычные арифметические операции.
 
-Для сложения двух чисел в математике мы пишем, например, *3 + 4*. В программировании — то же самое. Вот программа, складывающая два числа:
+К счастью, для старта хватит обычной школьной арифметики. С нее и начнем.
+
+## Сложение
+
+В математике сумму записывают как 3 + 4. В Java выражение выглядит так же. Само по себе оно ничего не показывает на экране, поэтому результат нужно вывести.
+
+Для вывода используют знакомую команду `System.out.println()`. Вот целая программа, которая складывает два числа и печатает результат:
 
 ```java
 class App {
     public static void main(String[] args) {
-        3 + 4;
+        System.out.println(3 + 4);
     }
 }
 ```
 
-Если запустить эту программу на выполнение, то она тихо отработает и завершится. На экран ничего не будет выведено. Операция сложения, как и остальные операции, сама по себе ничего не делает, кроме сложения.
+Сначала вычисляется сумма, затем готовое число попадает внутрь команды печати.
 
-Чтобы воспользоваться результатом сложения, его нужно вывести на экран:
-
-```java
+```text
 System.out.println(3 + 4);
+                   └─┬─┘
+                     7
+
+System.out.println(7);  →  7
 ```
 
 После запуска на экране появится результат:
@@ -26,21 +34,84 @@ System.out.println(3 + 4);
 7
 ```
 
-Кроме сложения доступны следующие операции:
+Если то же выражение взять в кавычки, результат изменится. В кавычках получается текст, и на экран выйдет строка как есть:
+
+```java
+System.out.println("3 + 4"); // 3 + 4
+System.out.println(3 + 4);   // 7
+```
+
+В первой строке Java видит текст и печатает его буквально. Во второй видит арифметику и считает.
 
-* `*` — умножение
-* `/` — деление
-* `-` — вычитание
-* `%` — [остаток от деления](https://ru.wikipedia.org/wiki/Деление_с_остатком)
+## Другие операции
 
-Теперь давайте выведем на экран результат деления, а потом результат возведения в степень:
+Кроме сложения в Java есть весь привычный набор операций:
+
+| Операция           | Символ | Пример  | Результат |
+|--------------------|--------|---------|-----------|
+| Сложение           | `+`    | `2 + 3` | `5`       |
+| Вычитание          | `-`    | `7 - 2` | `5`       |
+| Умножение          | `*`    | `4 * 3` | `12`      |
+| Деление            | `/`    | `8 / 2` | `4`       |
+| Остаток от деления | `%`    | `7 % 3` | `1`       |
+
+Выведем результат деления, а потом результат умножения:
 
 ```java
-System.out.println(8 / 2);
-System.out.println(3 * 3 * 3);
+System.out.println(8 / 2);     // 4
+System.out.println(3 * 3 * 3); // 27
 ```
 
-```text
-4
-27
+Отдельного оператора для возведения в степень в Java нет. Когда степень небольшая, число умножают само на себя нужное количество раз, как в примере выше с `3 * 3 * 3`.
+
+## Деление целых чисел
+
+С делением в Java связана важная особенность. Когда оба числа целые, результат тоже получается целым, а дробная часть отбрасывается:
+
+```java
+System.out.println(8 / 2); // 4
+System.out.println(7 / 2); // 3
 ```
+
+Во втором примере на калькуляторе вышло бы 3.5. Java делит 7 на 2 нацело и оставляет только целую часть, то есть 3. Остаток теряется.
+
+Так происходит потому, что целые числа в Java хранятся отдельно от дробных. Для работы с дробями в Java есть особый вид чисел. Их называют числами с плавающей точкой и записывают через точку, например `3.5`. Пока нам хватит целых.
+
+## Остаток от деления
+
+Операция `%` достает то, что остается после деления нацело.
+
+```java
+System.out.println(7 % 3); // 1
+```
+
+Почему получается 1? Тройка помещается в семерке два раза, это дает 6. До семерки не хватает единицы, она и есть остаток.
+
+Еще примеры:
+
+```java
+System.out.println(10 % 4); // 2, четверка вошла в десятку дважды, до 10 осталось 2
+System.out.println(15 % 5); // 0, пятерка делит 15 нацело
+```
+
+Остаток выручает во многих задачах. По нему проверяют, делится ли число нацело. Если остаток равен нулю, значит делится. Так отличают четные числа от нечетных, ведь остаток от деления на 2 равен 0 у четных и 1 у нечетных. А еще остаток помогает считать по кругу. Остаток от деления на 12 работает как циферблат часов, и `13 % 12` дает `1`, ведь после двенадцати отсчет начинается заново. Эта операция встречается в коде постоянно.
+
+## Оформление выражений
+
+Для Java между `3+4` и `3 + 4` разницы нет. Программа поймет оба варианта одинаково и в обоих случаях сложит числа. Разница только в читаемости. В программировании принято отбивать арифметические операторы пробелами, потому что так выражение легче воспринимать:
+
+```java
+3 + 4
+8 / 2
+7 % 3
+```
+
+Вариант без пробелов тоже рабочий:
+
+```java
+3+4
+8/2
+7%3
+```
+
+Выглядит он плотно, и глазу труднее. Привыкайте сразу писать с пробелами вокруг операторов.

modules/20-arithmetics/10-basics/ru/data.yml

@@ -2,5 +2,13 @@
 name: Арифметические операции
 tips:
   - >-
-    Деление на ноль приводит к ошибке. Чтобы его не допустить, нужно знать про
-    условные конструкции (о них вы узнаете в следующих уроках).
+    Отбивайте арифметические операторы пробелами от операндов, это хороший стиль
+    программирования. Так выражение читается удобнее.
+  - Деление на ноль приводит к ошибке.
+  - >-
+    [Деление с остатком](https://ru.wikipedia.org/wiki/Деление_с_остатком)
+definitions:
+  - name: Инструкция
+    description: >-
+      наименьшая автономная часть языка программирования, команда или набор
+      команд. Программа обычно представляет собой последовательность инструкций.

modules/20-arithmetics/20-operators/ru/README.md

@@ -1,33 +1,57 @@
-Перед тем, как двигаться дальше, разберем базовую терминологию. Знак операции, такой как `+`, называют оператором. **Оператор** — просто символ, который выполняет операцию, например, сложение:
+Сначала разберем базовую терминологию. Знак операции вроде `+` называют **оператором**. Оператор задает действие, например сложение:
 
 ```java
-System.out.println(8 + 2); // => 10
+System.out.println(8 + 2); // 10
 ```
 
-В этом примере `+` — это оператор, а числа *8* и *2* — это **операнды**.
+Здесь `+` работает как оператор, а числа `8` и `2` называют **операндами**. Операндами называют значения, к которым оператор применяет действие.
 
-В случае сложения у нас есть два операнда:
-
-* Один слева
-* Другой справа от знака *+*
+```text
+операнд   оператор   операнд       результат
+   8         +          2       →      10
+   5         -          3       →      2
+   4         *          3       →      12
+```
 
-Операции, которые требуют наличия двух операндов, называются **бинарными**. Если пропустить хотя бы один операнд, то программа завершится с синтаксической ошибкой. Например:
+У сложения два операнда. Один стоит слева от знака, другой справа. Операции с двумя операндами называют **бинарными**. Если пропустить хотя бы один операнд, программа не скомпилируется и выдаст синтаксическую ошибку:
 
+```java
+System.out.println(3 + ); // так писать нельзя
 ```
-`3 + ;`
+
+Бинарными операции бывают не всегда. Существуют еще унарные, с одним операндом, и тернарные, с тремя.
+
+## Унарный минус
+
+Один и тот же знак иногда означает разные операции. Посмотрите на минус:
+
+```java
+System.out.println(-3); // -3
 ```
 
-Операции бывают не только бинарными. Бывают еще:
+Здесь минус стоит перед одним числом и работает как унарный оператор. Он берет число `3` и возвращает противоположное ему, то есть `-3`.
 
-* Унарные — с одним операндом
-* Тернарные — с тремя операндами
+Когда минус стоит между двумя числами, это уже вычитание:
 
-Причем операторы могут выглядеть одинаково, но обозначать разные операции:
+```java
+System.out.println(5 - 2);  // 3
+System.out.println(10 - 7); // 3
+```
+
+Разница особенно заметна на отрицательных числах:
 
 ```java
-System.out.println(-3); // => -3
+System.out.println(5 - -2); // 7
 ```
 
-Выше пример применения унарной операции к числу *3*. Оператор «минус» перед тройкой говорит интерпретатору — возьми число *3* и найди противоположное, то есть *-3*.
+Слева идет вычитание `5 - (...)`, а справа унарный минус превращает `2` в отрицательное число. Получается `5 - (-2)`, и это дает `7`. Минус на минус дает плюс, ровно как в школе.
+
+Значение минуса зависит от соседей. Рядом с двумя числами это вычитание, перед одним числом это смена знака. Запись `-3` одновременно и само число, и оператор с операндом. У многих языков программирования такая же логика, так что вещь это привычная.
+
+Унарным бывает и плюс. Запись `+5` лишь подчеркивает, что число положительное, и значения не меняет:
+
+```java
+System.out.println(+5); // 5
+```
 
-Это немного может сбить с толку, потому что *-3* — это одновременно и число само по себе, и оператор с операндом, но у языков программирования такая структура.
+Остальные арифметические операторы `*`, `/` и `%` всегда бинарные, им нужны два операнда. Только плюс и минус умеют работать сразу в двух ролях, и как бинарные, и как унарные.

modules/20-arithmetics/20-operators/ru/data.yml

@@ -1,5 +1,9 @@
 ---
 name: Операторы
+tips:
+  - >-
+    Отбивайте арифметические операторы пробелами от операндов, это хороший стиль
+    программирования.
 definitions:
   - name: Арифметическая операция
     description: сложение, вычитание, умножение и деление.

modules/20-arithmetics/30-commutative/ru/README.md

@@ -1,15 +1,44 @@
-Мы все помним со школы: «от перемены мест слагаемых сумма не меняется». Это один из базовых и интуитивно понятных принципов арифметики — **коммутативный закон**.
+Мы все помним со школы фразу "от перемены мест слагаемых сумма не меняется". Это один из базовых принципов арифметики, он называется **коммутативным законом**.
 
-Бинарная операция считается коммутативной, если, вы получаете тот же самый результат, поменяв местами операнды. Очевидно, что сложение — коммутативная операция:
+## Что такое коммутативность
 
-```text
-3 + 2 = 2 + 3
+Операцию называют коммутативной, когда порядок операндов не влияет на результат. Поменяли значения местами и получили тот же ответ. Сложение коммутативно:
+
+```java
+System.out.println(3 + 2); // 5
+System.out.println(2 + 3); // 5
 ```
 
-А вот вычитание — это не коммутативная операция:
+Одинаковый результат подтверждает коммутативность.
 
 ```text
-2 - 3 ≠ 3 - 2
+2 + 3 = 5     3 + 2 = 5
+└──────────┬─────────┘
+   одинаковый результат
+
+2 - 3 = -1    3 - 2 = 1
+└──────────┬─────────┘
+     разный результат
+```
+
+## Некоммутативные операции
+
+Не все операции так устроены. Вычитание меняет результат, когда операнды меняются местами:
+
+```java
+System.out.println(2 - 3); // -1
+System.out.println(3 - 2); // 1
+```
+
+Деление тоже некоммутативно, и в Java это видно особенно ярко:
+
+```java
+System.out.println(8 / 2); // 4
+System.out.println(2 / 8); // 0
 ```
 
-В программировании этот закон работает точно так же, как в арифметике. Более того, большинство операций не являются коммутативными. Отсюда вывод: всегда обращайте внимание на порядок того, с чем работаете.
+В первом случае восьмерка делится на двойку и дает `4`. Во втором двойка делится на восьмерку. Целых восьмерок в двойке не помещается ни одной, поэтому при делении целых чисел получается `0`.
+
+## В программировании так же, как в арифметике
+
+Java следует тем же математическим правилам, что и школьная арифметика. А раз большинство операций некоммутативны, порядок операндов всегда важен. Обращайте на него внимание, особенно с незнакомой операцией, и проверяйте порядок на примере вместо догадок.

modules/20-arithmetics/30-commutative/ru/data.yml

@@ -1,8 +1,11 @@
 ---
 name: Коммутативная операция
+tips:
+  - >-
+    [Подробнее про коммутативность](https://ru.wikipedia.org/wiki/Коммутативность)
 definitions:
   - name: Коммутативность
     description: >-
-      свойство операции, когда изменения порядка операндов не влияет на
-      результат. Например, сложение — коммутативная операция: от перемены мест
-      слагаемых сумма не меняется.
+      свойство операции, при котором изменение порядка операндов не влияет на
+      результат. Например, сложение коммутативно: от перемены мест слагаемых
+      сумма не меняется.