Подробная программа ЕГЭ по информатике

from itertools import permutations, product            # перестановки столбцов и наборы значений

def f(x, y, z, w):                                     # функция из условия
    return (x and not y) or (y == z) or (not w)       # ∧ → and, ∨ → or, ≡ → ==, ¬ → not

frag = [(1, None, None, 1), (None, 0, None, 1), (1, None, None, 1)]   # фрагмент; None — пустая клетка

def fits(row, pattern):                                # совпадает ли строка с видимыми клетками
    return all(c is None or c == v for v, c in zip(row, pattern))

for p in permutations('xyzw'):                         # пробуем все порядки переменных в столбцах
    zeros = [r for r in product([0, 1], repeat=4)      # все наборы значений в порядке столбцов p
             if not f(**dict(zip(p, r)))]              # оставляем те, где F = 0
    for rows in permutations(zeros, 3):                # раскладываем три разных набора по строкам
        if all(fits(r, fr) for r, fr in zip(rows, frag)):   # все видимые клетки совпали
            print(''.join(p))                          # подходящий порядок столбцов: yxzw
            break                                      # этот порядок уже найден

from itertools import permutations, product            # перестановки столбцов и наборы значений

def f(x, y, z, w):                                     # функция из условия
    return (not x or y) and (not y or z) and w           # → записываем через not/or

frag = [(1, None, 0, None), (0, None, None, None), (None, 0, 1, None)]   # фрагмент; None — пустая клетка

def fits(row, pattern):                                # совпадает ли строка с видимыми клетками
    return all(c is None or c == v for v, c in zip(row, pattern))

for p in permutations('xyzw'):                         # пробуем все порядки переменных в столбцах
    good = [r for r in product([0, 1], repeat=4)       # наборы значений в порядке столбцов p
            if f(**dict(zip(p, r))) == 1]               # оставляем те, где F = 1
    for rows in permutations(good, 3):                 # раскладываем три разных набора по строкам
        if all(fits(r, fr) for r, fr in zip(rows, frag)):   # все видимые клетки совпали
            print(''.join(p))                          # подходящий порядок столбцов: zxyw
            break                                      # этот порядок уже найден

from itertools import permutations, product            # перестановки столбцов и наборы значений

def f(x, y, z, w):                                     # функция из условия
    return (x and not z) or (not y or w)                 # y → w записываем как not y or w

frag = [(None, None, 0, 1), (None, 0, None, None), (None, 1, None, 0)]   # фрагмент; None — пустая клетка

def fits(row, pattern):                                # совпадает ли строка с видимыми клетками
    return all(c is None or c == v for v, c in zip(row, pattern))

for p in permutations('xyzw'):                         # пробуем все порядки переменных в столбцах
    good = [r for r in product([0, 1], repeat=4)       # наборы значений в порядке столбцов p
            if f(**dict(zip(p, r))) == 0]               # оставляем те, где F = 0
    for rows in permutations(good, 3):                 # раскладываем три разных набора по строкам
        if all(fits(r, fr) for r, fr in zip(rows, frag)):   # все видимые клетки совпали
            print(''.join(p))                          # подходящий порядок столбцов: yzwx
            break                                      # этот порядок уже найден

=ВПР(C2; Магазин!A:C; 2; 0)

=ВПР(D2; Товар!A:E; 3; 0)

=ВПР(C2; Магазин!A:C; 2; 0)

=ВПР(D2; Товар!A:E; 3; 0)

=ВПР(D2; Товар!A:E; 5; 0)

for n in range(1, 100):                 # перебираем исходные N по возрастанию
    b = bin(n)[2:]                      # двоичная запись N без префикса 0b
    for _ in range(2):                  # шаг дописывания выполняется дважды
        b += str(b.count('1') % 2)      # дописываем остаток от деления суммы цифр на 2
    r = int(b, 2)                       # переводим запись обратно в число
    if r > 97:                          # R растёт вместе с N, поэтому первое R > 97 — минимальное
        print(r)                        # печатаем ответ
        break                           # дальше перебирать незачем

