Вариант 2 · Июль 2026

Решение:
Проанализировав схему, видим, что пункт E является уникальным узлом со степенью 4, следовательно, в таблице ему соответствует строка под номером 3. В силу симметрии графа пары вершин A и D, B и G, а также C и F являются взаимозаменяемыми. Допустим, что пункты A и D — это номера 1 и 4 (поскольку только эти точки не связаны напрямую с вершиной E). Исходя из этого, для G и B остаются позиции 7 и 6 (или наоборот). Следовательно, вершинам C и F будут соответствовать номера 2 и 5 (или в обратном порядке — 5 и 2).

Ответ: 25

Источник: ФИПИ

Решение:

Дизъюнкция равна нулю только при нулевых слагаемых: $\neg w = 0$, то есть $w=1$; $y \equiv z$ ложно, то есть $y \ne z$; и $x \land \neg y = 0$.

Наборов с такими свойствами ровно три: $(w,x,y,z)$ равно $(1,0,0,1)$, $(1,0,1,0)$ или $(1,1,1,0)$.

Во всех строках $w=1$, поэтому в столбце $w$ не может быть нулей. Нули есть во втором, третьем и четвёртом столбцах, значит $w$ — первый столбец.

Столбцы $y$ и $z$ обязаны различаться, а во второй строке второй и четвёртый столбцы оба равны 0, и в первой строке третий и четвёртый столбцы тоже оба равны 0. Остаётся единственная возможность: $y$ и $z$ — это второй и третий столбцы, а $x$ — четвёртый.

В первой и второй строках четвёртый столбец равен 0, то есть в них $x=0$. Наборов с $x=0$ всего два, поэтому третьей строке достаётся оставшийся набор $(1,1,1,0)$, в котором $y=1$ и $z=0$. В третьей строке второй столбец равен 0, а третий равен 1 — значит второй столбец это $z$, а третий $y$.

Тот же результат даёт перебор всех 24 расстановок переменных по столбцам:

from itertools import permutations, product

def F(w, x, y, z):
    return (x and not y) or (y == z) or not w

rows = [t for t in product([0, 1], repeat=4) if not F(*t)]   # наборы (w, x, y, z) с F = 0

frag = [[None, None, 0, 0],
        [1, 0, None, 0],
        [1, 0, 1, None]]

for cols in permutations('wxyz'):        # cols[i] — переменная в i-м столбце
    for order in permutations(rows, 3):  # какой набор какой строке фрагмента
        val = [dict(zip('wxyz', t)) for t in order]
        if all(frag[r][i] is None or frag[r][i] == val[r][cols[i]]
               for r in range(3) for i in range(4)):
            print(''.join(cols))
            break

Ответ: wzyx

Решение:

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

Шаг 1. В таблице «Аптека» отбираем аптеки сети «Солнышко» и выписываем их ID.

Шаг 2. В таблице «Препараты» находим Зиртек. Артикулов с таким названием несколько, и они отличаются числом таблеток в упаковке (7, 10 и 20). По условию нужна только упаковка на 7 таблеток — берём соответствующий ей артикул.

Шаг 3. В таблице «Движение лекарственных средств» оставляем строки с этим артикулом и аптеками из шага 1 (вся таблица охватывает 1–14 июня, поэтому по дате ничего отсекать не нужно) и двумя формулами СУММЕСЛИМН считаем сумму «Количества упаковок» отдельно для типа операции «Поступление» и для типа «Продажа». Получаем 1151 и 52 упаковки соответственно.

Шаг 4. Прирост: $1151 - 52 = 1099$ упаковок.

Ответ: 1099

Решение:

Известно: А — 01000, Б — 10001, В — 11010, Г — 00. Нужны три новых кодовых слова с наименьшей суммарной длиной.

Свободных слов длины 1 нет: 0 является началом слова 00 (буква Г), а 1 — началом слова 10001.

Свободных слов длины 2 тоже нет: 00 занято буквой Г, 01 является началом слова 01000, 10 — началом слова 10001, 11 — началом слова 11010.

Значит, каждое из трёх новых слов имеет длину не менее 3. Подходящие слова длины 3 действительно найдутся: в ветви 01 занята только вершина 010 (там лежит А) — свободно 011; в ветви 10 занята вершина 100 — свободно 101; в ветви 11 занята вершина 110 — свободно 111.

Получаем набор 011, 101, 111 с минимальной суммой длин $3 + 3 + 3 = 9$.

Ответ: 9

Решение:

Первый шаг алгоритма — вычитание остатка от деления на 4 — превращает $N$ в число $M = N - (N \bmod 4)$, кратное четырём. Дальше к двоичной записи $M$ дважды приписывается справа бит чётности, то есть запись удлиняется ровно на два разряда: $R = 4M + 2b_1 + b_0$, где $b_1$ и $b_0$ — приписанные биты.

Отсюда $R \ge 4M$, и из условия $R \lt 47$ следует $M \le 11$. Кратных четырём значений тут немного: $M = 0$, $M = 4$, $M = 8$. Чем больше $M$, тем больше $R$, поэтому берём наибольшее подходящее $M = 8$ и проверяем его.

Запись числа 8 — 1000. Сумма цифр равна 1, остаток от деления на 2 равен 1, приписываем: 10001. Теперь сумма цифр равна 2, остаток 0, приписываем: 100010. Это $32 + 2 = 34$, и действительно $34 \lt 47$. Для сравнения, $M = 4$ даёт $100 \to 1001 \to 10010 = 18$, а $M = 12$ уже даёт $1100 \to 11000 \to 110000 = 48 \gt 47$. Наибольшее подходящее $R$ равно 34 (оно получается при $N = 8, 9, 10, 11$).

def R(N):
    b = bin(N - N % 4)[2:]
    for _ in range(2):
        b += str(sum(int(c) for c in b) % 2)
    return int(b, 2)

print(max(R(N) for N in range(1, 1000) if R(N) < 47))   # 34

Ответ: 34

Решение:

Сначала выясним, какую фигуру чертит алгоритм. Команда «Направо 270» из положения «голова вверх» разворачивает Черепаху влево, в сторону отрицательных $x$. Первый цикл рисует отрезок из $(0;0)$ в $(-8;0)$, а после поворота на 120° — отрезок длиной 8 под углом 60° к оси абсцисс. Следующий блок дважды добавляет по 3 единицы в том же самом направлении, так что наклонный отрезок продолжается до общей длины $8+3+3=14$ и обрывается в точке $(-1;7\sqrt3)$. Последний цикл чертит отрезок 14 вниз-вправо в точку $(6;0)$ и отрезок 14 влево, замыкая контур в $(-8;0)$.

Итак, линия ограничивает равносторонний треугольник со стороной 14: основание лежит на оси абсцисс от $(-8;0)$ до $(6;0)$, вершина — $(-1;7\sqrt3)$, причём $7\sqrt3\approx12{,}12$. Боковые стороны задаются уравнениями $x=-8+\dfrac{y}{\sqrt3}$ и $x=6-\dfrac{y}{\sqrt3}$, поэтому для каждого целого $y$ от 1 до 12 достаточно посчитать целые $x$ строго между этими границами.

По строкам получается 13, 11, 11, 9, 9, 7, 5, 5, 3, 3, 1 и 1 точка, а всего $13+11+11+9+9+7+5+5+3+3+1+1=78$. Узлы на самой линии (в том числе 15 точек на основании) не учитываются.

from math import sqrt

n = 0
for y in range(1, 13):
    left = -8 + y / sqrt(3)     # левая сторона
    right = 6 - y / sqrt(3)     # правая сторона
    for x in range(-8, 7):
        if left < x < right:
            n += 1
print(n)   # 78

Ответ: 78

Решение:

Объём несжатой звукозаписи равен $V = k \cdot f \cdot b \cdot t$, где $k$ — число каналов, $f$ — частота дискретизации, $b$ — разрешение (число бит на отсчёт), $t$ — длительность.

Фрагмент тот же, поэтому $t$ не изменилась, и достаточно посмотреть, во сколько раз изменился каждый из остальных множителей:

• было 2 канала (стерео), стало 1 (моно) — уменьшение в 2 раза;
• разрешение (глубина кодирования) выросло в 2,5 раза;
• частота дискретизации выросла в 4 раза.

Значит объём файла умножился на $\frac{1}{2} \cdot 2{,}5 \cdot 4 = 5$, и новая запись занимает $39 \cdot 5 = 195$ Мбайт.

size = 39          # Мбайт, первая запись
k = 0.5 * 2.5 * 4  # во сколько раз изменился объём
print(size * k)    # 195.0

Ответ: 195

Решение:

В пятеричной системе счисления используются цифры 0, 1, 2, 3, 4.

Строго убывающая запись состоит из попарно различных цифр, и наоборот — любые три различные цифры выстраиваются по убыванию единственным способом. Поэтому подходящих записей ровно столько, сколько трёхэлементных подмножеств у множества из пяти цифр: $$C_5^3 = \frac{5!}{3!\,2!} = 10.$$

