Задание 5 ЕГЭ: Алгоритмы преобразования чисел

Вычислительные алгоритмы в системах счисления. Подготовка к ЕГЭ 2025

💡 Введение

Что проверяет современное задание 5?

На сегодняшний день задание 5 ЕГЭ по информатике — это работа с вычислительным алгоритмом преобразования числа в n-ричной системе счисления.

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

⚠️ Важная особенность

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

Типичная структура задачи:

  1. Дано натуральное число N
  2. Число переводится в определённую систему счисления (обычно 2, 3, 8 или 16)
  3. К записи применяется алгоритм преобразования (добавление цифр, умножение остатка и т.д.)
  4. Результат переводится обратно в десятичную систему
  5. Нужно найти число N или R, удовлетворяющее определённым условиям

🔢 Системы счисления

Система счисления — это способ записи чисел с помощью заданного набора специальных знаков (цифр).

Двоичная

2

Цифры: 0, 1

Используется в компьютерах

Троичная

3

Цифры: 0, 1, 2

Часто в ЕГЭ

Восьмеричная

8

Цифры: 0-7

Компактная запись

Десятичная

10

Цифры: 0-9

Привычная нам

Шестнадцатеричная

16

Цифры: 0-9, A-F

Для программистов

Принцип позиционной системы

В позиционной системе счисления значение каждой цифры зависит от её позиции (разряда).

Пример: Число 125₁₀ = 1×10² + 2×10¹ + 5×10⁰

Двоичное: 101₂ = 1×2² + 0×2¹ + 1×2⁰ = 4 + 0 + 1 = 5₁₀

🐍 Теория: Python и системы счисления

Встроенные функции Python для перевода

Перевод из десятичной в другие системы

num1 = bin(124)  # '0b1111100' - двоичная
num2 = oct(124)  # '0o174'    - восьмеричная
num3 = hex(124)  # '0x7c'     - шестнадцатеричная

# Убираем префиксы (0b, 0o, 0x)
binary = bin(124)[2:]   # '1111100'
octal = oct(124)[2:]    # '174'
hexa = hex(124)[2:]     # '7c'
⚠️ Важно: Результат функций bin(), oct(), hex() — это строка с префиксом. Используйте срез [2:] для удаления префикса.

Универсальная функция перевода

Вариант 1: Результат — список цифр

def convert_to_base(n, d):
    """
    Переводит число n в систему счисления с основанием d
    
    :param n: натуральное число в десятичной системе (int)
    :param d: основание системы счисления (int)
    :return: список цифр (list)
    """
    res = []
    while n != 0:
        res.append(n % d)
        n //= d
    return res[::-1]  # Переворачиваем список

# Пример использования
print(convert_to_base(12, 2))   # [1, 1, 0, 0]
print(convert_to_base(12, 3))   # [1, 1, 0]

Вариант 2: Результат — строка (для оснований ≤ 10)

def convert_to_base_str(n, d):
    """
    Переводит число n в систему счисления с основанием d
    
    :param n: натуральное число в десятичной системе (int)
    :param d: основание системы счисления (int)
    :return: строка (str)
    """
    res = ''
    while n != 0:
        res += str(n % d)
        n //= d
    return res[::-1]  # Переворачиваем строку

# Пример использования
print(convert_to_base_str(12, 2))   # '1100'
print(convert_to_base_str(12, 3))   # '110'

Перевод из любой системы в десятичную

# Функция int() с указанием основания системы счисления
num1 = int('111', 2)   # 7  (111₂ → 10)
num2 = int('111', 3)   # 13 (111₃ → 10)
num3 = int('111', 5)   # 31 (111₅ → 10)
num4 = int('FF', 16)   # 255 (FF₁₆ → 10)

# Основание может быть от 2 до 36
💡 Совет: Функция int() очень удобна для обратного перевода из любой системы счисления в десятичную.

🎯 Методы решения задач

Метод 1: Ручное решение 📝

Когда использовать: Для понимания алгоритма, на экзамене при отсутствии доступа к компьютеру (теоретически).

Преимущества:

  • Развивает понимание систем счисления
  • Не требует программирования

Недостатки:

  • Высокий риск арифметических ошибок
  • Долго для задач с перебором
  • Сложно для больших чисел

Метод 2: Программный перебор 💻

Когда использовать: Почти всегда! Это самый надёжный и быстрый способ.

Преимущества:

  • Быстрое получение ответа
  • Минимум ошибок
  • Легко проверить несколько вариантов
  • На ЕГЭ разрешено использовать калькуляторы/компьютер

