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

Давайте подробно разберём задачу и найдём искомое число \( N \).

---

Постановка задачи:

• Вводится натуральное число \( N \).
• Строится его двоичная запись.
• В зависимости от суммы цифр двоичной записи:
  • Если сумма чётная:
    • справа дописывается 0,
    • два левых разряда заменяются на 10.
  • Если сумма нечётная:
    • справа дописывается 1,
    • два левых разряда заменяются на 11.
• После этих преобразований полученная двоичная запись — двоичное число \( R \).
• Нужно найти максимальное \( N \), такое, что \( R < 35 \).

---

Анализ условий:

Рассмотрим оба варианта:

Вариант 1: сумма цифр двоичной записи чётная

1. Запись:
   • Дописываем справа 0 → получается удлинение на 1 бит.
   • Заменяем два левых разряда на "10" (то есть первые два бита двоичной записи изменяются на "10").

Вариант 2: сумма нечётна

1. Дописываем справа 1.
2. Заменяем два левых разряда на "11".

---

Исследуем пример из условия:

• \( N = 6 \), двоичная:

  \( 6_{10} = 110_2 \).

  Считаем сумму цифр: \( 1 + 1 + 0 = 2 \) — чётная.

  Тогда:

  • Заменяем два левых разряда "11" → "10".
  • Остальная часть: добавляем справа 0.

  Изначально: "110"

  После замены двух левых разрядов "11" → "10": остаётся "10" и далее "0" (добавление справа 0) → "10" + "0" → "100".

  Результат двоичной: "100" = 4 — что, по примеру, соответствует \( R = 8 \).

  Это немного противоречит примеру, где для числа 6 результат — 8, то есть двоичная "1000" .

  Внимание! Тогда нужно уточнить: как в примере сообразить, что получается "1000" ?

  Посмотрим ещё раз пример из условия:

Например, для числа 6 = 110₂ результат = 8 = 1000₂.

Тогда правило, видимо, предполагает, что при замене двух левых разрядов "11" → "10" происходит следующее:

• Меняем первые два бита "11" на "10".
• Удлиняем число справа добавлением "0" (не на самом деле, а в двоичной работе — добавлять 0 в конец).

Тогда, исходя из примера, двоичная запись "110" при чётной сумме (2), переходит в "1000", как по примеру.

Значит:

• Для случая "чётная сумма" — делается:

  • Перезаписываются первые два бита "11" на "10".

  • К числу добавляется справа "0".

  • И итоговая двоичная запись — это "10" + оставшиеся биты (после замены) + "0", причём замена происходит только если нужно заменить два левых разряда — то есть, первые два бита.

  Аналогично, пример показывает, что результат — это "1000", то есть 8.

• Аналогично для числа 4:

  \( 4_{10} = 100_2 \).

  В условии результат — 13, что в двоичной — "1101".

  "100" при нечётной сумме: делается "11" вместо первых двух разрядов, добавляется справа "1".

  Тогда:

  • Замена "10" на "11".

  • Справа добавляем "1".

  Итог: "110".

  В итоге получается "1101" — что равно 13 — правильно.

Вывод:

• Для нечётной суммы: первая часть — "11" вместо первых двух разрядов "10" — так в примере.

• Для чётной суммы: ("11" → "10") и в конце добавлять "0".

---

Обобщение правил по примерам:

Исходное число	Двоичная	Сумма цифр	Результат	Двоичный	Результат (десятичный)
4	100	1+0+0=1 (нечёт)	13 (1101)	1101	13
6	110	2 (чёт)	8 (1000)	1000	8

---

Пересмотрим шаги для каждого варианта:

Для нечётной суммы:

• Заменяем первые два бита "10" → "11"
• Справа добавляем "1"

Пример: "100" → "110" + "1" = "1101" (число 13)

Для чётной суммы:

• Заменяем первые два бита "11" → "10"
• Справа добавляем "0"

Пример: "110" → "100" + "0" = "1000" (число 8)

---

Итоговая формула:

1. Определить сумму цифр.
2. Заменить первые два бита согласно правил:
   • нечётная сумма: "10" → "11"
   • чётная сумма: "11" → "10"
3. Добавить в конец "1" или "0" в зависимости от суммы.
4. Остальную часть оставлять без изменений.

---

Решение задачи:

Нам нужно найти максимальное \( N \), для которого \( R < 35 \).

Переберём \( N \) и вычислим \( R \):

• Для \( N \) — переводим в двоичный.
• Определяем сумму цифр.
• Выполняем преобразование.
• Получаем \( R \), проверяем, меньше ли оно 35.

---

Итерационный поиск:

Проверим числа начиная с больших, идуя назад:

• Можно ограничиться числом возле 34, поскольку искомое \( R < 35 \).