for n in range(1, 1000):                      # перебираем N по возрастанию
    b = bin(n)[2:]                            # двоичная запись N
    if n % 3 == 0:                            # N делится на 3
        b += b[-3:]                           # дописываем три последние цифры
    else:                                     # не делится
        b += bin(n % 3 * 3)[2:]               # дописываем двоичную запись остатка, умноженного на 3
    if int(b, 2) > 151:                       # R больше 151
        print(n)                              # первое такое N — минимальное
        break                                 # остановка

for n in range(101, 10000):                                  # N больше 100, по возрастанию
    b = bin(n)[2:]                                           # двоичная запись N
    inv = ''.join('1' if c == '0' else '0' for c in b)       # инвертируем каждую цифру
    m = int(inv, 2)                                          # int сам отбросит незначащие нули
    if n - m == 29:                                          # R = N − M равно 29
        print(n)                                             # первое такое N — наименьшее
        break                                                # остановка

from itertools import product                # product перебирает все наборы букв
count = 0                                    # счётчик подходящих слов
for w in product('КОДЕР', repeat=5):         # все слова длины 5 из этих букв
    if w.count('Р') == 2:                    # буква Р встречается ровно два раза
        count += 1                           # слово подходит
print(count)                                 # 640

from itertools import product                          # перебор всех наборов цифр
count = 0                                              # счётчик подходящих чисел
for w in product('0123456', repeat=4):                 # все записи из четырёх семеричных цифр
    if w[0] == '0':                                    # ведущий ноль — число не четырёхзначное
        continue                                       # пропускаем
    if len(set(w)) < 4:                                # есть повторяющиеся цифры
        continue                                       # пропускаем
    ev = [int(c) % 2 == 0 for c in w]                  # для каждой позиции: чётная ли цифра
    if any(ev[i] and ev[i + 1] for i in range(3)):     # две чётные стоят рядом
        continue                                       # пропускаем
    count += 1                                         # число подходит
print(count)                                           # 270

from itertools import product                       # все слова длины 6
count = 0                                           # счётчик подходящих слов
for w in product('ПАРК', repeat=6):                 # перебираем слова из четырёх букв
    if w.count('А') == 1 and w[0] != 'Р':           # одна А и первая буква не Р
        count += 1                                  # слово подходит
print(count)                                        # 1053

count = 0                                          # сколько строк подошло
for line in open('9.txt'):                         # читаем файл построчно
    a = list(map(int, line.split()))               # шесть чисел строки
    rep = [x for x in a if a.count(x) == 2]        # числа, встречающиеся ровно дважды (каждое попадёт сюда 2 раза)
    one = [x for x in a if a.count(x) == 1]        # числа, встречающиеся один раз
    if len(rep) == 2 and len(one) == 4:            # ровно одно число повторено, остальные четыре различны
        if sum(one) / 4 <= rep[0]:                 # среднее неповторяющихся не больше повторяющегося
            count += 1                             # строка подходит
print(count)                                       # ответ

count = 0                                       # сколько строк подошло
for line in open('9.txt'):                      # читаем файл построчно
    a = sorted(map(int, line.split()))          # пять чисел строки по возрастанию
    if len(set(a)) == 5:                        # все числа различны
        if a[0] + a[4] > a[1] + a[2] + a[3]:    # наименьшее + наибольшее больше суммы средних трёх
            count += 1                          # строка подходит
print(count)                                    # ответ

for num, line in enumerate(open('9.txt'), 1):        # num — номер строки, начиная с 1
    a = list(map(int, line.split()))                 # числа строки
    even = sum(x for x in a if x % 2 == 0)           # сумма чётных
    odd = sum(x for x in a if x % 2 == 1)            # сумма нечётных
    if even == odd:                                  # суммы равны
        print(num)                                   # номер первой такой строки
        break                                        # дальше искать не нужно