Недостатки:

  • Требует знания Python
  • Нужен доступ к компьютеру/калькулятору с Python

Общий алгоритм программного решения

  1. Прочитайте условие и поймите алгоритм преобразования
  2. Напишите функцию, которая реализует этот алгоритм
  3. Проверьте функцию на примерах из условия
  4. Организуйте перебор чисел в нужном диапазоне
  5. Примените условия из задачи (найти минимум/максимум, больше/меньше заданного и т.д.)
  6. Выведите результат

📝 Разобранные примеры задач

Задача 1: Преобразование с делением на 3

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

  1. Строится двоичная запись числа N
  2. Далее эта запись обрабатывается по следующему правилу:
    • если число N делится на 3, то в этой записи дописываются справа три последние двоичные цифры
    • если число N на 3 не делится, то остаток от деления умножается на 3, переводится в двоичную запись и дописывается в конец числа
  3. Результат переводится в десятичную систему и выводится на экран

Примеры из условия:

  • 12₁₀ = 1100₂ → 1100100₂ = 100₁₀
  • 4₁₀ = 100₂ → 10011₂ = 19₁₀

Вопрос: Укажите максимальное число R, не превышающее 170, которое может быть получено с помощью описанного алгоритма.

✅ Решение

Шаг 1: Понимаем алгоритм

  • Если N % 3 == 0: дописываем 3 последние цифры двоичной записи
  • Если N % 3 != 0: умножаем остаток на 3, переводим в двоичную и дописываем

Шаг 2: Проверка примеров вручную

Для N = 12:

  • 12₁₀ = 1100₂
  • 12 % 3 = 0 → дописываем 3 последние цифры: 1, 0, 0
  • 1100100₂ = 1×64 + 1×32 + 0×16 + 0×8 + 1×4 + 0×2 + 0×1 = 100₁₀ ✓

Для N = 4:

  • 4₁₀ = 100₂
  • 4 % 3 = 1 → остаток 1 × 3 = 3 = 11₂
  • Дописываем: 10011₂ = 16 + 2 + 1 = 19₁₀ ✓

Шаг 3: Программное решение

def algorithm(n):
    # Переводим в двоичную систему (без префикса 0b)
    binary = bin(n)[2:]
    
    if n % 3 == 0:
        # Дописываем 3 последние цифры
        binary += binary[-3:]
    else:
        # Остаток умножаем на 3 и переводим в двоичную
        remainder = n % 3
        addition = bin(remainder * 3)[2:]
        binary += addition
    
    # Переводим обратно в десятичную
    result = int(binary, 2)
    return result

# Проверяем примеры
print(algorithm(12))  # Должно быть 100
print(algorithm(4))   # Должно быть 19

# Ищем максимальное R <= 170
max_r = 0
for n in range(1, 200):
    r = algorithm(n)
    if r <= 170:
        max_r = max(max_r, r)

print(f"Ответ: {max_r}")

Ответ: 164

Объяснение: Программа перебирает все натуральные числа, применяет к ним алгоритм и находит максимальное R, которое не превышает 170.

Задача 2: Контрольные биты (чётность)

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

  1. Строится двоичная запись числа N
  2. К этой записи дописываются справа ещё два разряда по следующему правилу:
    • складываются все цифры двоичной записи, и остаток от деления суммы на 2 дописывается в конец числа (справа). Например, запись 11100 преобразуется в запись 111001
    • над этой записью производятся те же действия — справа дописывается остаток от деления суммы цифр на 2

Вопрос: Укажите минимальное число R, которое превышает 43 и может являться результатом работы алгоритма.

✅ Решение

Шаг 1: Понимаем алгоритм

  • Дважды дописываем контрольный бит (остаток от деления суммы цифр на 2)
  • Это алгоритм добавления битов чётности

Шаг 2: Проверка примера вручную

Для записи 11100:

  • Сумма цифр: 1+1+1+0+0 = 3
  • 3 % 2 = 1 → дописываем 1: 111001
  • Новая сумма: 1+1+1+0+0+1 = 4
  • 4 % 2 = 0 → дописываем 0: 1110010

Шаг 3: Программное решение

def algorithm(n):
    # Переводим в двоичную систему
    binary = bin(n)[2:]
    
    # Первое дописывание
    sum_digits = sum(int(d) for d in binary)
    parity1 = sum_digits % 2
    binary += str(parity1)
    
    # Второе дописывание
    sum_digits = sum(int(d) for d in binary)
    parity2 = sum_digits % 2
    binary += str(parity2)
    
    # Переводим обратно в десятичную
    result = int(binary, 2)
    return result

