1. Введение

В задании №5 исполнитель получает натуральное число N и по описанному алгоритму строит новое число R.

Обычно нужно найти:

  • минимальное или максимальное N;
  • количество подходящих N;
  • значение R.

Задание проверяет умение:

  • переводить число в нужную систему счисления и обратно;
  • обрабатывать запись числа как строку;
  • точно переносить ветвление «если — иначе» в код;
  • перебирать значения N в правильных границах;
  • различать исходное число N, строку записи r и итоговое число R.

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

2. Теория

Системы счисления в Python

Для двоичной, восьмеричной и шестнадцатеричной записей в Python есть готовые функции:

bin()
oct()
hex()

Десятичную строку получают через:

str(n)

а само значение n уже является обычным целым числом Python.

ОснованиеПолучить записьРезультат функцииЧистая запись
2bin(n)'0b1101'bin(n)[2:]
8oct(n)'0o15'oct(n)[2:]
16hex(n)'0x1f'hex(n)[2:]
1

Почему нужен срез [2:]

Например:

bin(13)

возвращает:

0b1101

Первые два символа 0b — служебный префикс, а нам нужны только цифры двоичной записи.

Поэтому используем:

bin(13)[2:]

Получим:

1101

Важно: правильный срез — [2:], а не [:2].

[2:] означает: взять строку с позиции 2 до конца.

bin(13)[2:]

даёт:

1101

А:

bin(13)[:2]

оставит только:

0b

Перевод строки обратно в число

Функция:

int(строка, k)

читает строку как запись числа в системе с основанием k и возвращает обычное целое число Python.

Например:

int('1101', 2)

даст:

13

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

Для стандартной задачи №5 обычно используют основания от 2 до 36.

Как изменять строку

После перевода запись хранится в переменной r или s как строка.

Поэтому к ней можно приписывать символы и заменять отдельные части срезами.

1

Пусть:

s = '101101'

Дописать символы в начало

s = '11' + s

Получим:

11101101

Дописать символы в конец

s = s + '00'

Получим:

10110100

Вставить символ в середину

Сначала находим середину строки:

i = len(s) // 2

Затем собираем новую строку:

s = s[:i] + '0' + s[i:]

Срез:

s[:i]

берёт символы до позиции i, а:

s[i:]

берёт символы с позиции i до конца.

Поэтому формула работает при любой длине строки, а не только для конкретного количества цифр.

Заменить первые два символа

s = '00' + s[2:]

Заменить последние два символа

s = s[:-2] + '00'

Если требуется заменить только определённые позиции, срезы надёжнее метода replace().

Например:

s.replace('1', '0')

заменит все найденные единицы, а не только первую или первые две.

Если основание не равно 2, 8 или 16

Для троичной, пятеричной и другой системы пишем функцию перевода.

alf = sorted('1234567890QWERTYUIOPASDFGHJKLZXCVBNM')

def to_base(n, base):
    if n == 0:
        return '0'

    s = ''

    while n > 0:
        s = alf[n % base] + s
        n //= base

    return s

Строка alf содержит цифры и буквы. После sorted() символы располагаются в порядке:

0–9, A–Z

3. Шаги решения задачи кодом

  1. Определить, что требуется вывести: N, R или количество подходящих значений. От этого зависит, что сохранять после проверки.

  2. Задать перебор N. Для минимального N идём по возрастанию; границы из условия переносим в range без потери правого конца.

  3. Получить строку записи N:

bin(n)[2:]
oct(n)[2:]
hex(n)[2:]
to_base(n, base)
  1. Вычислить условие до изменения строки именно по условию задачи:
n % 2
n % 3
len(r) % 2
r.count('1') % 2

и так далее.

  1. Собрать новую строку конкретной операцией.

В начало:

prefix + r

В конец:

r + suffix

В середину:

r[:len(r) // 2] + fragment + r[len(r) // 2:]
  1. Выполнить:
R = int(r, base)

После этого проверить ограничение и сохранить нужную величину.

Для минимального N при возрастающем переборе обычно достаточно:

print(n)
break

Для максимального R сохраняем именно R.

Шаблон для основания 2, 8 или 16

for n in range(1, 10000):
    r = bin(n)[2:]

    if условие_для_n:
        r = ...
    else:
        r = ...

    R = int(r, 2)

    if условие_для_R:
        print(n)
        break

Для восьмеричной системы заменяем bin на oct и основание 2 в int на 8.

Для шестнадцатеричной — hex и 16.

Шаблон для другого основания

alf = sorted('1234567890QWERTYUIOPASDFGHJKLZXCVBNM')

def to_base(n, base):
    if n == 0:
        return '0'

    s = ''

    while n > 0:
        s = alf[n % base] + s
        n //= base

    return s


base = 3

for n in range(1, 10000):
    r = to_base(n, base)

    if условие_для_n:
        r = ...
    else:
        r = ...

    R = int(r, base)

    if условие_для_R:
        print(n)
        break

4. Практика с решениями

Задача 1. Основная волна 2026 (день 1)

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

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

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

Ключевой момент

В ответе требуется максимальное R, поэтому сохраняем R, а не исходное N.

После перебора выводим max(values).

Решение на Python

values = []

for n in range(1, 10000):
    r = bin(n)[2:]

    if n % 2 == 0:
        r = '11' + r + '11'
    else:
        r = '1' + r + '00'

    R = int(r, 2)

    if R <= 113:
        values.append(R)

print(max(values))

Ответ: 108

Задача 2. Троичная запись

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

  1. Строится троичная запись числа N.
  2. Если число N делится на 3, то слева к записи приписывается 1, а справа — 02.
  3. Если число N на 3 не делится, то остаток от деления на 3 умножается на 5, переводится в троичную систему и дописывается справа.
  4. Полученная запись переводится обратно в десятичную систему.

Например, для 11₁₀ = 102₃ результатом является 102101₃ = 307₁₀, а для 12₁₀ = 110₃ — 111002₃ = 353₁₀.

Укажите минимальное число N, после обработки которого получается число R, не меньшее 177.

Ключевой момент

В ветви else в троичную систему переводим выражение (n % 3) * 5, а не само N.

Решение на Python

alf = sorted('1234567890QWERTYUIOPASDFGHJKLZXCVBNM')

def to_base(n, base):
    if n == 0:
        return '0'

    s = ''

    while n > 0:
        s = alf[n % base] + s
        n //= base

    return s


for n in range(1, 1000):
    r = to_base(n, 3)

    if n % 3 == 0:
        r = '1' + r + '02'
    else:
        r += to_base((n % 3) * 5, 3)

    R = int(r, 3)

    if R >= 177:
        print(n)
        break

Ответ: 8

Задача 3. Досрочная волна 2026

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

Сначала строится двоичная запись числа N. Затем к ней справа два раза дописывается остаток от деления суммы цифр текущей записи на 2.

Например, запись 11100 после первого шага превращается в 111001. После этого сумма цифр считается уже для новой записи.

Для 12₁₀ = 1100₂ результат равен 110000₂ = 48₁₀, а для 7₁₀ = 111₂ — 11110₂ = 30₁₀.

Укажите наименьшее число N, для которого результат работы алгоритма больше 253.

Ключевой момент

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

Решение на Python

for n in range(1, 1000):
    r = bin(n)[2:]

    for _ in range(2):
        digit = r.count('1') % 2
        r += str(digit)

    R = int(r, 2)

    if R > 253:
        print(n)
        break

Ответ: 64

Задача 4. Сборник задач Крылова 2026

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

  1. Строится двоичная запись числа N.
  2. Если количество цифр в записи чётное, в середину дописывается 1.
  3. Если количество цифр нечётное, запись не изменяется.
  4. Полученная запись переводится обратно в десятичную систему.

Например, для 5₁₀ = 101₂ запись не меняется и R = 5. Для 2₁₀ = 10₂ получаем 110₂ = 6₁₀.

Укажите минимальное число N, после обработки которого получается R ≥ 26.

Ключевой момент

Позиция середины зависит от длины строки, поэтому используем:

mid = len(r) // 2

А новую строку собираем так:

r = r[:mid] + '1' + r[mid:]

Решение на Python

for n in range(1, 200):
    r = bin(n)[2:]

    if len(r) % 2 == 0:
        mid = len(r) // 2
        r = r[:mid] + '1' + r[mid:]

    R = int(r, 2)

    if R >= 26:
        print(n)
        break

Ответ: 12