from ipaddress import ip_network                                    # модуль для работы с IP-сетями
net = ip_network('192.168.32.160/255.255.255.224', strict=False)    # сеть по адресу узла и маске
print(net.network_address, net.broadcast_address)                   # 192.168.32.160 и 192.168.32.191
print(net.broadcast_address - 1)                                    # последний адрес для узла: 192.168.32.190

from ipaddress import ip_network                                    # модуль для работы с сетями
net = ip_network('112.154.133.208/255.255.248.0', strict=False)     # сеть по адресу узла и маске
print(net.network_address)                                          # 112.154.128.0

from ipaddress import ip_network                    # модуль для работы с сетями
net = ip_network('172.16.168.0/255.255.248.0')      # сеть по адресу и маске
count = 0                                           # счётчик подходящих адресов
for a in net:                                       # перебираем все адреса сети
    if bin(int(a)).count('1') % 5 == 0:             # единиц в двоичной записи адреса — кратно 5
        count += 1                                  # адрес подходит
print(count)                                        # 385

s = '8' * 70                              # исходная строка: 70 восьмёрок
while '222' in s or '888' in s:           # ПОКА нашлось(222) ИЛИ нашлось(888)
    if '222' in s:                        # ЕСЛИ нашлось(222)
        s = s.replace('222', '8', 1)      # заменить(222, 8) — только первое вхождение
    else:                                 # ИНАЧЕ
        s = s.replace('888', '2', 1)      # заменить(888, 2)
print(s)                                  # 22

s = '1' + '5' * 80                       # исходная строка
while '15' in s or '55' in s:            # ПОКА нашлось(15) ИЛИ нашлось(55)
    if '15' in s:                        # ЕСЛИ нашлось(15)
        s = s.replace('15', '5', 1)      # заменить(15, 5)
    else:                                # ИНАЧЕ
        s = s.replace('55', '1', 1)      # заменить(55, 1)
print(s)                                 # 1

s = '>' + '1' * 30 + '2' * 30 + '3' * 30         # исходная строка
while '>1' in s or '>2' in s or '>3' in s:       # ПОКА нашлось одно из трёх
    if '>1' in s:                                # ЕСЛИ нашлось(>1)
        s = s.replace('>1', '22>', 1)            # заменить(>1, 22>)
    if '>2' in s:                                # ЕСЛИ нашлось(>2)
        s = s.replace('>2', '2>', 1)             # заменить(>2, 2>)
    if '>3' in s:                                # ЕСЛИ нашлось(>3)
        s = s.replace('>3', '1>', 1)             # заменить(>3, 1>)
print(sum(int(c) for c in s if c.isdigit()))     # сумма цифр, символ > пропускаем: 210

s = 0                  # начальное значение s
n = 75                 # начальное значение n
while s + n < 150:     # цикл идёт, пока сумма меньше 150 (растёт на 10 за проход)
    s = s + 15         # s увеличивается на 15
    n = n - 5          # n уменьшается на 5
print(n)               # после 8 проходов: 75 − 40 = 35

s = 1                  # начальное s
n = 0                  # счётчик, растёт на 3 за проход
while s < 300:         # цикл, пока s меньше 300
    s = s * 2 + 1      # s: 3, 7, 15, …, 511
    n = n + 3          # +3 за каждый проход
print(n)               # 8 проходов · 3 = 24

k = 0                                  # сумма последних цифр
for i in range(1, 101):                # i от 1 до 100 включительно
    if i % 3 == 0 and i % 5 != 0:      # делится на 3 и не делится на 5
        k += i % 10                    # добавляем последнюю цифру
print(k)                               # 138

x = 4**2020 + 2**2017 - 15     # Python работает с длинными числами без потери точности
print(bin(x).count('1'))       # bin даёт строку '0b1…', считаем в ней единицы

x = 8**150 - 2**200 + 3        # длинная арифметика Python считает точно
print(bin(x).count('1'))       # считаем единицы в двоичной записи: 252