# Ищем минимальное R > 43
for n in range(1, 100):
    r = algorithm(n)
    if r > 43:
        print(f"Ответ: {r}")
        break

Ответ: 44

Проверка: n=10 → 1010₂ → сумма=2, 2%2=0 → 10100₂ → сумма=2, 2%2=0 → 101000₂ = 40 (меньше 43)
n=11 → 1011₂ → сумма=3, 3%2=1 → 10111₂ → сумма=4, 4%2=0 → 101110₂ = 46 (больше 43, но не минимальное)
Нужно проверить все варианты программой.

Задача 3: Чётность и дописывание цифр

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

  1. Строится двоичная запись числа N
  2. Далее эта запись обрабатывается по следующему правилу:
    • если число N чётное, то к этой записи дописываются две последние двоичные цифры
    • если число N нечётное, то в начало числа записывается цифра 1, а в конец числа — цифра 0
  3. Результат переводится в десятичную систему

Примеры из условия:

  • 11₁₀ = 1011₂ → 110110₂ = 54₁₀
  • 10₁₀ = 1010₂ → 101010₂ = 42₁₀

Вопрос: Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 100.

✅ Решение

Шаг 1: Понимаем алгоритм

  • Если N чётное: дописываем 2 последние цифры справа
  • Если N нечётное: добавляем 1 в начало и 0 в конец

Шаг 2: Проверка примеров

Для N = 11 (нечётное):

  • 11₁₀ = 1011₂
  • Добавляем 1 в начало: 11011₂
  • Добавляем 0 в конец: 110110₂ = 54₁₀ ✓

Для N = 10 (чётное):

  • 10₁₀ = 1010₂
  • Две последние цифры: 1, 0
  • Дописываем: 101010₂ = 42₁₀ ✓

Шаг 3: Программное решение

def algorithm(n):
    # Переводим в двоичную систему
    binary = bin(n)[2:]
    
    if n % 2 == 0:  # Чётное
        # Дописываем две последние цифры
        binary += binary[-2:]
    else:  # Нечётное
        # Добавляем 1 в начало и 0 в конец
        binary = '1' + binary + '0'
    
    # Переводим обратно в десятичную
    result = int(binary, 2)
    return result

# Проверяем примеры
print(algorithm(11))  # Должно быть 54
print(algorithm(10))  # Должно быть 42

# Ищем максимальное N, при котором R < 100
max_n = 0
for n in range(1, 100):
    r = algorithm(n)
    if r < 100:
        max_n = max(max_n, n)

print(f"Ответ: {max_n}")

Ответ: 24

Объяснение: Для N=24: 24₁₀ = 11000₂ → дописываем 00 → 1100000₂ = 96₁₀ < 100 ✓
Для N=25: 25₁₀ = 11001₂ → 1110010₂ = 114₁₀ ≥ 100 ✗

Задача 4: Минимальное R больше заданного

Условие: Алгоритм аналогичен задаче 1 (деление на 3 и дописывание цифр).

Вопрос: Укажите минимальное число R, большее 151, которое может быть получено с помощью описанного алгоритма.

✅ Решение
def algorithm(n):
    binary = bin(n)[2:]
    
    if n % 3 == 0:
        binary += binary[-3:]
    else:
        remainder = n % 3
        addition = bin(remainder * 3)[2:]
        binary += addition
    
    result = int(binary, 2)
    return result

# Ищем минимальное R > 151
for n in range(1, 200):
    r = algorithm(n)
    if r > 151:
        print(f"Ответ: {r}")
        break

Ответ: 152

Задача 5: Троичная система счисления

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

  1. Строится троичная запись числа N
  2. Далее эта запись обрабатывается по следующему правилу:
    • если число N делится на 3, то к этой записи дописываются две последние троичные цифры
    • если число N на 3 не делится, то вычисляется сумма цифр полученной троичной записи, эта сумма переводится в троичную систему счисления и дописывается в конец числа
  3. Результат переводится в десятичную систему

Примеры:

  • 11₁₀ = 102₃ → 10210₃ = 102₁₀
  • 12₁₀ = 110₃ → 11010₃ = 111₁₀

Вопрос: Укажите минимальное чётное число R, большее 220, которое может быть получено с помощью описанного алгоритма.

✅ Решение

Шаг 1: Функция перевода в троичную систему

def to_base3(n):
    """Перевод числа в троичную систему"""
    if n == 0:
        return '0'
    result = ''
    while n > 0:
        result = str(n % 3) + result
        n //= 3
    return result

