Задание 22 ЕГЭ по информатике — анализ программы с циклами

О чём задание

Задание 22 проверяет, умеешь ли ты читать чужую программу с циклом и условиями и предсказывать её поведение на разных входах. В условии дана короткая программа (обычно 5-15 строк) на Python или Паскале — чаще всего с циклом while, в теле которого изменяется переменная n (или x), и финальным if, который определяет «хороший» ли получился результат.

Типовые формулировки:

• «Сколько существует натуральных чисел x из отрезка [A, B], для которых программа выведет YES?»
• «Найдите наименьшее x, при котором программа выведет заданное число.»
• «Найдите наибольшее x из диапазона, при котором ответ программы больше Y.»

С 2026 года в КЕГЭ 27 заданий, 235 минут и 29 первичных баллов; задание 22 стоит 1 балл и относится к повышенному уровню. Полный список изменений этого года — в статье ЕГЭ по информатике 2026: что изменилось.

Почему с приходом КЕГЭ оно стало проще

До 2021 года на бумажном экзамене ты был обязан вручную трассировать программу, считая каждый шаг цикла. Ошибиться можно было на любом инкременте. Сейчас всё изменилось: у тебя есть Python под рукой, и за 2-3 минуты можно написать перебор, который сделает всю работу за тебя.

Поэтому основной подход к заданию 22 на КЕГЭ — это brute force. Ручной анализ остаётся запасным вариантом на случай, когда перебор не влезает в разумное время или когда нужно быстро проверить ответ.

Два подхода к задаче

Подход 1: brute force на Python

Надёжность — 95%+. Работает на любой задаче, где диапазон x укладывается в 10^6-10^7 значений.

Алгоритм:

1. Переписываешь программу из условия как функцию от x, чтобы она возвращала True/False или финальное значение.
2. Обёртываешь в цикл for x in range(A, B+1):.
3. Собираешь все x, удовлетворяющие условию, в список. Или считаешь count, или берёшь min/max.
4. Печатаешь ответ.

Подход 2: ручной анализ

Нужен, когда программа очень короткая (2-3 строки) и ты хочешь сэкономить время, или когда диапазон огромный. Ручной анализ требует выделить инвариант цикла — величину, которая на каждом шаге меняется предсказуемо. Например: «на каждой итерации n делится на 10, значит цикл сработает столько раз, сколько цифр в x».

На экзамене я рекомендую почти всегда идти через брутфорс. Ручной анализ — это страховка и инструмент для самопроверки.

Разбор задачи 1: сумма цифр

Условие. Дана программа:

s = 0
n = x
while n > 0:
    s = s + n % 10
    n = n // 10
if s > 20:
    print("YES")

Сколько существует натуральных x из отрезка [1, 10000], для которых программа выведет YES?

Что делает программа

Посимвольно: берёт n = x, в цикле обрубает последнюю цифру (n // 10) и прибавляет её к сумме s. В итоге s — это сумма цифр числа x. Условие s > 20 означает: сумма цифр больше 20.

Пример: x = 9999 → s = 36 → YES. x = 100 → s = 1 → NO.

Решение брутфорсом

На КЕГЭ переписываешь прямо из условия:

count = 0
for x in range(1, 10001):
    s = 0
    n = x
    while n > 0:
        s = s + n % 10
        n = n // 10
    if s > 20:
        count += 1
print(count)

Запускаешь — получаешь ответ. Код работает мгновенно: 10000 итераций с внутренним циклом максимум 5 шагов (5 цифр в числе).

Ручная проверка

Для диапазона [1, 10000]:

• 1, 2, 3 цифры — максимальная сумма 9+9+9 = 27, но только для 999. Считать легко, но долго.
• 4 цифры — максимум 36, сумма > 20 встречается часто.
• 5 цифр — только число 10000, сумма = 1 < 20.

Если хочешь перестраховаться — прогони код ещё раз с другим диапазоном и сверь. Но в реальной сдаче просто записывай ответ из консоли.

Разбор задачи 2: наибольшее x

Условие. Дана программа:

n = x
k = 0
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = n * 3 + 1
    k = k + 1
print(k)

Найдите наибольшее x ≤ 1000, при котором программа выведет k = 20.

Что делает программа

Это классическая гипотеза Коллатца: если n чётное — делим пополам, если нечётное — умножаем на 3 и прибавляем 1. Считаем, за сколько шагов добрались до 1. Возвращаем количество шагов.

Известно, что для всех x ≤ 10^18 программа заканчивается (гипотеза проверена экспериментально), но математически не доказана. На экзамене тебя это не должно волновать — просто запускай перебор.

Решение

def collatz(x):
    n = x
    k = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = n * 3 + 1
        k += 1
    return k

best = -1
for x in range(1, 1001):
    if collatz(x) == 20:
        best = x
print(best)

Почему best = -1 изначально? Чтобы не пропустить случай, когда таких x вообще нет. Если после цикла best остался -1, значит ответ — что таких x не существует (и в условии обычно это отметят).

Альтернативная форма: все подходящие x

Если бы в условии просили количество, код меняется минимально:

answers = []
for x in range(1, 1001):
    if collatz(x) == 20:
        answers.append(x)
print(len(answers), max(answers), min(answers))

Распечатай сразу и len, и max, и min — часто это экономит время, если формулировка окажется двоякой.

Шаблон, который ты должен помнить

Почти все задачи 22 укладываются в этот каркас:

result = []  # или 0, или -1, или 10**9 — зависит от типа ответа
for x in range(A, B + 1):
    # шаг 1: скопировать тело программы из условия
    # заменить входное значение на x
    n = x
    s = 0
    # ... (циклы и условия из задачи)
    # шаг 2: проверить условие
    if <условие из задачи>:
        result.append(x)  # или result += 1, или result = min(result, x)

# шаг 3: вывести нужный тип ответа
print(len(result))      # если спросили «сколько»
print(min(result))      # если спросили «наименьшее»
print(max(result))      # если спросили «наибольшее»

Разучи его до автоматизма. На экзамене ты просто подставляешь чужой код в середину и меняешь финальный print.

Таблица типов вопросов и что выводить

Формулировка в условии	Что выводить
Сколько существует x...	len(result)
Наибольшее значение x...	max(result)
Наименьшее значение x...	min(result)
Сумма всех x...	sum(result)
Среднее арифметическое...	sum(result) / len(result)
Произведение всех x, выведенных программой	from math import prod; prod(result)

В 9 случаях из 10 это будет len, min или max. Остальные варианты встречаются, но реже.

Типичные ошибки

1. Перевёл условие программы с ошибкой

Самая массовая беда. В условии написано n % 2 == 0 (чётность), ты переписываешь n // 2 == 0 (другая проверка!). Особенно легко ошибиться, если оригинал на Паскале, где mod и div легко перепутать.

Как лечить: после написания кода прогоняй его на одном конкретном x, для которого ты можешь в уме предсказать результат. Если ответы совпали — код переписан верно.

2. Не тот диапазон перебора

Условие: «натуральные x от A до B». В Python это range(A, B + 1) — именно B + 1, иначе ты теряешь правую границу. А если написано «x из отрезка [0, B]» — то range(0, B + 1), не забывай про ноль.

Натуральные числа в российской традиции — это 1, 2, 3, ... (без нуля). В некоторых задачах используется 0 — смотри внимательно.

3. Смешал // и /

// — целочисленное деление (результат int), / — обычное деление (результат float). В задачах 22 почти всегда нужно //. Если случайно написать /, цикл превратится в бесконечный или даст неверный результат.

4. Забыл сбросить переменные на каждой итерации

Если внутри цикла по x есть счётчик s, k, flag — он должен инициализироваться заново для каждого x. Типичный ляп:

s = 0               # ошибка: счётчик общий!
count = 0
for x in range(1, 10001):
    n = x
    while n > 0:
        s += n % 10  # s накапливается со всех x
        n //= 10
    if s > 20:
        count += 1

Правильно — инициализация s = 0 внутри цикла по x.

5. Ответ сливается с отладочным выводом

Ты написал print(x, s) для проверки, забыл убрать, отправил код с лишней выдачей. На бланке ответов запишется не то число. Перед тем как переписывать ответ — убедись, что в консоли одна строка с финальным числом.

Работа с большими диапазонами

Если в условии x от 1 до 10^7 — брутфорс за пару секунд справится. От 1 до 10^8 — уже десятки секунд, но терпимо. От 10^9 — нужно думать.

Ускорения:

• Вынеси тело цикла в отдельную функцию и не модифицируй x напрямую — копируй в n.
• Используй break, как только условие выполнилось (для min — сразу вернуть x, для max — прерывать нельзя, иди до конца).
• Для чисто арифметических задач рассмотри ручной анализ: возможно, цикл можно свернуть в формулу.

На практике диапазоны, не укладывающиеся в брутфорс, в задании 22 встречаются один раз на 100 вариантов. Не переживай заранее.

Тайминг на экзамене

Этап	Время
Прочитать условие, понять, что программа делает	1-2 мин
Написать перебор на Python	2-3 мин
Запустить, проверить на 1-2 контрольных x	1-2 мин
Выписать ответ на бланк	30 сек
Итого	5-8 мин

Если уложился в 5 минут — молодец, иди дальше. Если за 10 минут ничего не сошлось — пометь задание звёздочкой и возвращайся в конце. Оно стоит 1 балл, а впереди ещё задания 23, 26, 27, каждое из которых может дать больше.

Как тренироваться

1. Возьми банк ФИПИ и реши 20 задач 22 подряд, используя шаблон выше. Цель — довести написание перебора до 2 минут «с ходу».
2. Параллельно делай ручной анализ тех же задач. Это поможет видеть паттерны (сумма цифр, количество цифр, числа Фибоначчи, Коллатц).
3. Отслеживай ошибки в дневнике: «перепутал // и /», «забыл границу диапазона» — через месяц ты увидишь, на каких шаблонных ошибках ты теряешь баллы. Подробнее о системе учёта ошибок — в статье Типичные ошибки на ЕГЭ по информатике.
4. Периодически решай без Python, на листочке. Это тренирует фундамент и помогает, если вдруг забарахлит техника. Хотя по регламенту тебе сразу выдадут резервный компьютер, психологически надёжнее знать, что ты и так справишься.

Что учить, чего не учить

Не нужно разбирать исходники алгоритмов CPython или учить тонкости for-else. Для задания 22 достаточно:

• циклы while и for с range;
• арифметика целых: %, //, **;
• условия if/elif/else;
• списки: append, min, max, sum, len.

Всё. Это 30 минут чтения документации плюс практика.

Связанные задания

Задание 22 тематически связано с блоком программирования и часто тренируется в паре с:

• Задание 6 ЕГЭ по информатике — анализ работы черепашки, похожая логика «проследи исполнение».
• Задание 25 — поиск делителей — тоже брутфорс на Python.
• Задание 23 — следующий логический шаг, динамическое программирование.

Если ты только начинаешь и ещё не уверен в базе Python — начни с плана Подготовка к ЕГЭ по информатике с нуля, а затем вернись к задачам 22-25.

Короткий итог

Задание 22 — одно из самых «честных» в КЕГЭ: у тебя есть точный текст программы, ты его переписываешь в Python и запускаешь. Никаких хитрых математических уловок. Всё, что нужно — это аккуратность в переводе кода и дисциплина при проверке границ.

Держи в голове шаблон с for x in range(A, B + 1), разбирай 5-10 задач в неделю из банка ФИПИ, и к экзамену задание 22 превратится в гарантированный балл за 5 минут.