for x in range(15):                                          # x — цифра 15-ричной системы: от 0 до 14
    d = '0123456789ABCDE'[x]                                 # её запись символом
    v = int('82' + d + '19', 15) + int('6' + d + '073', 15)  # переводим оба числа в десятичную и складываем
    if v % 14 == 0:                                          # сумма делится на 14
        print(x, v // 14)                                    # x и частное: 3 51888
        break                                                # перебор по возрастанию — первый x наименьший

for A in range(256):                                    # перебираем A по возрастанию
    ok = True                                           # предполагаем, что A подходит
    for x in range(1024):                               # проверяем x; старшие биты на ответ не влияют
        f = (x & 29 == 0) or (x & 12 != 0) or (x & A != 0)   # a → (b → c) = ¬a ∨ ¬b ∨ c
        if not f:                                       # нашли x, при котором формула ложна
            ok = False                                  # A не подходит
            break                                       # дальше проверять незачем
    if ok:                                              # формула истинна при всех x
        print(A)                                        # первое такое A — наименьшее
        break                                           # остановка

best = 0                                                      # наибольшее подходящее A
for A in range(1, 1000):                                      # перебираем A
    ok = all(x % A == 0 or x % 6 != 0 or x % 4 != 0           # ¬a → (b → ¬c) = a ∨ ¬b ∨ ¬c
             for x in range(1, 5000))                         # проверяем много x
    if ok:                                                    # формула истинна при всех x
        best = A                                              # запоминаем — ищем наибольшее
print(best)                                                   # 12

import sys                                  # модуль sys нужен, чтобы поднять лимит рекурсии
sys.setrecursionlimit(5000)                 # по умолчанию Python не даст рекурсию глубже ~1000 вызовов

def F(n):                                   # функция по определению из условия
    if n == 1:                              # база: F(1) = 1
        return 1                            # возвращаем 1
    return n * F(n - 1)                     # иначе n · F(n − 1)

print((F(2024) + 2 * F(2023)) // F(2022))   # // — целочисленное деление, точное для огромных чисел

a, b = 1, 1                      # F(1) и F(2)
for n in range(3, 21):           # считаем F(3), F(4), …, F(20)
    a, b = b, b + 2 * a          # новое F(n) = F(n−1) + 2·F(n−2); сдвигаем пару
print(b)                         # F(20) = 349525

def F(n):                        # функция по определению из условия
    if n >= 2025:                # база: F(n) = n
        return n                 # возвращаем само число
    return n + F(n + 2)          # иначе n + F(n + 2)
print(F(2020) - F(2023))         # 4044

a = [int(x) for x in open('17.txt')]                 # читаем все числа файла в список
m = max(x for x in a if x % 13 == 0)                 # максимальный элемент, кратный 13
cnt, best = 0, -10**9                                # количество пар и максимальная сумма
for i in range(len(a) - 1):                          # i — индекс левого элемента пары соседей
    x, y = a[i], a[i + 1]                            # сама пара
    end3 = abs(x) % 10 == 3 or abs(y) % 10 == 3      # хотя бы одно оканчивается на 3 (abs — для отрицательных)
    if end3 and x + y < m:                           # оба условия выполнены
        cnt += 1                                     # пара подходит
        best = max(best, x + y)                      # обновляем максимальную сумму
print(cnt, best)                                     # два числа ответа

a = [int(x) for x in open('17.txt')]                        # все числа файла
def three(x): return 100 <= abs(x) <= 999                   # трёхзначное ли число (с учётом знака)
m = max(x for x in a if three(x) and abs(x) % 10 == 5)      # порог: максимальное трёхзначное на 5
cnt, best = 0, -10**9                                       # количество троек и максимальная сумма
for i in range(len(a) - 2):                                 # i — первый элемент тройки
    t = a[i:i + 3]                                          # сама тройка
    if sum(three(x) for x in t) == 2 and sum(t) <= m:       # ровно два трёхзначных и сумма не больше порога
        cnt += 1                                            # тройка подходит
        best = max(best, sum(t))                            # обновляем максимум сумм
print(cnt, best)                                            # ответ

a = [int(x) for x in open('17.txt')]       # все числа файла
cnt, low = 0, 10**9                        # количество пар и минимальная сумма
for i in range(len(a) - 1):                # i — левый элемент пары
    x, y = a[i], a[i + 1]                  # пара соседей
    if x * y < 0 and (x + y) % 7 == 0:     # разные знаки и сумма кратна 7
        cnt += 1                           # пара подходит
        low = min(low, x + y)              # обновляем минимальную сумму
print(cnt, low)                            # ответ

from functools import lru_cache          # запоминаем уже посчитанные позиции, иначе перебор очень долгий

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 4, s * 2]         # +1 камень, +4 камня, удвоение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 45:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print(min(s for s in range(1, 45) if game(s) == 'L1'))   # минимальное S, где Ваня выигрывает первым ходом: 22

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 2, s * 3]                # +2 камня или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 70:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print(min(s for s in range(1, 70) if game(s) == 'L1'))   # 22

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 2, s * 3]         # +1, +2 или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 60:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print([s for s in range(1, 60) if game(s) == 'L1'])   # [19]