def algorithm(n):
    # Переводим в троичную систему
    ternary = to_base3(n)
    
    if n % 3 == 0:
        # Дописываем две последние цифры
        ternary += ternary[-2:]
    else:
        # Вычисляем сумму цифр
        digit_sum = sum(int(d) for d in ternary)
        # Переводим сумму в троичную и дописываем
        addition = to_base3(digit_sum)
        ternary += addition
    
    # Переводим обратно в десятичную
    result = int(ternary, 3)
    return result

# Проверяем примеры
print(algorithm(11))  # Должно быть 102
print(algorithm(12))  # Должно быть 111

# Ищем минимальное чётное R > 220
for n in range(1, 300):
    r = algorithm(n)
    if r > 220 and r % 2 == 0:
        print(f"Ответ: {r}")
        break

Ответ: 222

Проверка: n=73 → 73₁₀ = 2201₃ → сумма цифр = 2+2+0+1 = 5 = 12₃ → 220112₃ = 222₁₀ ✓ (чётное)

Задача 6: Работа с трёхзначными числами

Условие: Автомат получает на вход трёхзначное число. По этому числу строится новое число по следующим правилам:

  1. Складываются первая и вторая, а также вторая и третья цифры исходного числа
  2. Полученные два числа записываются друг за другом в порядке убывания (без разделителей)

Пример: Исходное число: 348. Суммы: 3+4=7; 4+8=12. Результат: 127.

Вопрос: Укажите наименьшее число, в результате обработки которого автомат выдаст число 1412.

✅ Решение

Шаг 1: Понимаем алгоритм

  • Для числа ABC: вычисляем A+B и B+C
  • Записываем результаты в порядке убывания

Шаг 2: Анализ результата 1412

Результат 1412 означает, что две суммы дали 14 и 12 (в порядке убывания).

Значит: max(A+B, B+C) = 14 и min(A+B, B+C) = 12

Вариант 1: A+B=14, B+C=12

Из первого: A = 14-B, из второго: C = 12-B

Минимизируем число ABC, начинаем с B=5:

  • B=5: A=9, C=7 → число 957
  • B=6: A=8, C=6 → число 866
  • B=7: A=7, C=5 → число 775
  • B=8: A=6, C=4 → число 684
  • B=9: A=5, C=3 → число 593

Вариант 2: A+B=12, B+C=14

  • B=5: A=7, C=9 → число 759
  • B=6: A=6, C=8 → число 668
  • B=7: A=5, C=7 → число 577
  • B=8: A=4, C=6 → число 486
  • B=9: A=3, C=5 → число 395

Шаг 3: Программное решение