Старшая цифра — наибольшая из трёх, значит она не ноль, и все 10 наборов задают трёхзначные числа.

from itertools import product

print(sum(1 for d in product(range(5), repeat=3) if d[0] > d[1] > d[2]))

Ответ: 10

Решение:

Откроем файл. В строке 1 записаны часы (0:00 … 23:00), в столбце A — даты, а измерения занимают блок B2:Y92: 91 день по 24 замера, всего 2184 числа.

Разность между минимальным значением и средним арифметическим отрицательна, поэтому по смыслу задания ищем модуль этой разности — насколько среднее превышает минимум. В любую свободную ячейку записываем:

=СРЗНАЧ(B2:Y92)-МИН(B2:Y92)

В англоязычной версии редактора это =AVERAGE(B2:Y92)-MIN(B2:Y92). Получаем $10{,}4653\ldots - 0{,}3 = 10{,}1653\ldots$ Целая часть равна 10. То же самое на Python (для CSV-версии файла):

import csv

values = []
rows = list(csv.reader(open('data.csv', encoding='cp1251'), delimiter=';'))
for row in rows[1:]:                      # пропускаем строку с часами
    for cell in row[1:]:                  # пропускаем столбец с датой
        values.append(float(cell.replace(',', '.')))

print(sum(values) / len(values) - min(values))   # 10.1653...

В ответе записываем только целую часть. Ответ: 10

Решение:

Открываем прилагаемый файл в текстовом редакторе и пользуемся поиском (Ctrl+F).

Параметры поиска:

• «Только слово целиком» — включено: это как раз и отсекает другие формы слова — «долги», «долгами», «Долгами», а заодно и слова «долго», «долгий», внутри которых есть то же сочетание букв;
• «Учитывать регистр» — выключено: по условию подходят и «долг», и «Долг».

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

«Найти все» даёт единственное совпадение — строка «Цензуре долг свой заплачу».

Проверка программой (текст сохранён в текстовый файл):

import re

text = open('onegin.txt', encoding='utf-8').read()
print(len(re.findall(r'\bдолг\b', text)) + len(re.findall(r'\bДолг\b', text)))

Программа печатает 1.Ответ: 1

Решение:

В пароле встречаются только 26 строчных латинских букв и 10 арабских цифр, значит мощность алфавита составляет $26 + 10 = 36$ символов. На один символ нужно минимальное целое $i$, при котором $2^i \ge 36$. Так как $2^{5} = 32 \lt 36 \lt 64 = 2^{6}$, получаем $i = 6$ бит.

Один пароль из 7 символов занимает $7 \cdot 6 = 42$ бита. Число байт должно быть целым и минимальным: $42 = 8 \cdot 5 + 2$, поэтому под него отводится 6 байт.

Кроме пароля на один пользователя отводится ещё 9 байт дополнительных сведений, поэтому одна запись занимает $6 + 9 = 15$ байт.

Для 30 пользователей потребуется $30 \cdot 15 = 450$ байт.

import math

N = 26 + 10                   # мощность алфавита
i = math.ceil(math.log2(N))   # бит на один символ
b = math.ceil(7 * i / 8)      # байт на пароль
print(30 * (b + 9))           # ответ в байтах

Ответ: 450

Решение:

Символ «>» — это указатель, который двигается по строке слева направо: каждая замена обрабатывает цифру, стоящую сразу за указателем, и оставляет результат слева от «>», где он уже не изменится:

• >1 → 222> : цифра 1 даёт три двойки, вклад в сумму 6;
• >2 → 3> : цифра 2 даёт тройку, вклад 3;
• >3 → 1> : цифра 3 даёт единицу, вклад 1.

Каждая цифра обрабатывается ровно один раз, поэтому их порядок не важен, и сумма цифр итоговой строки равна $$11 \cdot 6 + n \cdot 3 + 11 \cdot 1 = 77 + 3n.$$

При $n=1$ получаем $80$ — составное; при $n=2$ получаем $83$ — простое число. Наименьшее подходящее $n = 2$.

def zamenit(s, v, w):
    return s.replace(v, w, 1)   # первое слева вхождение

def prostoe(x):
    d = 2
    while d * d <= x:
        if x % d == 0:
            return False
        d += 1
    return x > 1

def rabota(s):
    while ">1" in s or ">2" in s or ">3" in s:
        if ">1" in s:
            s = zamenit(s, ">1", "222>")
        if ">2" in s:
            s = zamenit(s, ">2", "3>")
        if ">3" in s:
            s = zamenit(s, ">3", "1>")
    return s