from functools import lru_cache          # запоминаем уже посчитанные позиции, иначе перебор очень долгий

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 4, s * 2]         # +1 камень, +4 камня, удвоение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 45:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print([s for s in range(1, 45) if game(s) == 'W2'])   # Петя выигрывает ровно вторым ходом: [11, 18, 21]

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 2, s * 3]                # +2 камня или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 70:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print([s for s in range(1, 70) if game(s) == 'W2'])   # [20, 21]

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 2, s * 3]         # +1, +2 или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 60:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print([s for s in range(1, 60) if game(s) == 'W2'])   # [17, 18]

from functools import lru_cache          # запоминаем уже посчитанные позиции, иначе перебор очень долгий

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 4, s * 2]         # +1 камень, +4 камня, удвоение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 45:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print(min(s for s in range(1, 45) if game(s) == 'L2'))   # Ваня выигрывает первым или вторым ходом, но не гарантированно первым: 17

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 2, s * 3]                # +2 камня или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 70:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print(min(s for s in range(1, 70) if game(s) == 'L2'))   # 18

from functools import lru_cache          # запоминаем уже посчитанные позиции

def moves(s):                            # все ходы из позиции s
    return [s + 1, s + 2, s * 3]         # +1, +2 или утроение

@lru_cache(None)                         # кэш результатов для каждой позиции
def game(s):                             # итог позиции для того, кто сейчас ходит
    if s >= 60:                          # игра уже окончена — ходящий проиграл
        return 'L0'                      # L0: проигрыш «за 0 ходов соперника»
    res = [game(t) for t in moves(s)]    # итоги позиций после каждого нашего хода (для соперника)
    lose = [r for r in res if r[0] == 'L']   # ходы, после которых соперник проигрывает
    if lose:                             # такой ход есть — мы выигрываем
        return 'W' + str(min(int(r[1:]) for r in lose) + 1)   # побеждаем как можно быстрее
    return 'L' + str(max(int(r[1:]) for r in res))           # все ходы плохие — проигрываем как можно позже

print([s for s in range(1, 60) if game(s) == 'L2'])   # [16]

def f(a, b):                       # сколько программ переводят a в b
    if a > b or a == 15:           # перелетели цель или попали в запретное 15 — путь не годится
        return 0                   # таких программ нет
    if a == b:                     # дошли до цели
        return 1                   # ровно одна программа — пустая
    return f(a + 1, b) + f(a + 3, b) + f(a * 2, b)   # пробуем все три команды и складываем

print(f(2, 10) * f(10, 20))       # через 10: пути до 10 × пути от 10 до 20 = 351

def f(a, b):                       # сколько программ переводят a в b
    if a > b or a == 17:           # перелетели цель или попали в запретное 17
        return 0                   # путь не годится
    if a == b:                     # дошли до цели
        return 1                   # одна программа
    return f(a + 2, b) + f(a * 2, b) + f(a + 3, b)   # три команды

