Задание №5 ЕГЭ по информатике

Решение задания №5 ЕГЭ по информатике на Python — пошаговый разбор

Задание №5 ЕГЭ по информатике — одно из тех, где Python может сэкономить вам несколько минут и уберечь от ошибок.
Вместо того чтобы вручную перебирать числа, переводить их в двоичную систему, дописывать биты и переводить обратно, мы напишем короткую программу, которая сделает всё за нас.
В этой статье мы:
  • разберем, что нужно знать для решения;
  • напишем код, который перебирает варианты;
  • разберем код по шагам;
  • проверим на примерах из условия;
  • посмотрим на другие примеры из ЕГЭ.

1. Что нужно знать для решения

1.1. Двоичная система счисления

В задании №5 числа переводятся в двоичную систему и обратно. В Python для этого есть две встроенные функции:

Встроенные функции перевода числа в Python
Важно: bin() возвращает строку с префиксом '0b'. Чтобы получить чистую двоичную запись, нужно отрезать первые два символа: bin(N)[2:].

1.2. Почему обязательно нужно отрезать 0b

Функция bin(N) возвращает строку с префиксом '0b', например '0b10100'.

Если вы не обрежете [2:], а потом допишете что-то справа (например, + '11'), то 0b останется в её начале:

N = 20
S = bin(N)       # '0b10100'
R = S + '11'     # '0b1010011'
print(int(R,2))  # 83
В этом случае 0b стоит в начале строки, и int(R, 2) ещё работает, потому что Python допускает префикс 0b в начале.
НО если вы когда-нибудь будете дописывать биты слева, 0b окажется внутри строки, и программа упадёт с ошибкой:
N = 20
S = bin(N)       # '0b10100'
R = '11' + S     # '110b10100'  ← 0b внутри строки!
print(int(R, 2)) # ValueError: invalid literal for int() with base 2
Вывод: всегда отрезайте [2:], чтобы работать с чистой двоичной строкой без префиксов. Это надёжнее и защищает от ошибок.

2. Разбор конкретного задания

Возьмем конкретное задание из варианта ЕГЭ:

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

1. Строится двоичная запись числа N.

2. Далее эта запись обрабатывается по следующему правилу:

а) если число N делится на 5, то к этой записи дописывается справа две единицы;

б) если число N на 5 не делится, то результат целочисленного деления N на 5 переводится в двоичную систему счисления и дописывается в конец числа.

3. Полученная таким образом запись является двоичной записью искомого числа R.

4. Результат переводится в десятичную систему и выводится на экран.


Например, для исходного числа 20 = 101002 результатом является число 10100112 = 83, а для исходного числа 14 = 11102 результатом является число 1110102 = 58.


Укажите минимальное чётное число N, для которого с помощью описанного алгоритма получается число, превышающее 896.

3. Проверяем на примерах из условия

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

Пример 1: N = 20

N = 20
S = bin(N)[2:]
if N % 5 == 0:
    R = S + '11'