n = 1
while True:
    s = rabota(">" + "1" * 11 + "2" * n + "3" * 11)
    summa = sum(int(c) for c in s if c != ">")
    if prostoe(summa):
        print(n, summa)   # 2 83
        break
    n += 1

Ответ: 2

Решение:

Маска однозначно задаётся числом $k$ своих единиц: это $k$ единиц подряд, а затем $32-k$ нулей. Адрес сети получается из адреса узла обнулением всех битов правее $k$-го, поэтому задача сводится к тому, чтобы найти все допустимые $k$, и ответом будет их количество.

Переведём числа в двоичную систему:
адрес узла 123.244.113.28 — 01111011.11110100.01110001.00011100,
адрес сети 123.244.0.0 — 01111011.11110100.00000000.00000000.

Последняя единица адреса сети стоит на 14-й позиции (шестой бит второго байта: 244 = 11110100), и она должна остаться в сетевой части, поэтому $k \ge 14$. Дальше сравниваем третьи байты: у адреса сети там нули, а у адреса узла 113 = 01110001 — первый бит нулевой и потому совпадает, а на 18-й позиции у узла стоит единица, которую маска обязана обнулить, значит $k \le 17$.

Подходят $k = 14, 15, 16, 17$ — маски 255.252.0.0, 255.254.0.0, 255.255.0.0 и 255.255.128.0. Всего 4 значения.

Проверка программой:

def to_bits(s):
    return ''.join(format(int(x), '08b') for x in s.split('.'))

ip = to_bits('123.244.113.28')
net = to_bits('123.244.0.0')
ok = [k for k in range(33) if ip[:k] + '0' * (32 - k) == net]
print(ok, len(ok))

Ответ: 4

Решение:

Основание системы счисления 23, а делитель $22 = 23-1$. Так как $23 \equiv 1 \pmod{22}$, любое число сравнимо по модулю 22 с суммой своих 23-ричных цифр (это тот же признак, что и признак делимости на 9 в десятичной системе). Значит, вся сумма делится на 22 тогда и только тогда, когда на 22 делится сумма всех цифр трёх слагаемых.

Считаем суммы цифр:

• $1x1x1x1x1_{23}$: $5 + 4x$;
• $20x24_{23}$: $2+0+x+2+4 = 8 + x$;
• $1x235_{23}$: $1+x+2+3+5 = 11 + x$.

Всего $24 + 6x$. Требуем $24 + 6x \equiv 0 \pmod{22}$, то есть $6x \equiv 20 \pmod{22}$, или $3x \equiv 10 \pmod{11}$, откуда $x \equiv 7 \pmod{11}$. В алфавите 23-ричной системы подходят $x = 7$ и $x = 18$; наименьшее — $x = 7$.

Подставляем $x=7$ и делим сумму на 22:

b = 23

def num(ds):
    n = 0
    for d in ds:
        n = n * b + d
    return n