print(f(3, 11) * f(11, 25))       # через 11: пути до 11 × пути от 11 до 25 = 84

def f(a, b):                       # сколько программ переводят a в b
    if a > b or a in (14, 26):     # перелетели цель или попали в запретное число
        return 0                   # путь не годится
    if a == b:                     # дошли до цели
        return 1                   # одна программа
    return f(a + 1, b) + f(a * 3, b)   # две команды

print(f(2, 50))                   # 19

s = open('24.txt').readline().strip()     # вся строка из файла без перевода строки
best = cur = 1                            # длина лучшей и текущей цепочки (один символ — уже цепочка)
for i in range(1, len(s)):                # идём по строке со второго символа
    if s[i] != s[i - 1]:                  # соседние различны
        cur += 1                          # цепочка продолжается
        best = max(best, cur)             # запоминаем рекорд
    else:                                 # два одинаковых подряд
        cur = 1                           # новая цепочка начинается с текущего символа
print(best)                               # ответ

s = open('24.txt').readline().strip()   # строка из файла
best = cur = 0                          # лучшая и текущая длина цепочки без Z
for c in s:                             # перебираем символы по очереди
    if c != 'Z':                        # символ подходит (X или Y)
        cur += 1                        # цепочка удлиняется
        best = max(best, cur)           # обновляем рекорд
    else:                               # встретили Z
        cur = 0                         # цепочка обрывается
print(best)                             # ответ

s = open('24.txt').readline().strip()    # строка из файла
best = left = z = 0                      # лучший ответ, левая граница окна, число Z в окне
for right in range(len(s)):              # двигаем правую границу окна
    if s[right] == 'Z':                  # в окно вошла буква Z
        z += 1                           # учитываем её
    while z > 2:                         # Z стало больше двух — сжимаем окно слева
        if s[left] == 'Z':               # уходящий символ — Z
            z -= 1                       # уменьшаем счётчик
        left += 1                        # сдвигаем левую границу
    best = max(best, right - left + 1)   # окно корректно — сравниваем длину с рекордом
print(best)                              # ответ