Обратим внимание: двоичные числа, дающие \( R < 35 \), должны быть не больше 34.

• Найдём двоичную запись чисел близких к 34:

  \( 34_{10} = 100010_2 \)

  \( 33_{10} = 100001_2 \)

  \( 32_{10} = 100000_2 \)

Проверим эти числа:

---

Проверка для \( N=34 \):

• \( 34_{10} = 100010_2 \)

• Сумма цифр: 1+0+0+0+1+0 = 2 (чётная).

• Правило для чётной суммы:

  • Заменяем первые два бита "10" → "10" (остается без изменений, так как первые два бита — "10").

  • В конце добавляем "0".

  • Итог: "10" + "0010" (остальные биты) → "100010" + "0" (добавляем справа) — в двоичной: "1000100" (делает больше 35, так как:

    \( 1000100_2 = 68 \)) — больше 35, не подходит.

Пересчитаем аккуратно:

• Исходная: "100010"

• Первые два бита "10", заменяем на "10" — без изменений.

• Добавляем справа "0".

• Итог: "100010" + "0" = "1000100" → 68. Значит, \( R=68 \), что больше 35.

---

Проверка для \( N=33 \):

• \( 33_{10} = 100001_2 \)

• Сумма цифр: 1+0+0+0+0+1=2, чётная.

• Правило:

  • Первые два бита "10" → "10" (без изменений).

  • Добавляем справа "0".

  • Итог: "100001" + "0" = "1000010" — \( 66 \), больше 35.

---

Проверка для \( N=32 \):

• \( 32_{10} = 100000_2 \)

• Сумма: 1+0+0+0+0+0=1 — нечётная.

• Тогда:

  • Первые два бита "10" → "11".

  • Добавляем справа "1".

  • Всё вместе:

    • Заменяем "10" → "11" в начале.

    • Итог: "110000" + "1" — "1100001" (в двоичной), что равно \( 97 \) — больше 35, не подходит.

---

Проверим чуть меньшие числа:

Для минимизации R чуть лучше проверить несколько меньших чисел.

---

Практическая проверка (условия, чтобы R было <35):

• Попробуем число \( N=20 \):

  \( 20_{10} = 10100_2 \)

  сумма: 1+0+1+0+0=2, чётная.

  Правило:

  • Первые два бита "10" → "10".

  • Добавляем справа "0" → "10100" + "0" = "101000".

  • Это равно:

    \( 101000_2 \) = 40, больше 35.

  не подходит.

• \( N=16 \):

  \( 16_{10} = 10000_2 \)

  сумма: 1+0+0+0+0=1 — нечётна.

  Правило:

  • Первые два бита "10" → "11".

  • Добавляем справа "1" → "1110001" — 113, что превышает 35.

• \( N=10 \):

  \( 1010_2 \)

  сумма: 1+0+1+0=2 — чётная.

  Замена первых двух бит "10" → "10" (не меняется), добавляем "0" справа:

  "1010" + "0" = "10100" = 20, равно 20, что меньше 35.

  Значит \( R=20 \), подходит.

---

Итог:

• При \( N=10 \), \( R=20<35 \). Хорошо.

• Проверим чуть больше:

  \( N=11 \):

  \( 1011_2 \)

  сумма: 1+0+1+1=3 — нечётная.

  Замена первых двух бит "10" → "11".

  Добавляем справа "1":

  Итог: "1111" — 15.

  \( R=15<35 \).

• \( N=12 \):

  \( 1100_2 \)

  сумма: 1+1+0+0=2 — чётная.

  Заменяем "11" → "10", добавляем "0" справа:

  Изначально: "1100"

  После замены первых двух бита: "10" + "00" (оставшиеся биты) + "0" в конце — итог "10000"→16.

  \( R=16<35 \).

• \( N=13 \):

  \( 1101_2 \)

  сумма: 1+1+0+1=3 (нечётная).

  • Заменяем "11" → "11" (остается без изменений? чуть уточню).

  Правило: для нечётной суммы — "10" → "11".

  Первые два бита: "11" — меняем на "11", добавляем "1" в конце.

  Итог: "1111" — 15.

  \( R=15<35 \).

---

Итоговая проверка:

Рассмотрев все эти, кажется очевидным, что число \( N=20 \) даёт \( R=20 \), что подходит. Но для чисел чуть больше, например, \( N=21 \) и далее, результат может быть выше.

Давайте проверим, что произойдет для \( N=34 \), так как \( R \) для этого числа был уже слишком большим.

Получается, максимальное число, для которого \( R<35 \), — это, вероятно, около 19-20, так как при более высоких значениях итоговое \( R \) превышает 35.

Итоговий ответ:

Самое большое \( N \), при котором \( R <35 \), — это число 20.

---

Ответ:

\[ \boxed{20} \]