Справочник — Типовые приёмы работы с for

Здесь собраны приёмы, которые часто встречаются в задачах с for: выбор шага, поиск делителя, досрочный выход, поиск крайних значений и сравнение соседних вводов. Выберите подходящий приём, затем проследите, что хранит каждая переменная после очередного повторения.

Изменение шага

Чтобы вывести чётные числа от 0 до 98, можно сразу увеличивать i на 2:

for (int i = 0; i < 100; i += 2)
{
    Console.WriteLine(i);
}

Проверять i % 2 == 0 внутри тела уже не нужно: заголовок сразу задаёт только нужные значения.

Аналогично можно перебирать числа, кратные трём:

for (int i = 0; i < 100; i += 3)
{
    Console.WriteLine(i);
}

Здесь последним будет выведено 99. Начальное значение, шаг и граница вместе определяют, какие числа пройдёт цикл.

Проверка простого числа: начало решения

Простое число — целое число больше 1, которое делится без остатка только на 1 и на само себя. Поэтому возможные дополнительные делители начинаем проверять с 2:

int n = 79;

for (int i = 2; i < n; i++)
{
    if (n % i == 0)
    {
        Console.WriteLine("Число не простое");
    }
}

Это пока лишь часть решения. Для 79 программа вообще ничего не выведет. Если у числа несколько делителей, она выведет одно и то же сообщение несколько раз. Нам нужен один итоговый ответ и возможность прекратить проверку после найденного делителя.

Логический флаг и break

Флаг хранит состояние проверки. Вначале допускаем, что число простое, если оно не меньше 2. Найденный делитель меняет флаг на false:

int n = 79;
bool isPrime = n >= 2;

for (int i = 2; i < n; i++)
{
    if (n % i == 0)
    {
        isPrime = false;
        break;
    }
}

if (isPrime)
    Console.WriteLine("Число простое");
else
    Console.WriteLine("Число не простое");

• break завершает цикл, как только дальнейшая проверка уже не нужна.
• if (isPrime) использует готовое логическое значение; сравнение == true излишне.
• Начальное выражение n >= 2 не позволяет ошибочно объявить простыми 1, 0 или отрицательные числа.

Поиск минимума и максимума

Частая ошибка — начать поиск минимума с 0. Если все введённые числа положительные, 0 ошибочно останется минимумом, хотя его не вводили.

Для четырёх целых чисел можно начать с наибольшего значения типа int:

int min = int.MaxValue;

for (int i = 0; i < 4; i++)
{
    int num = int.Parse(Console.ReadLine());

    if (num < min)
        min = num;
}

Console.WriteLine(min);

Для максимума меняем начальное значение и направление сравнения:

int max = int.MinValue;

for (int i = 0; i < 4; i++)
{
    int num = int.Parse(Console.ReadLine());

    if (num > max)
        max = num;
}

Console.WriteLine(max);

После каждого повторения переменная хранит минимум или максимум всех чисел, которые уже введены. Другой способ инициализации — считать первый ввод до цикла и использовать его как начальное крайнее значение.

Дополнительное значение: где встретился минимум

Иногда нужен не только минимум, но и номер его ввода. Сохраняйте оба значения вместе:

int min = int.MaxValue;
int minIndex = -1;

for (int i = 0; i < 10; i++)
{
    int num = int.Parse(Console.ReadLine());

    if (i == 0 || num < min)
    {
        min = num;
        minIndex = i + 1; // Номер ввода при нумерации с 1.
    }
}

Console.WriteLine("Минимум: " + min);
Console.WriteLine("Номер ввода: " + minIndex);

Условие i == 0 гарантирует сохранение первого номера даже тогда, когда первым введено int.MaxValue. При следующих вводах обновление происходит только для меньшего числа, поэтому при повторяющемся минимуме остаётся его первое появление.

Так же можно сохранять имя участника с лучшим результатом или день с самой высокой температурой: обновляйте связанные данные в одном блоке.

Сохранение предыдущего ввода

Чтобы сравнивать соседние числа, нужно помнить предыдущее. В следующем примере вводятся десять чисел, и подсчитываются изменения между соседями:

int previous = int.Parse(Console.ReadLine());
int changes = 0;

for (int i = 1; i < 10; i++)
{
    int current = int.Parse(Console.ReadLine());

    if (current != previous)
        changes++;

    previous = current;
}

Console.WriteLine("Количество изменений: " + changes);

Один ввод выполнен до цикла, поэтому внутри остаётся девять вводов. После сравнения текущее число записывается в previous; на следующем повторении это уже будет предыдущее число.

Сначала сравнивайте, затем обновляйте previous. Иначе оба значения окажутся одинаковыми ещё до проверки.

Проверка строго возрастающей последовательности

Последовательность строго возрастает, если каждое следующее число больше предыдущего. Сохраним предыдущее число и добавим флаг:

int previous = int.Parse(Console.ReadLine());
bool rising = true;

for (int i = 1; i < 5; i++)
{
    int current = int.Parse(Console.ReadLine());

    if (current <= previous)
        rising = false;

    previous = current;
}

if (rising)
    Console.WriteLine("Последовательность строго возрастает");
else
    Console.WriteLine("Последовательность не является строго возрастающей");

Флаг означает «до сих пор все соседние пары подходят». Когда найдено нарушение, он остаётся false: последующие подходящие пары уже не исправят всю последовательность.

Равные соседние числа тоже нарушают строгое возрастание. Программа продолжает считывать все пять чисел даже после обнаружения нарушения.

Заголовок цикла должен помогать читать программу

В for можно использовать несколько переменных, пропускать части заголовка и изменять индекс в теле. Но для обычного повторения действий удобнее сохранять простой заголовок, по которому видно число повторений:

int count = 5;
for (int i = 0; i < count; i++)
{
    Console.WriteLine(i);
}

Если менять i ещё и внутри тела, читателю придётся учитывать скрытое в нём изменение. Выбирайте такую форму, по которой легко понять, какие значения перебираются и когда цикл закончится.

Выбор приёма

Дальше

• Практика 4.2 — Счётчики, накопители, крайние значения и трассировка
• Практика 4.5 — Соседние значения и тройки с решениями
• Повторить основы цикла for
• Содержание курса