def algorithm(n):
    # Разбиваем трёхзначное число на цифры
    a = n // 100
    b = (n // 10) % 10
    c = n % 10
    
    # Вычисляем суммы
    sum1 = a + b
    sum2 = b + c
    
    # Записываем в порядке убывания
    if sum1 >= sum2:
        result = int(str(sum1) + str(sum2))
    else:
        result = int(str(sum2) + str(sum1))
    
    return result

# Ищем минимальное трёхзначное число, дающее 1412
min_num = float('inf')
for n in range(100, 1000):
    if algorithm(n) == 1412:
        min_num = min(min_num, n)

print(f"Ответ: {min_num}")

Ответ: 395

Проверка: 395 → 3+9=12, 9+5=14 → max=14, min=12 → 1412 ✓

❓ Часто задаваемые вопросы

Нажмите на вопрос, чтобы увидеть ответ:

1Можно ли использовать Python на ЕГЭ для решения задания 5?

Ответ: Да! На ЕГЭ по информатике разрешено использовать компьютер, включая среды программирования. Вы можете писать программы на Python для решения задач. Более того, это рекомендуемый подход для задания 5, так как он минимизирует ошибки и экономит время.

Однако стоит научиться решать простые примеры вручную для лучшего понимания алгоритмов.

2Как быстро перевести число из двоичной системы в десятичную?

Ответ: В Python используйте функцию int() с указанием основания системы:

binary_str = '1101'
decimal = int(binary_str, 2)  # 13

Вручную: Умножайте каждую цифру на соответствующую степень двойки и суммируйте:

1101₂ = 1×2³ + 1×2² + 0×2¹ + 1×2⁰ = 8 + 4 + 0 + 1 = 13₁₀

3Что делать, если в задаче нужна система счисления с основанием больше 10?

Ответ: Для систем с основанием до 36 Python поддерживает стандартные обозначения (A=10, B=11, ..., Z=35).

Для перевода в десятичную используйте int():

hex_num = int('1A', 16)  # 26
# A в 16-ричной = 10 в десятичной

Для перевода из десятичной в 16-ричную используйте hex():

decimal = 26
hex_str = hex(decimal)[2:]  # '1a'

Для других систем (не 2, 8, 16) используйте универсальную функцию из раздела "Теория".

4Как понять, в каком диапазоне делать перебор?

Ответ: Ориентируйтесь на условие задачи:

  • Если ищете R ≤ 170, пробуйте N от 1 до 200-300
  • Если ищете R > 220, начните с N от 1 и идите до 300-500
  • Для трёхзначных чисел: от 100 до 999

Совет: Начните с небольшого диапазона (до 100), затем расширяйте, если не находите ответ. Python работает быстро, перебор до 1000 занимает доли секунды.

5Почему результат bin() начинается с '0b'?

Ответ: Префикс '0b' указывает, что строка содержит двоичное число. Аналогично '0o' для восьмеричной и '0x' для шестнадцатеричной системы.

Эти префиксы нужны для однозначного определения системы счисления, но при обработке строки они мешают, поэтому их убирают срезом [2:]:

num = bin(10)      # '0b1010'
clean = num[2:]    # '1010'
6Как работает срез [::-1] для переворота строки?

Ответ: Срез с шагом -1 проходит по строке (или списку) от конца к началу:

s = '12345'
reversed_s = s[::-1]  # '54321'

# Эквивалентно:
# s[start:stop:step]
# s[::  -1] означает: от начала до конца с шагом -1

Это удобный способ развернуть последовательность в Python.

7Что означает "остаток от деления" в задачах?

Ответ: Остаток от деления — это то, что остаётся после деления нацело.

Примеры:

  • 10 ÷ 3 = 3 (остаток 1), потому что 3×3 = 9, и 10-9 = 1
  • 17 ÷ 5 = 3 (остаток 2), потому что 5×3 = 15, и 17-15 = 2

В Python: используйте оператор %

print(10 % 3)  # 1
print(17 % 5)  # 2
print(12 % 3)  # 0 (делится нацело)
8Как проверить, делится ли число на 3?

Ответ: Используйте оператор остатка от деления %:

if n % 3 == 0:
    print("Делится на 3")
else:
    print("Не делится на 3")

Если остаток равен 0, число делится нацело.

Альтернативный способ проверки: Сумма цифр числа должна делиться на 3. Например, 123: 1+2+3=6, 6÷3=2, значит 123 делится на 3.

💡 Советы и рекомендации

Совет 1: Всегда проверяйте примеры из условия

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

Совет 2: Используйте функции для переиспользования кода

Оформите алгоритм преобразования в отдельную функцию. Это сделает код чище и позволит легко проверять разные числа.

Совет 3: Не бойтесь перебора

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

Совет 4: Обратите внимание на формулировку вопроса

Различайте:

  • "Максимальное R, не превышающее X" — R ≤ X
  • "Минимальное R, превышающее X" — R > X
  • "Минимальное R, большее или равное X" — R ≥ X
  • "Максимальное N, при котором R меньше X" — R < X

Совет 5: Изучите стандартные приёмы

Типичные операции в задачах:

  • Дописывание последних k цифр
  • Умножение остатка от деления
  • Добавление битов чётности (контрольных битов)
  • Вычисление суммы цифр записи
  • Добавление цифр в начало/конец

Совет 6: Готовьте шаблоны кода

Подготовьте заранее функции для:

  • Перевода числа в произвольную систему счисления
  • Перевода из произвольной системы в десятичную
  • Стандартного перебора

Это сэкономит время на экзамене.

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

  • Забыли убрать префикс: Используйте [2:] после bin(), oct(), hex()
  • Неправильный порядок операций: Внимательно читайте последовательность действий в алгоритме
  • Путаница с индексами: Помните, что binary[-3:] берёт последние 3 символа
  • Неверный диапазон перебора: Если не находите ответ, расширьте диапазон
  • Забыли про условия: "Чётное число R" означает проверку r % 2 == 0

Совет 7: Практикуйтесь на разных типах задач

Задание 5 может содержать задачи с двоичной, троичной, восьмеричной системами. Потренируйтесь на каждом типе, чтобы быть готовым к любому варианту на экзамене.

🎓 Заключение

Задание 5 ЕГЭ по информатике в современном формате требует:

  • Понимания систем счисления и принципов перевода чисел
  • Умения анализировать алгоритмы преобразования
  • Навыков программирования на Python (рекомендуется)
  • Внимательности при чтении условий

Ключ к успеху: Программный перебор + понимание алгоритма + проверка на примерах = правильный ответ!

© 2025 Обучающие материалы для школьников по информатике

Задание 5: Алгоритмы преобразования чисел в системах счисления