else:
    R = S + bin(N // 5)[2:]
print(N, S, R, int(R, 2))
Вывод: 20 10100 1010011 83

Совпадает с условием: 10100112 = 83 ✅

Пример 2: N = 14

N = 14
S = bin(N)[2:]
if N % 5 == 0:
    R = S + '11'
else:
    R = S + bin(N // 5)[2:]
print(N, S, R, int(R, 2))
Вывод: 14 1110 111010 58

Совпадает с условием: 111010₂ = 58 ✅

Можно объединить это в цикле:

for N in (20, 14):
    S = bin(N)[2:]
    if N % 5 == 0:
        R = S + '11'
    else:
        R = S + bin(N // 5)[2:]
    print(N, S, R, int(R, 2))

Вывод:

20 10100 1010011 83

14 1110 111010 58

4. Готовый код для решения

for N in range(2, 1000, 2):
    S = bin(N)[2:]
    if N % 5 == 0:
        R = S + '11'
    else:
        R = S + bin(N // 5)[2:]
    if int(R, 2) > 896:
        print(N)
        break

Результат: 56

5. Разбор кода по шагам

Шаг 1. Цикл перебора

for N in range(2, 1000, 2):
  • range(2, 1000, 2) — перебирает чётные числа от 2 до 998.
  • В условии сказано: минимальное чётное число N. Мы сразу перебираем только чётные, чтобы не тратить время на нечётные.
  • 1000 — взято с запасом (объяснение ниже).
Шаг 2. Двоичная запись числа
S = bin(N)[2:]
  • bin(N) — переводит число в двоичную строку с префиксом '0b'.
  • [2:] — отрезает первые два символа, оставляя чистую двоичную запись.
Шаг 3. Обработка по правилу
if N % 5 == 0:
    R = S + '11'
else:
    R = S + bin(N // 5)[2:]
  • Если N делится на 5, дописываем справа '11'.
  • Если не делится, делим N на 5 нацело (N // 5), переводим в двоичную систему и дописываем в конец числа (тоже справа).
Шаг 4. Проверка условия
if int(R, 2) > 896:
    print(N)
    break
  • int(R, 2) — переводит двоичную строку обратно в десятичное число, вторым аргументом указывается система счисления из которой переводим в десятичное число.
  • Если полученное число R больше 896, выводим N и завершаем цикл (нам нужно минимальное, а мы перебираем от меньшего к большему).

6. Как понять, до какого числа перебирать?

В этой задаче мы взяли range(2, 1000, 2). Откуда взялось 1000?

Вместо точных вычислений просто возьмём диапазон с большим запасом. Нам нужно получить число R > 896. Если взять N = 250, результат уже будет больше 1000 (потому что в самом худшем варианте мы допишем всего два бита в конце). А если взять N = 1000 — точно хватит.

Поэтому в цикле мы пишем range(2, 1000, 2) — это гарантирует, что мы точно найдём ответ.

Совет: Если не уверены, возьмите range(2, 2000, 2) — это всё равно выполнится за доли секунды, а запас будет ещё больше.

7. Другие примеры из ЕГЭ

Пример 1: Дописываем биты по-другому

Если число N делится на 3, то к двоичной записи дописывается '0', иначе — '1'.

for N in range(1, 1000):
    S = bin(N)[2:]
    if N % 3 == 0:
        R = S + '0'
    else:
        R = S + '1'
    if int(R, 2) > 100:
        print(N)
        break
Пример 2: Дописываем биты слева
Если число N чётное, то слева дописывается '1', иначе — '0'.
for N in range(1, 1000):
    S = bin(N)[2:]
    if N % 2 == 0:
        R = '1' + S
    else:
        R = '0' + S
    if int(R, 2) > 100:
        print(N)
        break
Пример 3: Дописываем результат арифметической операции
К двоичной записи числа N дописывается справа двоичная запись числа N % 3 (остаток от деления на 3).
for N in range(1, 1000):
    S = bin(N)[2:]
    R = S + bin(N % 3)[2:]
    if int(R, 2) > 100:
        print(N)
        break

8. Главный вывод

Задание №5 можно решить на Python всего за 5–10 строк кода. Это:

  • Быстрее, чем перебирать числа вручную.
  • Надежнее — компьютер не делает ошибок в двоичной арифметике.
  • Универсально — достаточно изменить пару строк для любого варианта.

Алгоритм решения любого задания №5:

  1. Запустить цикл for по числам N (с запасом по диапазону).
  2. Получить двоичную запись: bin(N)[2:].
  3. Применить правила из условия (дописать биты, изменить строку).
  4. Перевести обратно в десятичную систему: int(R, 2).
  5. Проверить условие, вывести ответ и завершить цикл.

И не забывайте отрезать префикс [2:] — это убережёт вас от ошибок, если в условии потребуется дописывать биты слева!

Нужна помощь с подготовкой?

Я — Олег Алексеевич, репетитор по информатике. Готовлю к ЕГЭ более 15 лет.

На своих занятиях мы:

  • разбираем структуру экзамена и стратегии решения;
  • пишем код на Python так, чтобы он работал с первого раза;
  • отрабатываем сложные задания 26 и 27 на реальных примерах.

Хотите попробовать? Запишитесь на первое занятие — познакомимся, определим ваш уровень и составим план подготовки.

Переходите на мой сайт, чтобы узнать подробности и записаться: Репетиторы рядом

Made on
Tilda