From a5b538bb01ea157857528429bc68c9e5dc7b5ec1 Mon Sep 17 00:00:00 2001 From: Nikolay Gagarinov Date: Wed, 24 Jun 2026 01:40:36 +0500 Subject: [PATCH] =?UTF-8?q?feat(90-loops):=20=D0=BF=D0=B5=D1=80=D0=B5?= =?UTF-8?q?=D0=BD=D0=BE=D1=81=20=D1=82=D0=B5=D0=BE=D1=80=D0=B8=D0=B8=20?= =?UTF-8?q?=D0=B8=D0=B7=20Python=20=D0=B8=20=D0=B0=D0=B4=D0=B0=D0=BF=D1=82?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BF=D0=BE=D0=B4=20java?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 4.8 (1M context) --- .../200-aggregation-strings/ru/README.md | 32 ++++++++- .../200-aggregation-strings/ru/data.yml | 7 +- .../250-iteration-over-strings/ru/README.md | 45 ++++++++++-- .../250-iteration-over-strings/ru/data.yml | 4 +- .../300-conditions-inside-loops/ru/README.md | 52 +++++++++----- .../90-loops/400-syntax-sugar/ru/README.md | 71 +++++++++++++++++-- modules/90-loops/400-syntax-sugar/ru/data.yml | 9 ++- .../500-return-from-loops/ru/README.md | 34 ++++++--- .../500-return-from-loops/ru/data.yml | 3 + modules/90-loops/550-for/ru/README.md | 71 ++++++++++++++++--- modules/90-loops/550-for/ru/data.yml | 3 + 11 files changed, 276 insertions(+), 55 deletions(-) diff --git a/modules/90-loops/200-aggregation-strings/ru/README.md b/modules/90-loops/200-aggregation-strings/ru/README.md index 33f9201..5da8b85 100644 --- a/modules/90-loops/200-aggregation-strings/ru/README.md +++ b/modules/90-loops/200-aggregation-strings/ru/README.md @@ -1,6 +1,6 @@ -Агрегация применяется не только к числам, но и к строкам. +Агрегация применяется не только к числам, но и к строкам. Под агрегацией строк понимают задачи, в которых заранее неизвестно, что содержат строки и какого они размера. -При агрегации строка формируется динамически, то есть заранее неизвестно, какого она размера и что будет содержать. Представьте себе метод, который умеет умножать строку — то есть он повторяет ее указанное количество раз: +При агрегации строка формируется динамически. Представьте себе метод, который повторяет строку указанное количество раз. В Java для этого есть готовые средства, но здесь мы посмотрим, как такой повтор устроен внутри: ```java App.repeat("hexlet", 3); // "hexlethexlethexlet" @@ -10,7 +10,7 @@ App.repeat("hexlet", 3); // "hexlethexlethexlet" ```java public static String repeat(String text, int times) { - // Нейтральный элемент для строк – пустая строка + // Нейтральный элемент для строк — пустая строка var result = ""; var i = 1; @@ -33,3 +33,29 @@ result = result + "hexlet"; // "hexlet" result = result + "hexlet"; // "hexlethexlet" result = result + "hexlet"; // "hexlethexlethexlet" ``` + +Наглядно процесс наращивания строки выглядит так: + +```text +repeat("hexlet", 3): + +i=1: result = "" + "hexlet" = "hexlet" +i=2: result = "hexlet" + "hexlet" = "hexlethexlet" +i=3: result = "hexlethexlet" + "hexlet" = "hexlethexlethexlet" + └── результат +``` + +Здесь работают сразу две переменные. Счетчик `i` управляет количеством повторов и останавливает цикл, когда повторов набралось `times`. Переменная `result` хранит накопленную строку и отдает ее вызывающему коду после цикла. + +## Нейтральный элемент + +Чтобы наращивание заработало, нужно стартовое значение. Для строк им служит **пустая строка** `""`. + +Ее называют нейтральным элементом, потому что при конкатенации она ничего не меняет: + +```java +System.out.println("" + "abc"); // => abc +System.out.println("abc" + ""); // => abc +``` + +Поэтому пустая строка всегда стоит в начале при агрегации строк. С нее цикл начинает наращивание, а дальше на каждой итерации добавляет к результату очередной кусок. diff --git a/modules/90-loops/200-aggregation-strings/ru/data.yml b/modules/90-loops/200-aggregation-strings/ru/data.yml index 4ed1fe3..8b66212 100644 --- a/modules/90-loops/200-aggregation-strings/ru/data.yml +++ b/modules/90-loops/200-aggregation-strings/ru/data.yml @@ -1,3 +1,8 @@ --- name: Агрегация данных (Строки) -tips: [] +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/90-loops/250-iteration-over-strings/ru/README.md b/modules/90-loops/250-iteration-over-strings/ru/README.md index dc7f50f..22876d8 100644 --- a/modules/90-loops/250-iteration-over-strings/ru/README.md +++ b/modules/90-loops/250-iteration-over-strings/ru/README.md @@ -1,14 +1,16 @@ -Циклы подходят не только для обработки чисел, но и при работе со строками. В первую очередь благодаря возможности получить конкретный символ по его индексу. Ниже пример кода, который распечатывает буквы каждого слова на отдельной строке: +С помощью циклов обрабатывают числа и работают со строками. Строка состоит из символов, и до каждого символа можно добраться по его индексу. Индексы начинаются с нуля, поэтому первый символ строки `"Arya"` имеет индекс `0`, а последний — индекс `length() - 1`. + +Получить символ по индексу позволяет метод `charAt()`, а узнать длину строки — метод `length()`. Этих двух методов и счетчика достаточно, чтобы пройти строку символ за символом. Ниже пример кода, который печатает буквы слова на отдельных строках: ```java public static void printNameBySymbol(String name) { var i = 0; - // Такая проверка будет выполняться до конца строки + // Такая проверка выполняется до конца строки, // включая последний символ. Его индекс `length() - 1`. while (i < name.length()) { // Обращаемся к символу по индексу System.out.println(name.charAt(i)); - i += 1; + i = i + 1; } } @@ -20,9 +22,42 @@ App.printNameBySymbol(name); // "a" ``` -Самое главное в этом коде — поставить правильное условие в `while`. Это можно сделать сразу двумя способами: +Цикл проходит по каждому символу строки по очереди: + +```text +"Arya" + │ │ │ │ + A r y a + ↓ ↓ ↓ ↓ +каждый символ обрабатывается по очереди +``` + +Главное в этом коде — поставить правильное условие в `while`. Сделать это можно двумя способами: * `i < name.length()` * `i <= name.length() - 1` -Оба способа приводят к одному результату. +Оба способа приводят к одному результату. Первый встречается чаще, потому что в нем меньше арифметики. + +## Обход в обратном порядке + +Счетчик не обязан расти от нуля. Если начать с последнего индекса и уменьшать его до нуля, строка пройдется задом наперед. Напишем метод, который печатает символы слова в обратном порядке: + +```java +public static void printReversed(String name) { + // Начинаем с последнего символа + var i = name.length() - 1; + while (i >= 0) { + System.out.println(name.charAt(i)); + i = i - 1; + } +} + +App.printReversed("Arya"); +// "a" +// "y" +// "r" +// "A" +``` + +Здесь счетчик `i` стартует со значения `name.length() - 1`, двигается к нулю и завершает цикл, когда становится меньше нуля. На каждом шаге метод берет символ по текущему индексу и печатает его. Направление обхода задает только начальное значение счетчика и способ его изменения. diff --git a/modules/90-loops/250-iteration-over-strings/ru/data.yml b/modules/90-loops/250-iteration-over-strings/ru/data.yml index 8f2c0f7..365a7f6 100644 --- a/modules/90-loops/250-iteration-over-strings/ru/data.yml +++ b/modules/90-loops/250-iteration-over-strings/ru/data.yml @@ -1,3 +1,5 @@ --- name: Обход строк -tips: [] +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) diff --git a/modules/90-loops/300-conditions-inside-loops/ru/README.md b/modules/90-loops/300-conditions-inside-loops/ru/README.md index 050f308..ba4dcf5 100644 --- a/modules/90-loops/300-conditions-inside-loops/ru/README.md +++ b/modules/90-loops/300-conditions-inside-loops/ru/README.md @@ -1,11 +1,11 @@ -Тело цикла, как и тело метода — это место выполнения инструкций. Значит, мы можем использовать внутри него все изученное ранее — в том числе условные конструкции. +Тело цикла, как и тело метода — это место выполнения инструкций. Значит, внутри него работает все изученное раньше, в том числе условные конструкции. Так программа повторяет одно действие много раз, но на каждом повторе принимает решение. -Рассмотрим метод, который считает, сколько раз входит буква в предложение: +Цикл перебирает значения подряд, а условие внутри цикла решает, что делать с текущим значением. Рассмотрим метод, который считает, сколько раз буква входит в предложение: ```java -countChars("Fear cuts deeper than swords.", 'e'); // 4 -// Если вы ничего не нашли, то результат — 0 совпадений -countChars("Sansa", 'y'); // 0 +App.countChars("Fear cuts deeper than swords.", 'e'); // 4 +// Если ничего не нашли, то результат — 0 совпадений +App.countChars("Sansa", 'y'); // 0 ``` Сначала попробуйте ответить на вопросы: @@ -13,25 +13,41 @@ countChars("Sansa", 'y'); // 0 * Является ли эта операция агрегацией? * Какой будет проверка на вхождение символа? -А теперь посмотрим на фрагмент кода: +А теперь посмотрим на код: ```java public static int countChars(String str, char ch) { - var i = 0; - var count = 0; - while (i < str.length()) { - if (str.charAt(i) == ch) { - // Считаем только подходящие символы - count = count + 1; + var i = 0; + var count = 0; + while (i < str.length()) { + if (str.charAt(i) == ch) { + // Считаем только подходящие символы + count = count + 1; + } + // Счетчик увеличивается в любом случае + i = i + 1; } - // Счетчик увеличивается в любом случае - i = i + 1; - } - return count; + return count; } ``` -Эта задача является агрегирующей. Метод считает не все символы, но при этом для подсчета самой суммы все равно приходится анализировать каждый символ. +Это агрегирующая задача. Метод считает не все символы, но для подсчета суммы все равно приходится посмотреть каждый. Переменная `count` хранит результат и растет только тогда, когда текущий символ совпал с искомым. -Ключевое отличие этого цикла от рассмотренных в наличии условия внутри тела. Переменная `count` увеличивается только в том случае, когда текущий рассматриваемый символ совпадает с ожидаемым. В остальном — это типичный агрегатный метод, который возвращает количество нужных символов вызываемому коду. +## Счетчик и условие отвечают за разное + +В таком цикле удобно разделять две части. Счетчик `i` переводит программу к следующему символу, а `if` решает, что делать с текущим. Счетчик меняется на каждой итерации, а действие внутри `if` выполняется не всегда. + +Это важно. Если увеличивать `i` только внутри `if`, цикл застрянет на первом неподходящем символе, потому что счетчик перестанет расти и условие `i < str.length()` навсегда останется истинным. Программа зациклится. Поэтому строка `i = i + 1` стоит снаружи `if` и выполняется при любом исходе проверки. + +## Работа по шагам + +Разберем вызов `countChars("Sansa", 'a')`. До цикла `i` равен `0`, а `count` равен `0`. + +**Шаг 1.** Условие `i < str.length()` истинно. Символ с индексом `0` — это `S`. Он не равен `a`, блок `if` не выполняется. Затем `i` растет до `1`. + +**Шаг 2.** Условие снова истинно. Символ с индексом `1` — это `a`. Он совпал с искомым, поэтому `count` растет до `1`. Затем `i` растет до `2`. + +Дальше цикл проверяет каждый символ. Подходящие он считает, остальные пропускает. Когда `i` станет равен длине строки, условие цикла станет ложным, и метод вернет накопленное значение `count`. + +Условие внутри цикла может проверять что угодно — четность числа, совпадение символа, длину строки или значение переменной. Главное, чтобы счетчик продолжал меняться и цикл мог завершиться. diff --git a/modules/90-loops/400-syntax-sugar/ru/README.md b/modules/90-loops/400-syntax-sugar/ru/README.md index add601b..2c26408 100644 --- a/modules/90-loops/400-syntax-sugar/ru/README.md +++ b/modules/90-loops/400-syntax-sugar/ru/README.md @@ -1,9 +1,66 @@ -Подобные конструкции `index = index + 1` в Java используются довольно часто, поэтому создатели языка добавили сокращенный вариант записи: `index += 1`. Такие сокращения принято называть **синтаксическим сахаром**, потому что они делают процесс написания кода немного проще и приятнее. +В программировании часто встречаются повторяющиеся конструкции. В Java, как и во многих других языках, их запись можно сократить. Такие упрощения называют **синтаксическим сахаром**. Они делают написание кода короче и приятнее, сохраняя тот же результат. -Существуют сокращенные формы для всех арифметических операций и для конкатенации строк: +## Сокращенные формы присваивания -* `a = a + 1` → `a += 1` -* `a = a - 1` → `a -= 1` -* `a = a * 2` → `a *= 2` -* `a = a / 1` → `a /= 1` -* `a = a + "foo"` → `a += "foo"` +Часто значение переменной меняют, прибавив или вычтя что-то, умножив или разделив на число. Базовый вариант выглядит так: + +```java +index = index + 1; +count = count * 2; +total = total - 5; +price = price / 3; +``` + +Java позволяет записать то же самое короче, с помощью составных операторов: + +```java +index += 1; // то же самое, что index = index + 1 +count *= 2; // то же самое, что count = count * 2 +total -= 5; // то же самое, что total = total - 5 +price /= 3; // то же самое, что price = price / 3 +``` + +Каждый такой оператор берет текущее значение переменной, применяет операцию и сохраняет результат в ту же переменную. Слева всегда стоит имя переменной, в которую запишется новое значение. + +## Сахар в циклах + +В циклах такие сокращения встречаются особенно часто. В них обычно меняют счетчик и накапливают результат: + +```java +var sum = 0; +var index = 1; + +while (index <= 5) { + sum += index; // то же самое, что sum = sum + index + index += 1; // то же самое, что index = index + 1 +} + +System.out.println(sum); // => 15 +``` + +Без сокращений тело цикла было бы длиннее и многословнее: + +```java +while (index <= 5) { + sum = sum + index; + index = index + 1; +} +``` + +## Конкатенация строк + +Составные операторы работают не только с числами. Для строк подходит `+=`, потому что `+` соединяет строки: + +```java +var text = "Hello"; +text += " World"; // то же самое, что text = text + " World" +// "Hello World" +``` + +Поэтому при сборке строки в цикле счетчик меняют через `+=`, а к результату каждый раз дописывают очередной символ тем же оператором. + +## Поддерживаемые сокращения + +Сокращенная форма есть почти у всех операторов: `+=`, `-=`, `*=`, `/=`, `%=`. Все они работают по одному принципу — берут текущее значение переменной, применяют операцию и кладут результат обратно. + +Отдельно стоит изменение переменной на единицу. Запись `index += 1` можно сократить до `index++`, а `index -= 1` — до `index--`. Эти две операции называют инкрементом и декрементом, у них есть свои тонкости, и им посвящен отдельный разговор. diff --git a/modules/90-loops/400-syntax-sugar/ru/data.yml b/modules/90-loops/400-syntax-sugar/ru/data.yml index 84ecd90..cebb736 100644 --- a/modules/90-loops/400-syntax-sugar/ru/data.yml +++ b/modules/90-loops/400-syntax-sugar/ru/data.yml @@ -1,3 +1,10 @@ --- name: Синтаксический сахар -tips: [] +tips: + - | + [Синтаксический сахар](https://ru.wikipedia.org/wiki/Синтаксический_сахар) +definitions: + - name: Синтаксический сахар + description: > + это синтаксические возможности, применение которых не влияет на поведение + программы, но делает использование языка более удобным для человека. diff --git a/modules/90-loops/500-return-from-loops/ru/README.md b/modules/90-loops/500-return-from-loops/ru/README.md index cc417ec..a4c3d49 100644 --- a/modules/90-loops/500-return-from-loops/ru/README.md +++ b/modules/90-loops/500-return-from-loops/ru/README.md @@ -1,14 +1,17 @@ +Работа с циклами обычно сводится к двум сценариям. В первом результат накапливается во время итераций, а работа с ним идет уже после цикла. Такой подход называют агрегацией, и переворот строки относится к нему. Во втором цикл выполняется до достижения нужного результата и завершается досрочно. Так устроена, например, проверка простого числа, которое делится без остатка только на себя и на единицу. -Работа с циклами обычно сводится к двум сценариям: +Рассмотрим алгоритм проверки простоты числа. Будем делить искомое число `x` на все числа из диапазона от двух до `x - 1` и смотреть остаток. Если в этом диапазоне не нашелся делитель, который делит `x` без остатка, значит, перед нами простое число. -1. Агрегация — накопление результата во время итераций и работа с ним после цикла. Переворот строки как раз относится к такому варианту -2. Выполнение цикла до достижения необходимого результата и выход. Например, задача поиска простых чисел. Вспомним, что простое число делится без остатка только на себя и на единицу +## Проверка простоты числа 5: пошаговый разбор -Рассмотрим простой алгоритм проверки простоты числа. Попробуем поделить искомое число `x` на все числа из диапазона от двух до `x - 1` и смотреть остаток от деления. Если в этом диапазоне не найден делитель, который делит число `x` без остатка, значит перед нами простое число. +1. Берем число `x = 5`. Возможные делители ищем в диапазоне от 2 до `x - 1`, то есть от 2 до 4 +2. Делим 5 на 2. Остаток равен 1, делителя не нашли, продолжаем +3. Делим 5 на 3. Остаток равен 2, делителя не нашли, продолжаем +4. Делим 5 на 4. Остаток равен 1, делителя не нашли, завершаем перебор -Можно заметить, что достаточно проверять числа не до `x - 1`, а до половины числа. Например, 11 не делится на 2, 3, 4, 5. Но и дальше гарантированно не будет делиться на числа больше своей половины. +Итог: в диапазоне от 2 до 4 не нашлось ни одного числа, на которое 5 делится без остатка. Значит, 5 — простое число. -Значит, можно провести небольшую оптимизацию и проверять деление только до `x / 2`: +Поиск делителей достаточно ограничить половиной числа. Например, 11 не делится на 2, 3, 4, 5, а на числа больше своей половины оно тем более не разделится. Значит, алгоритм можно оптимизировать и проверять деление только до `x / 2`: ```java public static boolean isPrime(int number) { @@ -35,6 +38,21 @@ App.isPrime(3); // true App.isPrime(4); // false ``` -Алгоритм построен таким образом, что если во время последовательного деления на числа до `x / 2` находится хоть одно, которое делит без остатка, то переданный аргумент — не простое число, а значит дальнейшие вычисления не имеют смысла. В этом месте стоит возврат `false`. +*Если быть честными до конца, для решения задачи хватит проверки чисел до квадратного корня из `number`. Но здесь важно сосредоточиться на работе с условием внутри цикла* -И только если цикл отработал целиком, можно сделать вывод, что число — простое, так как не было найдено ни одного числа, которое делит число без остатка. +Главный прием этого урока — выход из метода прямо изнутри цикла: + +```text +while (...) { + if (условие) { + return значение; ← выход из метода (и из цикла) + } + ... +} +───────────────────────────────── +Без return цикл доходит до конца +``` + +Алгоритм построен так, что при последовательном делении на числа до `x / 2` достаточно найти хотя бы один делитель без остатка. Тогда переданный аргумент — составное число, и дальнейшие вычисления не имеют смысла. В этом месте стоит возврат `false`, и `return` сразу завершает и цикл, и весь метод. + +И только если цикл отработал целиком и ни один делитель без остатка не нашелся, выполнение дойдет до последней строки. Метод вернет `true`, потому что число оказалось простым. diff --git a/modules/90-loops/500-return-from-loops/ru/data.yml b/modules/90-loops/500-return-from-loops/ru/data.yml index 7abc7ba..88eced9 100644 --- a/modules/90-loops/500-return-from-loops/ru/data.yml +++ b/modules/90-loops/500-return-from-loops/ru/data.yml @@ -3,3 +3,6 @@ name: Возврат из циклов tips: - | [Список простых чисел](https://ru.wikipedia.org/wiki/Список_простых_чисел) +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/90-loops/550-for/ru/README.md b/modules/90-loops/550-for/ru/README.md index ec71522..e16bc21 100644 --- a/modules/90-loops/550-for/ru/README.md +++ b/modules/90-loops/550-for/ru/README.md @@ -1,28 +1,77 @@ -Цикл `while` идеален для ситуаций, когда количество итераций неизвестно заранее, например, при поиске простого числа. +С помощью цикла `while` решают любую задачу перебора, но его отличает многословность. Для `while` приходится отдельно заводить счетчик, отдельно задавать условие остановки и отдельно менять счетчик в теле цикла. Когда циклов немного, это терпимо. В реальном коде циклы встречаются на каждом шагу, и управлять тремя частями вручную утомительно, особенно когда количество повторов известно заранее. -Когда количество итераций известно, предпочтительнее использовать цикл `for`. Посмотрим реализацию переворота строки через цикл `for`: +Для таких случаев в Java есть цикл `for`. Он собирает все три части в одну строку. Посмотрим реализацию переворота строки через `for`: ```java public static String reverseString(String str) { var result = ""; - // Счетчик увеличивается с помощью инкремента. - // Об этой операции мы поговорим ниже. for (var i = 0; i < str.length(); i++) { result = str.charAt(i) + result; } return result; } + +App.reverseString("code"); // "edoc" +``` + +Запись `i++` увеличивает счетчик на единицу. Это короткая форма для `i = i + 1`, и в заголовке цикла она встречается чаще всего. Сам код можно описать словами так: + +> Цикл с индексом `i` начинается со значения `0`, повторяется, пока `i < str.length()`, и после каждого шага увеличивает `i` на единицу + +В заголовке цикла `for` ровно три части, разделенные точками с запятой: + +1. Начальное значение счетчика. Этот код выполняется один раз перед первой итерацией +2. Предикат — условие повторения. Проверяется перед каждой итерацией, точно так же как в `while` +3. Изменение счетчика. Этот код выполняется в конце каждой итерации + +В остальном принцип работы такой же, как у `while`. + +## Разбор по шагам + +Разберем, как отрабатывает цикл при вызове `reverseString("go!")`. До цикла `result` равен пустой строке: + +```text +reverseString("go!") + +до цикла: result = "" + +i=0: charAt(0) = 'g' +result = 'g' + "" = "g" + +i=1: charAt(1) = 'o' +result = 'o' + "g" = "og" + +i=2: charAt(2) = '!' +result = '!' + "og" = "!og" ``` -Этот код можно описать так: +Каждый символ берется по индексу слева направо и приклеивается к началу результата. Поэтому строка собирается в обратном порядке. -> Цикл с индексом `i` повторяется, пока `i < str.length()`, а также после каждого шага увеличивает `i` на 1 +## Сравнение с while + +Один и тот же перебор строки на двух циклах выглядит так: + +```text +for (var i = 0; i < str.length(); i++) { var i = 0; + System.out.println(str.charAt(i)); while (i < str.length()) { +} System.out.println(str.charAt(i)); + i = i + 1; +│ │ } +└── счетчик задан в одной строке └── счетчик размазан по телу +``` -В определении цикла `for` есть: +Цикл `for` держит все управление счетчиком в заголовке, поэтому тело остается чистым. Когда количество повторов понятно заранее, `for` читается лучше. Когда заранее неясно, сколько будет итераций, например при поиске простого числа, удобнее `while`. -1. Начальное значение счетчика. Этот код выполняется ровно один раз перед первой итерацией -2. Предикат — условие повторения циклов. Выполняется на каждой итерации. Точно так же как и в `while` -3. Описание изменения счетчика. Этот код выполняется в конце каждой итерации +Покажем еще пример с числовым счетчиком. Сложим числа от `0` до `9`: + +```java +var sum = 0; +for (var i = 0; i < 10; i++) { + sum = sum + i; +} + +System.out.println(sum); // => 45 +``` -В остальном принцип работы точно такой же, как у цикла `while`. +Счетчик начинается с нуля, цикл идет, пока `i < 10`, и на каждом шаге `i` растет на единицу. Внутри тела остается только накопление суммы. diff --git a/modules/90-loops/550-for/ru/data.yml b/modules/90-loops/550-for/ru/data.yml index 1985e4a..4ed8bb5 100644 --- a/modules/90-loops/550-for/ru/data.yml +++ b/modules/90-loops/550-for/ru/data.yml @@ -1,3 +1,6 @@ --- name: Цикл For tips: [] +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла.