Задание 5 ЕГЭ по информатике 2027 — алгоритм над двоичной записью и наименьшее R

Задание 5 в демоверсии 2027 года — автомат над двоичной записью: по числу N строится новое число R, и спрашивают наименьшее R, превышающее 95. Ответ — 100, и получить его можно за минуту перебором на Python. Но только если не останавливаться на первом подходящем числе: R не растёт вместе с N, и перебор с break выдаёт 115. Ниже — правило из демо, таблица N → R, объяснение, почему результат «скачет», код и вариации вопроса.

В демоверсии 2026 был автомат того же типа, с другим правилом дописывания цифр, а вопрос шёл в обратную сторону — наименьшее N, при котором R не меньше 200. Задачи, где исполнитель применял команды к числу, а решали обратным ходом, разобраны в статье о задании 5. Техника обратного хода там по-прежнему полезна для задач из сборников, но на демоверсии 2027 она не нужна.

Условие демоверсии 2027

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R:

1. Строится двоичная запись числа N.
2. Запись обрабатывается по правилу: если N чётное, то к записи справа и слева дописываются по две единицы; если N нечётное, то в конец записи дописываются два нуля, а в начало — единица. Полученная запись (в ней на три или четыре разряда больше) — двоичная запись числа R.
3. Результат переводится в десятичную систему и выводится на экран.

Примеры из условия: для N = 13 = 1101₂ результат 1110100₂ = 116, для N = 6 = 110₂ результат 1111011₂ = 123. Вопрос: укажите наименьшее число R, превышающее 95, которое может быть результатом работы алгоритма. Ответ ФИПИ: 100.

Таблица N → R

Правило проще всего увидеть на первых числах. Чётные и нечётные N идут по разным веткам, и это видно по результатам.

N	Двоичная запись	Правило	Запись R	R
1	1	нечётное: 1 … 00	1100	12
2	10	чётное: 11 … 11	111011	59
3	11	нечётное	11100	28
4	100	чётное	1110011	115
5	101	нечётное	110100	52
6	110	чётное	1111011	123
7	111	нечётное	111100	60
8	1000	чётное	11100011	227
9	1001	нечётное	1100100	100
10	1010	чётное	11101011	235
11	1011	нечётное	1101100	108
12	1100	чётное	11110011	243

Результаты больше 95: 115 (N = 4), 123 (N = 6), 227 (N = 8), 100 (N = 9), 235 (N = 10), 108 (N = 11), 243 (N = 12). Наименьший из них — 100, он появляется при N = 9. А первый по порядку N — 115 при N = 4. Кто перебирает N подряд и останавливается на первом результате больше 95, получает 115 и теряет балл.

Почему R «скачет»

Дописать единицу слева к k-разрядной записи — значит прибавить 2^k. Дописать две цифры справа — умножить на 4 и прибавить значение этих цифр. Отсюда две формулы:

N	Запись R	Формула
чётное	11 + запись + 11	R = 4N + 3 + 3 · 2^(k+2)
нечётное	1 + запись + 00	R = 4N + 2^(k+2)

где k — число разрядов в двоичной записи N. Для чётных N слева стоят две единицы, и слагаемое 3 · 2^(k+2) делает результат заметно больше, чем у соседнего нечётного N с одной единицей слева. Поэтому последовательность R немонотонна — то растёт, то падает: N = 4 даёт 115, а N = 9 — только 100. Любое задание этой формы устроено так же, и именно поэтому ответ ищут как минимум по множеству, а не как первый подходящий.

Решение на Python

def rule(n):
    s = bin(n)[2:]               # двоичная запись без приставки 0b
    if n % 2 == 0:
        s = "11" + s + "11"
    else:
        s = "1" + s + "00"
    return int(s, 2)             # обратно в десятичную

X = 95
results = []
for n in range(1, 1000):
    r = rule(n)
    if r > X:
        results.append(r)

print(min(results))              # 100

Три детали, на которых держится код. Срез [2:] убирает приставку 0b — без него нуль из приставки попадёт в запись. Функция int(s, 2) переводит строку из нулей и единиц обратно в число. И последняя строка — min по списку всех подходящих R, а не break в цикле.

Граница перебора 1000 взята с запасом: запись R длиннее записи N на три-четыре разряда, значит R не меньше 8N, и для R около ста хватило бы N до пятнадцати. Запас ничего не стоит, а пустой results — верный признак, что граница мала и min упадёт на пустом списке.

Чтобы увидеть ловушку, замени последние строки:

for n in range(1, 1000):
    if rule(n) > X:
        print(n, rule(n))        # 4 115
        break

Так напечатается 115 — первый результат по порядку N, но не наименьший.

Ещё один пример с другим правилом

Правило: если N чётное, слева к двоичной записи дописывается 10, а справа 0; если N нечётное, слева дописывается 11, а справа 10. Для N = 7 = 111₂ получается 1111110₂ = 126, для N = 20 = 10100₂ — 10101000₂ = 168. Вопрос: наименьшее R, превышающее 138.

Меняется только функция rule:

def rule(n):
    s = bin(n)[2:]
    if n % 2 == 0:
        s = "10" + s + "0"
    else:
        s = "11" + s + "10"
    return int(s, 2)

X = 138
results = [rule(n) for n in range(1, 1000) if rule(n) > X]
print(min(results))                  # 160

Ответ — 160. А первый по порядку N результат больше 138 равен 230: разрыв с правильным ответом ещё больше, чем в демоверсии. Правило другое, ловушка та же, код тот же.

Вариации вопроса

Вопрос	Последняя строка
Наименьшее R, превышающее X	min(r for r in results) при условии r > X
Наибольшее R, не превышающее X	max(r for r in results) при условии r <= X
Наименьшее N, при котором R в отрезке [A; B]	собирать пары (n, r) и взять n первой пары с подходящим r
Сколько различных R на отрезке	len(set(r for r in results)) при условии A <= r <= B

Для «наименьшего N» перебор по возрастанию N как раз годится — первая подходящая пара и есть ответ. Путаница возникает, когда спрашивают про R, а перебирают по N: это разные порядки, и для R нужен min.

В сборниках прошлых лет встречаются правила над восьмеричной и троичной записью: для них вместо bin берут oct или свою функцию перевода, а обратно — int(s, 8) и int(s, 3). Переводы между системами счисления разобраны в статье о задании 14.

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

Остановка на первом подходящем R

Самая дорогая ошибка формы 2027: break на первом R > X даёт 115 вместо 100. Собирай все подходящие результаты и бери минимум.

Приставка 0b в записи

bin(13) возвращает строку '0b1101'. Если не отрезать 0b, дописанные цифры встанут вокруг приставки, и int(s, 2) упадёт или посчитает не то.

Перепутаны ветки чётности

В демо чётное число получает единицы с обеих сторон, нечётное — единицу слева и нули справа. Перепутанные ветки дают правдоподобные, но неверные результаты. Проверь функцию на примерах из условия: 13 → 116 и 6 → 123.

Перевод обратно не в ту систему

int(s, 2) для двоичной записи. Ошибка int(s) без основания прочитает строку 1100100 как число один миллион сто тысяч сто.

Мала граница перебора

Если граница меньше, чем нужно, список ответов пуст и min падает с ошибкой. Для «наименьшего R, превышающего X» хватает перебора N до X; удвоить границу дешевле, чем потерять балл.

Подборка ошибок по всем номерам — в статье Типичные ошибки на ЕГЭ по информатике.

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

Этап	Время
Перенести правило в функцию rule	1 мин
Проверить функцию на примерах из условия	30 сек
Запустить перебор с min	30 сек
Итого	2–3 мин

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

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

1. Реши пять заданий этой формы с разными правилами — дописывание справа, слева, вычёркивание цифр, сумма цифр. Функция rule меняется, остальной код — нет.
2. Для каждого построй таблицу N → R на первых десяти числах и найди ответ руками, потом сверь с кодом.
3. Один раз специально реши через break и увидь неверный ответ — после этого рука сама потянется к min.
4. Прогони шаблон на правилах с другими основаниями (oct, троичная), чтобы не зависеть от bin.

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

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

Задание 5 в 2027 году — правило над двоичной записью и вопрос «наименьшее R, превышающее X». R не растёт вместе с N, поэтому решение — перебор всех N до запаса, список подходящих R и min, без break. На демоверсии ответ 100 при N = 9, а первый по порядку результат 115 — ловушка.

Задания 5 в форме 2027 года с автопроверкой есть в TuteMe: в каждом X подобран так, что перебор с break даёт неверный ответ.

Попробовать бесплатно →