from fnmatch import fnmatch                  # fnmatch понимает маски с ? и *
for k in range(2023, 10**10 + 1, 2023):     # перебираем только числа, кратные 2023
    if fnmatch(str(k), '1?2139*4'):          # число подходит под маску
        print(k, k // 2023)                  # число и частное от деления на 2023

from fnmatch import fnmatch                 # fnmatch понимает маски с ? и *
for k in range(317, 10**8 + 1, 317):       # только числа, кратные 317
    if fnmatch(str(k), '12??36*1'):         # число подходит под маску
        print(k, k // 317)                  # число и частное

def M(n):                                   # сумма наименьшего и наибольшего нетривиальных делителей
    d = 2                                   # ищем наименьший делитель, начиная с 2
    while d * d <= n:                       # дальше корня искать незачем
        if n % d == 0:                      # нашли наименьший делитель
            return d + n // d               # наибольший — парный к нему
        d += 1                              # пробуем следующий
    return 0                                # делителей нет — число простое

count = 0                                   # сколько чисел уже нашли
n = 700001                                  # начинаем с первого числа больше 700 000
while count < 5:                            # нужно пять чисел
    m = M(n)                                # считаем M
    if m % 10 == 4:                         # M оканчивается на 4
        print(n, m)                         # печатаем число и M
        count += 1                          # ещё одно найдено
    n += 1                                  # следующее число

f = open('26.txt')                                 # файл: в первой строке S и N, дальше N цен
S, N = map(int, f.readline().split())             # бюджет и количество товаров
a = sorted(int(f.readline()) for _ in range(N))   # цены по возрастанию
cnt, total = 0, 0                                  # сколько купили и сколько потратили
while cnt < N and total + a[cnt] <= S:             # берём самые дешёвые, пока хватает денег
    total += a[cnt]                                # платим за товар
    cnt += 1                                       # ещё один товар куплен
rest = S - (total - a[cnt - 1])                    # деньги, если не покупать последний (самый дорогой из взятых)
top = max(x for x in a[cnt - 1:] if x <= rest)     # самый дорогой из оставшихся, который помещается в бюджет
print(cnt, top)                                    # количество и цена самого дорогого товара

f = open('26.txt')                                # файл: N, затем N баллов
n = int(f.readline())                             # количество участников
a = sorted((int(f.readline()) for _ in range(n)), reverse=True)   # баллы по убыванию
k = n // 4                                        # 25% участников, округление вниз
low = a[k - 1]                                    # балл последнего из «основных» призёров
count = sum(1 for x in a if x >= low)             # призёры — все с баллом не ниже порога
print(count, low)                                 # количество призёров и минимальный балл

f = open('26.txt')                                 # файл: N, затем N размеров
n = int(f.readline())                              # количество коробок
a = sorted((int(f.readline()) for _ in range(n)), reverse=True)   # размеры по убыванию
chain = [a[0]]                                     # начинаем с самой большой коробки
for x in a[1:]:                                    # остальные — от больших к меньшим
    if chain[-1] - x >= 3:                         # помещается в последнюю взятую
        chain.append(x)                            # вкладываем
print(len(chain), chain[-1])                       # количество и самая маленькая коробка

from math import dist                                   # евклидово расстояние между двумя точками
pts = [tuple(map(float, line.replace(',', '.').split()))   # читаем пары координат, запятую меняем на точку
       for line in open('27.txt')]                      # по одной звезде в строке
cl = [[p for p in pts if p[1] > p[0]],                  # кластер выше прямой y = x (границу берём по диаграмме)
      [p for p in pts if p[1] <= p[0]]]                 # кластер ниже прямой
def center(c):                                          # центр кластера
    return min(c, key=lambda p: sum(dist(p, q) for q in c))   # точка с минимальной суммой расстояний
cs = [center(c) for c in cl]                            # центры обоих кластеров
px = sum(c[0] for c in cs) / len(cs)                    # среднее абсцисс центров
py = sum(c[1] for c in cs) / len(cs)                    # среднее ординат центров
print(int(px * 10000), int(py * 10000))                 # целые части, как требует условие

from math import dist                                          # расстояние между двумя точками
pts = [tuple(map(float, line.replace(',', '.').split()))       # читаем пары координат
       for line in open('27.txt')]                             # по одной звезде в строке
cl = [[p for p in pts if p[0] < 3],                            # первый кластер (границы — по диаграмме)
      [p for p in pts if 3 <= p[0] < 7],                       # второй кластер
      [p for p in pts if p[0] >= 7]]                           # третий кластер
def center(c):                                                 # центр кластера
    return min(c, key=lambda p: sum(dist(p, q) for q in c))    # минимальная сумма расстояний
cs = [center(c) for c in cl]                                   # центры всех кластеров
px = sum(c[0] for c in cs) / len(cs)                           # среднее абсцисс центров
py = sum(c[1] for c in cs) / len(cs)                           # среднее ординат центров
print(int(px * 10000), int(py * 10000))                        # ответ

from math import dist                                          # расстояние между двумя точками
pts = [tuple(map(float, line.replace(',', '.').split()))       # читаем пары координат
       for line in open('27.txt')]                             # по одной звезде в строке
cl = [[p for p in pts if p[1] > p[0]],                         # кластер выше прямой y = x
      [p for p in pts if p[1] <= p[0]]]                        # кластер ниже прямой
def center(c):                                                 # центр кластера
    return min(c, key=lambda p: sum(dist(p, q) for q in c))    # минимальная сумма расстояний
far = []                                                       # дальние расстояния по кластерам
for c in cl:                                                   # для каждого кластера
    ce = center(c)                                             # его центр
    far.append(max(dist(ce, p) for p in c))                    # расстояние до самой дальней звезды
print(int(max(far) * 10000))                                   # наибольшее из двух · 10 000