Ветвления и циклы: идея управления ходом алгоритма

Знакомимся с двумя главными приёмами, которые делают алгоритмы по-настоящему умными: ветвлением (выбором) и циклом (повтором).

Ветвление — выбор одного из путей в зависимости от условия. Цикл — повторение действий несколько раз.

Линейных алгоритмов мало для жизни

Линейный алгоритм хорош, но слишком прямолинеен: он всегда делает одно и то же. А жизнь полна выборов и повторов. «Если идёт дождь — возьми зонт, иначе не бери» — тут нужен выбор. «Отожмись 10 раз» — тут нужен повтор. Эти два приёма — ветвление и цикл — превращают простые алгоритмы в гибкие и мощные. Познакомимся с ними на уровне идеи, а в следующем разделе запрограммируем по-настоящему.

Ветвление: алгоритм делает выбор

Ветвление — это развилка. Алгоритм проверяет некоторое условие и в зависимости от ответа («да» или «нет») идёт по одному из двух путей. В блок-схеме это тот самый ромб с двумя стрелками.

Пример из жизни: «Если оценка за контрольную больше 3 — порадуйся, иначе — подтяни тему». Условие здесь — «оценка больше 3». Если оно верно, выполняется одна ветка, если нет — другая.

Условия строят с помощью сравнений: больше, меньше, равно. Бывает и неполное ветвление — когда есть только ветка «да», а если условие ложно, ничего не происходит: «Если на улице холодно — надень шапку».

Ветвление позволяет алгоритму вести себя по-разному в зависимости от данных. Без него программа была бы как поезд по одной колее.

Цикл: алгоритм повторяет действия

Цикл — это повторение одних и тех же действий несколько раз. Вместо того чтобы писать «сделай шаг» сто раз, мы говорим «повтори шаг 100 раз». Циклы бывают двух типов по тому, как задаётся число повторов:

• Цикл с известным числом повторов. Мы заранее знаем, сколько раз повторить: «отожмись 10 раз», «выведи числа от 1 до 5».
• Цикл с условием. Повторяем, пока выполняется условие: «прыгай, пока не устанешь», «дели число на 2, пока оно больше 1».

Цикл — это огромная экономия. Компьютер может повторить действие миллион раз, не уставая и не ошибаясь, — а нам достаточно описать его один раз.

Вложенность: циклы и ветвления внутри друг друга

Настоящая мощь появляется, когда эти конструкции вкладывают одну в другую. Цикл может содержать внутри ветвление — мы как раз это увидим в примере ниже, где для каждого числа из цикла проверяется условие «чётное или нет». А ветвление может содержать цикл: «если пользователь вошёл в игру, то повторяй показ уровней, пока он не выйдет». Бывают и циклы внутри циклов: чтобы заполнить таблицу, внешний цикл идёт по строкам, а внутренний — по столбцам каждой строки. Из этих простых «кирпичиков» — следования (шаги по порядку), ветвления (выбор) и цикла (повтор) — можно собрать алгоритм любой сложности. Это доказанный математический факт: трёх базовых конструкций достаточно для решения вообще любой алгоритмической задачи. Так что, освоив их, ты получаешь универсальный конструктор, из которого строятся все программы на свете — от калькулятора до поисковика.

Опасность: бесконечный цикл

У цикла с условием есть коварная ловушка. Если условие никогда не станет ложным, цикл будет крутиться вечно — это бесконечный цикл, и он нарушает свойство конечности алгоритма. «Прыгай, пока 2 больше 1» — будешь прыгать вечно, ведь 2 всегда больше 1. Поэтому внутри цикла обязательно должно что-то меняться в сторону завершения. Об этом нужно помнить, и мы ещё вернёмся к этому, когда будем писать настоящие циклы.

Попробуй сам

Соединим обе идеи в одном алгоритме: цикл переберёт числа от 1 до 10, а ветвление для каждого решит — чётное оно или нечётное. Не вникай пока в синтаксис, лови саму идею «повтори и выбери».

# Цикл: повторяем для чисел от 1 до 10
for chislo in range(1, 11):
    # Ветвление: выбираем, что вывести
    if chislo % 2 == 0:
        print(chislo, "— чётное")
    else:
        print(chislo, "— нечётное")

Вывод:

1 — нечётное
2 — чётное
3 — нечётное
4 — чётное
5 — нечётное
6 — чётное
7 — нечётное
8 — чётное
9 — нечётное
10 — чётное

За четыре строчки кода мы проверили десять чисел! Поменяй range(1, 11) на range(1, 21) — и алгоритм проверит уже двадцать чисел, а кода больше не станет. Вот зачем нужны циклы. В следующем разделе мы разберём, как это устроено, по косточкам.

Ещё пример: цикл с условием

Выше мы видели цикл с известным числом повторов. А теперь — цикл с условием: он повторяется, пока условие истинно, и заранее число шагов неизвестно. Возьмём наглядную задачу: будем делить число на 2, пока оно больше 1, и считать, сколько раз делили. Это, между прочим, и есть перевод числа «в биты» — тот самый, что мы делали в кодировании.

chislo = 100
shagov = 0

# Повторяем, ПОКА число больше 1
while chislo > 1:
    chislo = chislo // 2     # делим пополам (целочисленно)
    shagov = shagov + 1
    print("После деления:", chislo)

print("Всего делений:", shagov)

Вывод:

После деления: 50
После деления: 25
После деления: 12
После деления: 6
После деления: 3
После деления: 1
Всего делений: 6

Сколько раз пришлось делить — заранее неочевидно, и в этом вся суть цикла с условием: он работает «пока надо», а не фиксированное число раз. Обрати внимание на строку chislo = chislo // 2 — именно она приближает условие к ложному. Убери её мысленно — и цикл стал бы бесконечным! Поменяй chislo на 1000 и посмотри, сколько делений понадобится. Заодно подумай: а где мы уже встречали такое «деление пополам»? Верно — в игре «угадай число» из самого первого раздела. Идеи в информатике любят возвращаться.

Частые ошибки

• Думать, что цикл всегда выполняется фиксированное число раз. Цикл с условием крутится, пока условие истинно, — заранее число повторов может быть неизвестно.
• Забывать менять условие внутри цикла. Иначе получится бесконечный цикл.
• Путать полное и неполное ветвление. В неполном есть только ветка «да», ветки «иначе» нет.

Запомни

• Ветвление — выбор пути по условию; бывает полным (да/нет) и неполным (только да).
• Цикл — повторение действий; бывает с известным числом повторов и с условием.
• Цикл с условием может стать бесконечным, если условие никогда не станет ложным.
• Ветвления и циклы делают алгоритмы гибкими и мощными.