for x in range(b):                       # ищем наименьшее x
    s = (num([1, x, 1, x, 1, x, 1, x, 1])
         + num([2, 0, x, 2, 4])
         + num([1, x, 2, 3, 5]))
    if s % 22 == 0:
        print(x, s // 22)                # 7 4651779499
        break

Ответ: 4651779499

Решение:

Формула ложна, когда ложны все четыре части, то есть когда для целых неотрицательных $x$ и $y$ одновременно

$x \leq 19$, $y \leq 39$, $y \gt x + A$, $y \lt 3x - A$.

Иначе говоря, «плохая» пара существует, если в интервале $(x + A;\ 3x - A)$ найдётся целое $y$, не превосходящее 39.

Между целыми числами $x + A$ и $3x - A$ строго лежит целое число только тогда, когда их разность не меньше 2:

$(3x - A) - (x + A) \geq 2 \iff 2x - 2A \geq 2 \iff x \geq A + 1$.

Так как $x \leq 19$, плохих пар не будет, если $A + 1 \gt 19$, то есть $A \geq 19$.

Проверим, что $A = 18$ не годится: при $x = 19$ интервал — $(37;\ 39)$, в нём лежит $y = 38 \leq 39$, и все четыре части ложны. А при $A = 19$ и $x = 19$ интервал $(38;\ 38)$ пуст, при меньших $x$ — тем более.

Наименьшее целое $A = 19$. Проверка перебором:

A = 19
bad = [(x, y) for x in range(20) for y in range(40)
       if not ((x >= 20) or (y >= 40) or (y <= x + A) or (y >= 3*x - A))]
print(bad)

Ответ: 19

Решение:

Считать $F(2024)$ и $F(2022)$ по отдельности не нужно: в разности почти всё сократится. Раскроем соотношение $F(n) = 2n + 1 + F(n - 1)$ два раза.

$$F(2024) = 2 \cdot 2024 + 1 + F(2023) = 4049 + F(2023),$$

$$F(2023) = 2 \cdot 2023 + 1 + F(2022) = 4047 + F(2022).$$

Подставим второе равенство в первое:

$$F(2024) = 4049 + 4047 + F(2022) = 8096 + F(2022).$$

Отсюда $F(2024) - F(2022) = 8096$. Обратите внимание: базовое значение $F(1) = 5$ в ответ не входит вовсе.

def F(n):
    r = 5
    for i in range(2, n + 1):
        r = 2 * i + 1 + r
    return r

print(F(2024) - F(2022))   # 8096

Ответ: 8096

Решение:

Считаем файл в список целых чисел и просмотрим все пары соседних элементов $(a_i,\ a_{i+1})$ — их на единицу меньше, чем самих чисел.

Последняя цифра числа — это остаток от деления его модуля на 10. Модуль здесь принципиален: в Python для отрицательных чисел остаток считается по-другому, например $-3119 \bmod 10 = 1$, хотя число оканчивается на 9.

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

a = [int(s) for s in open('44118_17.txt')]

count = 0
best = None
for x, y in zip(a, a[1:]):
    dx, dy = abs(x) % 10, abs(y) % 10
    if dx % 2 == 1 and dy % 2 == 1 and dx != dy:
        count += 1
        p = abs(x) * abs(y)
        if best is None or p < best:
            best = p

print(count, best)   # 1020 17197

Программа находит 1020 подходящих пар, наименьшее произведение модулей равно 17197.Ответ: 1020 17197

Решение:

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

Пусть $a_{ij}$ — номинал монеты в клетке, $M_{ij}$ и $m_{ij}$ — максимальная и минимальная накопленные суммы. Тогда $M_{ij}=\max(M_{i-1,j},\,M_{i,j-1})+a_{ij}$ и $m_{ij}=\min(m_{i-1,j},\,m_{i,j-1})+a_{ij}$, причём соседняя клетка учитывается только тогда, когда между ней и текущей нет стены. Для левой верхней клетки $M_{11}=m_{11}=a_{11}$.

В приложенном файле поле имеет размер $20\times20$, стены показаны утолщёнными линиями. Вертикальные внутренние стены (движение вправо запрещено) стоят:

• между 2-м и 3-м столбцами — в строках 2–8;
• между 4-м и 5-м столбцами — в строках 5–13;
• между 6-м и 7-м столбцами — в строках 10–18;
• между 9-м и 10-м столбцами — в строках 2–9;
• между 12-м и 13-м столбцами — в строках 6–14;
• между 15-м и 16-м столбцами — в строках 9–18.

Горизонтальные внутренние стены (движение вниз запрещено) стоят между 2-й и 3-й строками в столбцах 4–8 и между 17-й и 18-й строками в столбцах 9–14.

Скопируем содержимое таблицы в текстовый файл 18.txt (числа разделены пробелами или знаками табуляции) и обработаем его программой.

f = open('18.txt')
a = [[int(x) for x in s.split()] for s in f]
N = len(a)

# стена снизу от клетки (i, j); строки и столбцы нумеруются с нуля
def wall_down(i, j):
    return (i == 1 and 3 <= j <= 7) or (i == 16 and 8 <= j <= 13)

# стена справа от клетки (i, j)
def wall_right(i, j):
    return ((j == 1 and 1 <= i <= 7) or (j == 8 and 1 <= i <= 8) or
            (j == 3 and 4 <= i <= 12) or (j == 11 and 5 <= i <= 13) or
            (j == 5 and 9 <= i <= 17) or (j == 14 and 8 <= i <= 17))

MX = [[0] * N for i in range(N)]   # максимум, накопленный к клетке
MN = [[0] * N for i in range(N)]   # минимум
for i in range(N):
    for j in range(N):
        if i == 0 and j == 0:
            MX[i][j] = MN[i][j] = a[0][0]
            continue
        v = []
        if i > 0 and not wall_down(i - 1, j):
            v.append((MX[i - 1][j], MN[i - 1][j]))
        if j > 0 and not wall_right(i, j - 1):
            v.append((MX[i][j - 1], MN[i][j - 1]))
        MX[i][j] = max(x for x, y in v) + a[i][j]
        MN[i][j] = min(y for x, y in v) + a[i][j]

print(MX[N - 1][N - 1], MN[N - 1][N - 1])

Программа выводит 1099 1026: максимальная сумма равна 1099, минимальная — 1026. Ответ: 1099 1026

Решение:

Позиция игры описывается одним числом $s$ — количеством камней в куче. Игрок, который ходит из позиции $s$, выигрывает своим ходом, если хотя бы один его ход сразу даёт кучу в 181 камней или больше.

Ходы: $s\to s+1$ и $s\to 2s$. Одним ходом игра заканчивается, если $s+1\ge181$ ($s\ge180$) или $2s\ge181$ ($s\ge90{,}5$, для целого $s$ — $s\ge91$). Значит, из позиции $s\ge91$ ходящий выигрывает одним ходом.

Нужно $S\le90$ (Петя не выигрывает сразу) и $S+1\ge91$, $2S\ge91$, то есть $S\ge90$ и $S\ge46$. Единственное значение — $S=90$.

Проверка: из 90 Петя получает 91 или 180. Из 91 Ваня удваивает: $182\ge181$; из 180 добавляет камень: $181\ge181$. Сам Петя выиграть сразу не мог: $91\lt181$ и $180\lt181$.

def win1(s):
    return s + 1 >= 181 or 2 * s >= 181

for S in range(1, 181):
    if not win1(S) and win1(S + 1) and win1(2 * S):
        print(S)

Ответ: 90

Решение:

Напомним игру: в куче $S$ камней, своим ходом игрок либо добавляет в кучу один камень, либо удваивает её; выигрывает тот, после чьего хода в куче окажется не менее 301 камней.

Так как $2S \ge S+1$, игрок выигрывает одним ходом тогда и только тогда, когда $2S \ge 301$, то есть при $S \ge 151$.

Найдём проигрышную позицию — такую кучу, из которой ходящий сам выиграть не может, но любой его ход отдаёт победу сопернику. Оба хода должны попадать в зону $\ge 151$; слабее ход «+1», он требует $S+1 \ge 151$, то есть $S \ge 150$. Вместе с $S \le 150$ (иначе игрок выиграл бы сам) получаем единственную такую кучу: 150 камней. Действительно, из 150 камней получаются 151 и 300 камней — до 301 не хватает; зато из 151 камней соперник удваивает и получает 302, а из 300 камней добавляет камень и получает 301.

Значит Петя должен своим первым ходом получить ровно 150 камней:

• ходом «+1»: $S+1 = 150$, то есть $S = 149$;
• ходом «×2»: $2S = 150$, то есть $S = 75$.

Оба значения меньше 151, так что за один ход Петя действительно не выигрывает, а после его хода в позицию «150 камней» Ваня вынужден отдать победу: как бы он ни сходил, Петя следующим ходом добирает кучу до 301. Меньших подходящих значений нет: из кучи, где меньше 75 камней, позицию «150 камней» одним ходом не получить.

Проверка перебором:

N = 301

def moves(s):
    return [s + 1, 2 * s]

def win1(s):                      # выигрыш первым же ходом
    return any(t >= N for t in moves(s))

def lose1(s):                     # ходящий проигрывает: любой его ход даёт сопернику победу
    return not win1(s) and all(win1(t) for t in moves(s))

def win2(s):                      # первым ходом не выигрывает, вторым — выигрывает
    return not win1(s) and any(lose1(t) for t in moves(s))

print([s for s in range(1, N) if win2(s)][:2])   # [75, 149]

Ответ: 75 149

Решение:

Напомним условия игры: перед игроками две кучи камней, за ход можно добавить в одну из куч (по своему выбору) два камня либо увеличить количество камней в одной из куч вдвое; игра заканчивается, когда суммарное количество камней в кучах становится не менее $122$. Начальная позиция — $(3,\ S)$, первым ходит Петя.

Позицию будем оценивать с точки зрения игрока, который ходит из неё. Обозначим: В1 — из позиции можно выиграть первым же ходом; П1 — любой ход не заканчивает игру и переводит соперника в В1 (то есть ходящий проигрывает следующим ходом соперника); В2 — позиция не В1, но есть ход, переводящий соперника в П1, то есть ходящий выигрывает ровно вторым своим ходом при любой игре соперника.

В1. Из позиции $(3,\ S)$ игру заканчивают ход «добавить два камня» ($S+5 \ge 122$) и удвоение большей кучи ($2S+3 \ge 122$). Второе условие слабее, поэтому В1 — это все $S \ge 60$.

П1 для начальной позиции — единственное значение $S = 59$; В2 — значения $S = 57$, $S = 58$.

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

При $S = 55$ четыре хода Пети дают позиции $(3,\ 57)$ (В2), $(5,\ 55)$ (В2), $(6,\ 55)$ (В2), $(3,\ 110)$ (В1). Все они для Вани выигрышны не позже второго хода, но три из них — только вторым ходом, поэтому гарантированно выиграть первым ходом Ваня не может. Полный перебор подтверждает, что меньших значений $S$ с таким свойством нет.

Перебор всех $S$ удобно сделать программой:

N = 122

def moves(p):
    a, b = p
    return [(a + 2, b), (a, b + 2), (2 * a, b), (a, 2 * b)]

def over(p):                 # игра закончена
    return p[0] + p[1] >= N

def win1(p):                 # В1: выигрыш своим первым ходом
    return any(over(q) for q in moves(p))

def lose1(p):                # П1: любой ход отдаёт победу сопернику
    return all(not over(q) and win1(q) for q in moves(p))

def win2(p):                 # В2: выигрыш вторым ходом, но не первым
    return not win1(p) and any(not over(r) and lose1(r) for r in moves(p))

def lose2(p):                # Ваня выигрывает первым или вторым ходом,
    return (all(not over(q) and (win1(q) or win2(q)) for q in moves(p))
            and not lose1(p))          # но не гарантированно первым

print(min(s for s in range(1, 118) if lose2((3, s))))

Ответ: 55

Решение:

Момент завершения процесса $B$ равен $F(B) = \max F(A_i) + t(B)$, где $A_i$ — процессы, от которых он зависит; независимый процесс завершается в момент $t(B)$. Время работы всей совокупности — наибольшее из значений $F$. При увеличении $t$ это время не убывает, поэтому нужно взять наибольшее целое $t$, при котором оно ещё не превышает 12 мс.

Подставим $t = 2$ и заполним столбец $F$:

ID процесса	Время выполнения, мс	Зависит от	Момент завершения, мс
1	2	0	2
2	3	0	3
3	6	0	6
4	$t$	1; 2; 3	8
5	3	4	11
6	3	0	3
7	2	6	5
8	3	4; 7	11
9	7	0	7
10	1	8; 9	12
11	1	9	8
12	1	11	9

Наибольшее значение равно 12 мс, условие «не более 12 мс» выполнено. При $t = 3$ общее время стало бы равно 13 мс, что больше 12, поэтому 2 — максимально возможное целое значение.

Тот же перебор программой:

# данные из прилагаемого файла; None — неизвестное время t
data = {
     1: (2, []),
     2: (3, []),
     3: (6, []),
     4: (None, [1, 2, 3]),
     5: (3, [4]),
     6: (3, []),
     7: (2, [6]),
     8: (3, [4, 7]),
     9: (7, []),
    10: (1, [8, 9]),
    11: (1, [9]),
    12: (1, [11]),
}

def total(t):
    finish = {}
    for i in sorted(data):
        dur, deps = data[i]
        if dur is None:
            dur = t
        finish[i] = max([finish[d] for d in deps], default=0) + dur
    return max(finish.values())

print(max(t for t in range(1, 1000) if total(t) <= 12))

Ответ: 2

Решение:

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

Траектория обязана содержать число $6$, поэтому каждая подходящая программа однозначно распадается на две части: $1 \to 6$ и $6 \to 35$. По правилу умножения ответ равен произведению количеств программ для этих участков.

Пусть $f(x, y)$ — количество программ, переводящих $x$ в $y$: $f(x, x) = 1$ (пустая программа), $f(x, y) = 0$ при $x \gt y$ (число уже «перескочило» цель, а уменьшать команды не умеют). В остальных случаях перебираем первую команду («прибавить 2», «прибавить 3» или «умножить на 5»):

$$f(x, y) = f(x + 2,\, y) + f(x + 3,\, y) + f(5x,\, y).$$

Число $21$ траектория содержать не должна, поэтому переход в него запрещаем — соответствующее слагаемое отбрасываем.

from functools import lru_cache

@lru_cache(None)
def f(x, y):          # сколько программ переводят число x в число y
    if x == y:
        return 1
    if x > y:
        return 0      # перескочили - назад команд нет
    s = 0
    for z in (x + 2, x + 3, x * 5):
        if z != 21:
            s += f(z, y)
    return s

print(f(1, 6) * f(6, 35))

Получаем $f(1, 6) = 2$ и $f(6, 35) = 846$, то есть всего $2 \cdot 846 = 1692$ программ. Ответ: 1692

Решение:

Запрещена только одна конфигурация — две буквы P подряд, то есть подстрока PP. Все остальные сочетания символов допустимы, поэтому серия обрывается ровно в тех местах, где встречается PP.

Идём по файлу и храним длину текущей допустимой серии cur. Если текущий и предыдущий символы оба равны P, старая серия закончилась, и новая начинается с текущего символа: cur = 1. Иначе cur += 1. Ответ — максимум cur.

s = open('53033_24.txt').read().strip()

mx = cur = 1
for i in range(1, len(s)):
    if s[i] == 'P' and s[i - 1] == 'P':
        cur = 1
    else:
        cur += 1
    if cur > mx:
        mx = cur

print(mx)

Важно, что при обрыве новая серия начинается именно со второй буквы P: она сама по себе запрещённой пары не образует и может стать началом следующего участка. Программа выводит 188. Ответ: 188

Решение:

Переведём маску 1?2157*4 в условие на строку десятичной записи числа: первая цифра равна 1; вторая цифра любая (символ «?»); далее подряд идут цифры 2157; затем произвольная, возможно пустая, последовательность цифр (символ «*»); последняя цифра равна 4. Отсюда сразу видно, что в числе не менее семи цифр.

Перебирать все числа до $10^{10}$ незачем: достаточно пройти только по кратным 2024, тогда делимость выполняется автоматически, а проверять останется лишь совпадение с маской. Таких кратных около пяти миллионов, программа отрабатывает за секунды.

for n in range(2024, 10**10 + 1, 2024):
    s = str(n)
    if len(s) >= 7 and s[0] == '1' and s[2:6] == '2157' and s[-1] == '4':
        print(n, n // 2024)

Условие len(s) >= 7 гарантирует, что блок 2157 и завершающая цифра 4 не накладываются друг на друга, то есть «*» действительно может быть пустой последовательностью. Программа находит 11 чисел; выводим их по возрастанию вместе с частными:

142157664	70236
1021575544	504731
1121571264	554136
1221577104	603546
1321572824	652951
1421578664	702361
1521574384	751766
1621570104	801171
1721575944	850581
1821571664	899986
1921577504	949396

Ответ: 142157664 70236 1021575544 504731 1121571264 554136 1221577104 603546 1321572824 652951 1421578664 702361 1521574384 751766 1621570104 801171 1721575944 850581 1821571664 899986 1921577504 949396

Решение:

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

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

f = open('26.txt')
n = int(f.readline())
a = sorted((int(x) for x in f), reverse=True)

cnt = 0
last = None
for x in a:
    if last is None or x <= last - 3:
        cnt += 1
        last = x
print(cnt, last)

Программа выводит:

2767 51

Ответ: 2767 51

Решение:

Сначала забудем про делимость и возьмём из каждой пары большее число. Полученная сумма $S$ — наибольшая из всех возможных, поэтому если она не делится на 35, то она и есть ответ.

Пусть $S$ делится на 35. Тогда в некоторых парах придётся взять меньшее число. Замена в паре $(a,b)$ уменьшает сумму ровно на $d=|a-b|$, а замены в нескольких парах — на сумму соответствующих разностей. Итоговая сумма $S-\sum d$ не делится на 35 тогда и только тогда, когда $\sum d$ не кратна 35 (ведь само $S$ кратно 35). Но если бы все слагаемые в $\sum d$ были кратны 35, то и вся сумма была бы кратна 35; значит, хотя бы одна разность $d$ не кратна 35, и потому $\sum d \ge d_{\min}$, где $d_{\min}$ — наименьшая положительная разность, не кратная 35. Эта оценка достижима: достаточно поменять выбор в одной-единственной паре. Итак, ответ равен $S$, если $S$ не делится на 35, и $S-d_{\min}$ иначе.

Алгоритм линейный: один проход по файлу, в котором накапливаются $S$ и $d_{\min}$.

def solve(name, m):
    f = open(name)
    n = int(f.readline())
    s = 0                       # сумма больших чисел из каждой пары
    best = 10**9                # минимальная «допустимая» разность
    for _ in range(n):
        a, b = map(int, f.readline().split())
        s += max(a, b)
        d = abs(a - b)
        if d > 0 and d % m != 0:
            best = min(best, d)
    if s % m != 0:
        return s
    return s - best

print(solve('A.txt', 35), solve('B.txt', 35))

Файл A: сумма больших чисел равна $665848$; она даёт остаток $8$ при делении на 35, то есть уже не делится на 35 — уменьшать ничего не нужно, ответ $665848$.Файл B: сумма больших чисел равна $665535990$ и делится на 35. Наименьшая ненулевая разность внутри пары, не кратная 35, равна $1653$, поэтому ответ $665535990 - 1653 = 665534337$.Ответ: 665848 665534337