Шаблоны решения заданий для ЕГЭ по информатике

Задание 1

Где начинается путь, там 1

Задание 2

print('x y z w') # печатаем имена переменных
# перебор всех комбинаций значений переменных В ТОМ ЖЕ ПОРЯДКЕ!
for x in range(2):
   for y in range(2):
      for z in range(2):
         for w in range(2):
# переписываем функцию
            if ((not(x<=y)) or (z==w) or z) == 0:  # f = 0 или 1 по заданию
                 print(x, y, z, w)

≡ ==
¬ not
/\ and
V or
→ <=

То что после if и до == обязательно В СКОБКАХ!

Задание 3

Используйте автофильтр

Задание 4

Обязательно в условии подчеркивайте, что конкретно надо найти: с наименьшим или наибольшим числовым значением, кратчайшее или самое длинное, сумму, сколько букв в закодированном алфавите (надо, чтобы все буквы влезли на дерево). Может быть несколько условий в задании, например кратчайшее с наибольшим числовым значением.

Считать по 2-3 раза, чтобы быть точно уверенным!

Задание 5

N → q → R

Без перестановки

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.
1. Строится троичная запись числа N.
2. Далее эта запись обрабатывается по следующему правилу:
а) если число N делится на 3, то к этой записи справа дописываются цифры 21, а слева - цифра 1;
б) если число N на 3 не делится, то остаток от деления N на 3 умножается на 5, переводится в троичную запись и дописывается в конец числа.
Полученная таким образом запись является троичной записью искомого числа R.
3. Результат переводится в десятичную систему и выводится на экран.
Например, для исходного числа 11 = 102₃ результатом является число 102101₃ = 307, а для исходного числа 12=110₃ результатом является число 111021₃= 358.
Укажите максимальное нечетное число N, после обработки которого с помощью этого алгоритма получается число R, не превышающее 1130.

# Перевод в троичную/двоичную:

def f(n):
s = ''
while n > 0:
s = str(n% 3) + s
n//= 3
return s
print(f(11)) # Проверка правильности перевода, должно быть 102

for n in range(100000, 0, -1):  # 0 потому что когда с конца его не включаем и получится от 1 до 100000
    q = f(n)
    if n % 3 == 0:      # Условия из задания
        q = '1' + q + '21'
    else:
        ost = (n % 3) * 5
        q = q + f(ost)
    r = int(q, 3)      # Переводим в десятичную
    if n%2 != 0 and r <=1130:  # Условия для N и R из задания
        print(n)
        break

С перестановкой:

На вход алгоритма подаётся неотрицательное число $N .$ Алгоритм строит по нему новое число $R$ следующим образом.
Число переводится в семеричную систему счисления. Полученная запись преобразуется по следующему алгоритму:
а) если $N$ чётное, то справа дописывается $1,$ а слева — $52;$
б) если $N$ нечётное, то первая и последняя цифры в числе меняются местами, а затем справа дописывается $15.$
Из записи удаляются незначащие нули.
Полученная таким образом запись является семеричной записью искомого числа $R .$ Укажите максимальное число $N,$ не превышающее $1000,$ после обработки которого с помощью этого алгоритма получается число $R,$ семеричная запись которого содержит ровно $4$ значащих разряда.

Тот же шаблон, но добавляется перестановка

def f(n):
    s = ''
    while n > 0:
        s = str(n% 7) + s
        n//= 7
    return s

for n in range(0, 100000):
    q = f(n)
    if n % 2 == 0:
        q = '52' + q + '1'
    else:
        q = q[-1] + q[1:-1] + q[0] + '15' # q[1:-1] cрез со 2-го символа (индекс 1) до предпоследнего
    r = int(q, 7)         # переводим в десятичную, чтобы удалить незначащие нули
    if n <=1000 and len(f(r)) == 4:  # Полученная таким образом запись... len(f(r)) - переводим снова в 7-ричную
        print(n)

берем последнее или for n in range задаем с конца и break как в первом примере

Найти R

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.
1. Строится двоичная запись числа N.
2. Далее эта запись обрабатывается по следующему правилу:
а) если число N делится на 3, то к этой записи дописываются три последние двоичные цифры;
б) если число N на 3 не делится, то остаток от деления умножается на 3, переводится в двоичную запись и дописывается в конец числа.
Полученная таким образом запись является двоичной записью искомого числа R.
3. Результат переводится в десятичную систему и выводится на экран.
Например, для исходного числа 12₁₀ = 1100₂ результатом является число 1100100₂ = 100₁₀, а для исходного числа 4₁₀ = 100₂ это число 10011₂ = 19₁₀.
Укажите максимальное число R, не превышающее 208, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Тот же шаблон

def f(n):
    s = ''
    while n > 0:
        s = str(n% 2) + s
        n//= 2
    return s

for n in range(1, 1000000):  # перебираем всевозможные N
    q = f(n)
    if n % 3 == 0:      # Условия из задания
        q = q + q[-3:]   # если добавить первые 3 то q[:3], если начиная с 4го и до конца q[3:]
    else:
        ost = (n % 3) * 3
        q = q + f(ost)
    r = int(q, 2)      # Переводим в десятичную
    if r <=208:  # Условия для N и R из задания
        print(r)

Задание 6

from turtle import * # Импортируем модуль turtle для визуализации пути Черепахи

tracer(0)            # Отключаем анимацию для мгновенного отображения
screensize(2000, 2000) # Устанавливаем размер холста (если рисунок не влезает)
k = 20                # Масштабный коэффициент для увеличения видимости, иначе всё мелкое
lt(90)                # Поворачиваем голову черепахи налево на 90°, потому что в питоне черепаха изначально головой вдоль оси х (голова теперь вдоль оси Y)

# Черепаха готова, по умолчанию ее хвост опущен, задаем алгоритм из задания
for _ in range(2): # цикл
    fd(14 * k) # вперед 
    lt(270) # влево
    bk(12 * k) # назад
    rt(90) # вправо
    up() # хвост вверх
    down() # хвост вниз
 
# Размечаем сетку целочисленных координат
pu()                 # Поднимаем хвост, чтобы не рисовать при перемещении
for x in range(-20, 20):   # Проходим по всем целым x от -20 до 19 (цифры подбором)
    for y in range(-20, 20):  # Проходим по всем целым y от -20 до 19
        goto(x * k, y * k)   # Перемещаемся к координатам (x*k, y*k)
        dot(4, 'red') # Красные точки с размером 4

Периметр и площадь считаем по ОТРЕЗКАМ! Точки с целочисленными координатами - считаем ТОЧКИ

Задание 7

Лена записывает голосовое сообщение для своей подруги. Перед отправкой сообщение оцифровывается в формате стерео с частотой дискретизации 28 000 Гц и глубиной кодирования 8 бит. Определите наименьшее количество Кбайт, необходимое для сохранения сообщения в памяти (без учёта заголовка), если его длительность – 2 минуты 20 секунд.
В ответе укажите только число.

from math import *

v=ceil(2*28000*8*140/8/1024)
print(v)

Маша делает цветные фотографии на телефон, который сохраняет снимки с размером 3840×2160 пикселей и разрешением 20 бит. После сохранения снимков в памяти телефона Маша отправляет фотографию через мессенджер, который сжимает снимок до размера 1280x720 пикселей. При отправке 120 фотографий удалось сэкономить 2322000 Кбайт. Какое максимальное количество цветов может быть в сжатой картинке?

from math import *
for n in range(100000, 0, -1):
i = ceil(log2(n))
pic1 = 3840*2160*20
pic2 = 1280*720*i
if 120*(pic1-pic2)==2322000*8*1024:
print(n)
break #256

Если переводим из битов в байты и больше, то всегда округляем.
i=ceil(log2(n2) всегда округляем вверх.

Для картинок V=m∙n∙i

Для звука V=каналов∙ N∙i∙t
N частота дискретизации, Герц,
i – глубина звука, бит
t – время звучания, секунды
Моно – 1 канал
Стерео – 2 канала
Квадро – 4 канала

Задание 8

Все пятибуквенные слова, составленные из букв А, Л, Г, О, Р, И, Т, М, записаны в алфавитном порядке и пронумерованы. Вот начало списка:
1. ААААА
2. ААААГ
3. ААААИ
4. ААААЛ
5. ААААМ
6. ААААО Определите, под каким номером в этом списке стоит первое слово с чётными номерами, которые не начинаются с букв А или Г и при этом содержат в своей записи не менее двух букв Р.

from itertools import *
count = 0
for x in product(sorted('алгоритм'), repeat=5):
    s = ''.join(x)
    count += 1
    if count % 2 == 0 and s[0] not in 'аг' and s.count('р') >= 2:
        print(count)
        break

Все пятибуквенные слова, составленные из букв А, Л, Г, О, Р, И, Т, М, записаны в алфавитном порядке и пронумерованы.
Вот начало списка:
1. ААААА
2. ААААГ
3. …… Определите в этом списке количество слов с чётными номерами, которые не начинаются с буквы Л и при этом содержат в своей записи не менее двух букв И.

from itertools import *
num = 0
result = 0
for x in product(sorted('АЛГОРИТМ'), repeat=5):
    s = ''.join(x)
    num += 1
    if num % 2 == 0 and s[0] != 'Л' and s.count('И') >= 2:
        result += 1
print(result)

k%2==0 четный
k%2!=0 нечетный
s[0] not in 'аг' не начинается с А и Г
'а' not in s and 'г' not in s не содержит А и Г
s.count('р')>=2 содержат в своей записи не менее двух букв Р

Вася составляет 5-буквенные слова, в которых есть только буквы З, И, М, А, причём в каждом слове есть ровно одна гласная буква и она встречается ровно 1 раз. Каждая из допустимых согласных букв может встречаться в слове любое количество раз или не встречаться совсем. Словом считается любая допустимая последовательность букв, не обязательно осмысленная. Сколько существует таких слов, которые может написать Вася?

from itertools import *
num = 0
result = 0
for x in product(sorted('ЗМГ'), repeat=5):
    s = ''.join(x)
    num += 1
    if s.count('Г') == 1:
        result += 2
print(result)

или

alph = 'ЗМГ' #буквы З,М и гласная
num = 0
for a in alph:
for b in alph:
for c in alph:
for d in alph:
for e in alph:
s = a + b + c + d + e
if s.count('Г') == 1: #только 1 гласная в слове
num += 2 #2 потому что гласная может быть буквой А, а может И
print(num)

Все четырёхбуквенные слова, составленные из букв А, Б, З, И, записаны в алфавитном порядке и пронумерованы начиная с 1. Ниже приведено начало списка.
1. АААА
2. АААБ
3. АААЗ
4. АААИ
5. ААБА … Под каким номером стоит слово ИЗБА?

from itertools import *
num = 0
for x in product(sorted('АБЗИ'), repeat = 4):
   s = ''.join(x)
   num += 1
   if s == 'ИЗБА':
      print(num)

или

alf = 'АБЗИ'
num = 0
for a in alf:
    for b in alf:
        for c in alf:
            for d in alf:
                    s = a + b + c + d
                    num += 1
                    if s == 'ИЗБА':
                        print(num)

Задание 9

sum(p) - сумма повторяющихся чисел
len(np) - количество неповторяющихся
len(set(p)) - количество разных повторяющихся

Если нужен номер, то счетчик считает ДО if, если количество - после if

[:3] # первые 3
[3:] # все остальные с 4-го до конца, а не последние 3.
[-3:] # последние 3
[1:-1] # со 2-го до предпоследнего

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

одно число, которое повторяется трижды, одно число, которое повторяется дважды, остальные числа не повторяются, пример строки:
55599123 5 и 9 повторяются
сумма повторяющихся чисел в строке превышает сумму всех неповторяющихся чисел 5+5+5+9+9 > 1+2+3
Надо найти все такие строки и посчитать сумму чисел в строке с наиБОЛЬШИМ номером.

Создаем файл 9 в пайчарме в рабочей директории, копируем таблицу в файл.

for s in open('9'):
a = [int(x) for x in s.split()] #все цифры
p = [x for x in a if a.count(x) >1] #повторяющиеся
np = [x for x in a if a.count(x) == 1] #неповторяющиеся
if len(p) == 5 and len(set(p)) == 2 and len(np) == 3: #5 повторяющихся цифр, 2 разных цифры повторяются, 3 не повторяется)
if sum(p) > sum(np):
print(sum(a))

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

Пример удовлетворяющий условию: 111234 Копируем в файл 9 таблицу. Среднее арифметическое это сумма деленная на количество.

num=0
for s in open('9'):
a = [int(x) for x in s.split()]
num += 1
p = [x for x in a if a.count(x) >1] #повторяющиеся
np = [x for x in a if a.count(x) == 1] #неповторяющиеся
if len(p) == 3 and len(set(p)) == 1 and len(np) == 3: #3 повторяющихся цифр, 1 разных цифры повторяются, 3 не повторяется)
if p[0] > (sum(np)/len(np)):
print(num)

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

sp = 0
for s in open("9"):
    a = [int(x) for x in s.split()]
    p = [x for x in a if a.count(x) > 1]
    np = [x for x in a if a.count(x) == 1]
    sp += 1
    if len(p) == 0 and len(set(p)) == 0 and len(np) == 6:
        sorr = sorted(a)
        chost = sorr[:3]  # первые 3
        chmin = sorr[3:]  # все остальные с 4го до конца
        if sum(chost) * 2 < sum(chmin):
            print(sp)

Задание 10

Дефисы заменяем на ничего (без пробела!!!) потом все считаем

Проверяем ТОМ! Может быть несколько глав с одинаковым номером, но в разных томах.

После каждого поиска выделяем заново

Задание 11

На предприятии каждой изготовленной детали присваивают серийный номер, содержащий десятичные цифры, 26 латинских букв (без учёта регистра) и символы из 16 350-символьного специального алфавита. В базе данных для хранения каждого серийного номера отведено одинаковое и минимально возможное число байт. При этом используется посимвольное кодирование серийных номеров, все символы кодируются одинаковым и минимально возможным числом бит. Известно, что для хранения 510 серийных номеров отведено более 96 Кбайт памяти. Определите минимально возможную длину серийного номера. В ответе запишите только целое число.

from math import *
i = ceil(log2(16386)) # i
nom = ceil((96 *1024)/510) # байт на 1 номер
x = ceil(nom * 8 / i) # длина номера
print(x)

При регистрации в компьютерной системе каждому пользователю выдаётся пароль, состоящий из семи символов и содержащий только десятичные цифры и символы из 26-символьного набора прописных латинских букв. В базе данных для хранения сведений о каждом пользователе отведено одинаковое и минимально возможное целое число байт. При этом используют посимвольное кодирование паролей, все символы кодируют одинаковым и минимально возможным количеством бит. Кроме собственно пароля, для каждого пользователя в системе хранятся дополнительные сведения, для чего выделено целое число байт; это число одно и то же для всех пользователей. Для хранения сведений о 20 пользователях потребовалось 500 байт. Сколько байт выделено для хранения дополнительных сведений об одном пользователе? В ответе запишите только целое число – количество байт.

from math import *
i = ceil(log2(36))                # размер символа, округляем вверх
ves = ceil(7 * i / 8)        # байт на пароль, округляем в большую сторону
print(500 // 20 - ves) # считаем кол-во байт на 1 пользователя, берем целое, отнимаем байты на пароль

На предприятии каждой изготовленной детали присваивается серийный номер, состоящий из 248 символов. В базе данных для хранения каждого серийного номера отведено одинаковое и минимально возможное число байт. При этом используется посимвольное кодирование серийных номеров, все символы кодируются одинаковым и минимально возможным числом бит. Известно, что для хранения 75 600 серийных номеров требуется более 16 Мбайт памяти. Определите минимально возможную мощность алфавита, используемого для записи серийных номеров. В ответе запишите только целое число.

from math import *
for N in range(2,1000):       #перебираем разные варианты кодировки от 2 до тысячи (у других от 1 до 100000000000)
    i = ceil(log2( N ) )     #размер символа, округляем вверх
    numb = ceil( 248 * i /8 ) #размер номера в байтах, округляем вверх
    if 75600*numb > 16*2**20:  #как только размер всех номеров превысит 16 Мбайт (или 16*1024*1024)
        print(N)     #выводим мощность алфавита
        break        #останавливаем, так как нам хватит минимальной

Задание 12

Перевод в двоичную

print(bin(3147))

0b убираем

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

print(int("100000000000",2))

Задание 13

В терминологии сетей TCP/IP маской сети называют двоичное число, которое показывает, какая часть IP-адреса узла сети относится к адресу сети, а какая – к адресу узла в этой сети. Адрес сети получается в результате применения поразрядной конъюнкции к заданному адресу узла и его маске. Широковещательным адресом называется специализированный адрес, в котором на месте нулей в маске стоят единицы. Адрес сети и широковещательный адрес не могут быть использованы для адресации сетевых устройств.
Сеть задана IP-адресом одного из входящих в неё узлов $146.180.173.153$ и сетевой маской $255.192.0.0.$ Определите наибольший IP-адрес данной сети, который может быть присвоен компьютеру. В ответе укажите сумму числовых значений октетов найденного IP-адреса. Например, если бы найденный адрес был равен $111.22.3.44,$ то в ответе следовало бы записать $180.$

from ipaddress import *
n = ip_network('146.180.173.153/255.192.0.0', 0)
print(n[-2]) #если бы был наименьший, вместо -2 бы писали 1; если адрес сети - просто n

$180.$

В терминологии сетей TCP/IP маской сети называется двоичное число, определяющее, какая часть IP-адреса узла сети относится к адресу сети, а какая – к адресу самого узла в этой сети. Обычно маска записывается по тем же правилам, что и IP-адрес, – в виде четырёх байтов, причём каждый байт записывается в виде десятичного числа. При этом в маске сначала (в старших разрядах) стоят единицы, а затем с некоторого разряда – нули. Адрес сети получается в результате применения поразрядной конъюнкции к заданному IP-адресу узла и маске. Например, если IP-адрес узла равен 231.32.255.131, а маска равна 255.255.240.0, то адрес сети равен 231.32.240.0.
Для узла с IP-адресом 117.191.176.37 адрес сети равен 117.191.160.0. Чему равен третий слева байт маски? Ответ запишите в виде десятичного числа.

from ipaddress import *
for mask in range(33): #перебираем разные варианты маски с количеством единиц от 0 до 32 (больше обычно не бывает)
net = ip_network(f'117.191.176.37/{mask}', 0)  #F означает форматированная строка; 0 не забываем, так питон за вас посчитает адрес сети
  print(net, net.netmask)

Питон выдаст таблицу:
адрес сети/кол-во единиц в маске   маска
байт это 3 цифры после точки
Всего единиц и нулей всегда 32

Задание 14

Значение арифметического выражения $6^{2030} + 6^{100} - x,$ где $x$ — целое положительное число, не превышающее $2030,$ записали в $6$-ричной системе счисления. Определите наименьшее количество нулей, которое может содержаться в этой записи. В ответе запишите число в десятичной системе счисления.

for x in range(1, 2031): #Не забудьте добавить 1 к 2030
a = 6**2030 + 6**100 - x
k0 = 0
while a>0:
if a%6==0:
k0+=1
a//=6
print(k0) #1930

Значение арифметического выражения $39^{483} + 39^{235} - x,$ где $x$ — целое положительное число, не превышающее $9430,$ записали в $39$-ричной системе счисления. Определите максимально возможное количество нулей в 39-ричной записи числа, являющегося значением данного арифметического выражения. В ответе запишите только целое число.

maxx = 0
for x in range(1, 9431): #Не забудьте добавить 1 к 9430
a = 39**483 + 39**235 - x
k0 = 0
while a>0:
if a%39==0:
k0+=1
a//=39
maxx = max(maxx, k0)
print(maxx) #250

Значение арифметического выражения 7³⁵⁰ + 7¹⁵⁰ –– x, где x –– целое положительное число, не превышающее 2300, записали в семеричной системе счисления. Определите наибольшее значение x, при котором в семеричной записи числа, являющегося значением данного арифметического выражения, содержится ровно 200 нулей. В ответе запишите число в десятичной системе счисления.

# Поскольку ищем наибольший Х, идем по убыванию
for x in range(2300, 0, -1):
a = 7**350 + 7**150 - x
# посчитываем количество нулей без хранения семеричной записи
k = 0
while a > 0:
if a % 7 == 0:
k += 1
a //= 7
if k == 200:
print(x)
# после первого подходящего прерываем цикл
break

Значение арифметического выражения $$2 \cdot 2187^{567} + 729^{566} - 2 \cdot 243^{565} + 81^{564} - 2 \cdot 27^{563} - 6561$$ записали в системе счисления с основанием $27.$ Определите в $27$-ричной записи числа количество цифр с чётным числовым значением, превышающим $9.$

n = 2 * 2187**567 + 729**566 - 2 * 243**565 + 81**564 - 2 * 27**563 - 6561
q = 0
while n:
    r = n % 27
    q += r % 2 == 0 and r > 9
    n //= 27
print(q)   #940

Значение арифметического выражения 6 ∙ 512³⁹⁵ + 7 ∙ 64³⁹⁶ + 3 ∙ 8³⁹⁸ + 5 ∙ 8³⁹³ + 300 записали в системе счисления с основанием 64. Сколько значащих нулей содержится в этой записи?

n = 6*512**395+7*64**396+3*8**398+5*8**393+300
q = 0
while n:
if n % 64 == 0:
q += 1
n //= 64
print(q) #587

Задание 15

Обозначим через ДЕЛ(n, m) утверждение «натуральное число n делится без остатка на натуральное число m»; и пусть на числовой прямой дан отрезок B = [50; 70]. Для какого наибольшего натурального числа А формула ДЕЛ(x, A) \/ ((x ∈ B) → ¬ДЕЛ(x, 16)) тождественно истинна (т.е. принимает значение 1) при любом натуральном значении переменной х?

def f(x, A):
return (x % A == 0) or (50 <=x <= 70)) <= not (x % 16 == 0)

for A in range(1, 10000):
if all(f(x, A) for x in range(1, 1000)):
print(A) # 64

Смотрим максимальное 64, или в проге ищем с конца for A in range(1100, 0, -1): и ставим break

Конъюнкция	A ∧ B	A and B
Дизъюнкция	A ∨ B	A or B
Инверсия	¬A	not(A)
Импликация	A → B	A <= B
Эквиваленция	A ≡ B	A == B

Для ручного решения:

A → B = ¬ A V B
¬ (A V B) = ¬ A /\ ¬ B

Задание 16

1 функция: F

Алгоритм вычисления функции F(n), где n – целое число, задан следующими соотношениями:
F(n) = n, если n < 10;
F(n) = n – 1 + F(n – 1), если n ≥ 10.
Чему равно значение выражения F(8567) – F(8563)?

f = [0] * 8568   # Создаем список f, содержащий 8568 элементов, каждый из которых равен 0
for n in range(0, 10):
    f[n] = n              # 1 условие
for n in range(10, 8568):     
    f[n] = n - 1 + f[n - 1]   # 2 условие
print(f[8567] - f[8563])  # Вычисляем и выводим разность из условия

то же самое, только сам еще берет целое через int:

Алгоритм вычисления функции F(n), где n – целое число, задан следующими соотношениями:
F(n) = n, если n < 10;
F(n) = (n – 2) × F(n – 5), если n ≥ 10.
Чему равно значение выражения (F(3220) – 2 × F(3215)) / F(3210)?
В ответе запишите целую часть полученного числа.

n_max = 3220
f = [0] * (n_max + 1)
for n in range(0, 10):
    f[n] = n
for n in range(10, n_max + 1):
    f[n] = (n - 2) * f[n - 5]
print(int((f[3220] - 2 * f[3215]) / f[3210]))  # 10333008

2 функции: F и G:

Алгоритм вычисления функций F(n) и G(n), где n – целое число, задан следующими соотношениями:
F(n) = 2 × (G(n – 3) + 8);
G(n) = 2 × n, если n < 10;
G(n) = G(n – 2) + 1, если n ≥ 10.
Чему равно значение выражения F(15548)?

Сначала приведем задачу к первому виду

G(n) = 2 × n, если n < 10;
G(n) = G(n – 2) + 1, если n ≥ 10.
Чему равно значение выражения F(15548)=2 × (G(n – 3) + 8)=2 × (G(15548 – 3) + 8)=2 × (G(15545 + 8)

а потом решаем точно как и прошлое, только G вместо F

g = [0] * 15552  # Список для хранения значений G(n), индексы от 0 до 15551 (с запасом для G(n-3) при n=15548)

for n in range(10):   # Заполняем G(n) для n < 10
    g[n] = 2 * n
for n in range(10, 15552): # Заполняем G(n) для n ≥ 10
    g[n] = g[n - 2] + 1
print(2 * (g[15545] + 8))  # F(15548) = 2 × (G(15548 - 3) + 8) = 2 × (G(15545) + 8)

# 15588

Задание 17

Задание 18 робот собирает монеты

На этапе заливки таблицы формулами проверяем, не накосячили ли!

Задание 19-21 кучи камней

1 куча. Ходы -3, -7, : 4. Победа - куча из 15 и меньше] камней. То есть при 16 проигрыш.
19. Петя не может выиграть за один ход, но при любом ходе Пети Ваня может выиграть своим первым ходом. Это классическая проигрышная позиция для Пети — Ваня выигрывает гарантированно, независимо от хода Пети - берем lose1 (all).

def moves(heap):
    return heap - 3, heap - 7, heap // 4

def game_over(heap):
    return heap <= 15

def win1(heap):
    return not game_over(heap) and any(game_over(m) for m in moves(heap)) # Выигрыш в 1 ход: можно сделать ход, который сразу завершает игру. not game_over(heap) — проверяем, что игра ещё не закончилась. any(game_over(m) for m in moves(heap)) — существует ход, который завершает игру

def loose1(heap):
    return not win1(heap) and all(win1(m) for m in moves(heap)) # Проигрышная позиция для игрока, все возможные ходы ведут в выигрышные для противника позиции (win1)

def win2(heap):
    return not win1(heap) and any(loose1(m) for m in moves(heap)) # Выигрыш в 2 хода: есть ход, который ведёт в проигрышную для противника позицию (loose1)

def loose2(heap):
    return all(win1(m) or win2(m) for m in moves(heap)) \
            and any(win2(m) for m in moves(heap))  # Проигрышная позиция в 2 хода, все ходы ведут в позиции, где противник выигрывает за 1 или 2 хода, и хотя бы один ход даёт противнику выигрыш в 2 хода (т.е. позиция именно проигрышная, не ничейная)

z19 = [S for S in range(16, 1000) if loose1(S)]  # позиции, где Петя проигрывает (Ваня выигрывает первым ходом)
z20 = [S for S in range(16, 1000) if win2(S)]    #  позиции, где Петя выигрывает вторым ходом (win2)
z21 = [S for S in range(16, 1000) if loose2(S)]  #  позиции, где Ваня выигрывает первым или вторым ходом, но не гарантированно первым

print(min(z19))
print(z20[0], z20[1])
print(min(z21))

1 куча. +1, +5, *3, Победа - [124 и более камней.То есть при 123 проигрыш. 19. Петя не может выиграть за один ход, но при любом ходе Пети Ваня может выиграть своим первым ходом.

def move(heap):
	return heap + 1, heap + 5, 3 * heap

def game_over(heap):
	return heap >= 124

def win1(heap):
	return not game_over(heap) and any(game_over(m) for m in move(heap))

def loose1(heap):
	return not win1(heap) and all(win1(m) for m in move(heap))

def win2(heap):
	return not win1(heap) and any(loose1(m) for m in move(heap))

def loose2(heap):
	return all(win1(m) or win2(m) for m in move(heap)) \
	       and any(win2(m) for m in move(heap))

z19 = [S for S in range(1, 124) if loose1(S)]  # 124 потому что 124-1=123 а нам и надо до 123
z20 = [S for S in range(1, 124) if win2(S)]
z21 = [S for S in range(1, 124) if loose2(S)]

print(min(z19))
print(z20[0], z20[1])
print(min(z21))

2 кучи. Ходы +1, *3. Победа = [65 и более камней. То есть при 64 проигрыш. В первой куче 6 камней, во второй S.
19. Ваня выиграл своим первым ходом после неудачного первого хода Пети.
Петя не смог выиграть за один ход (это not win1). Петя сделал конкретный неудачный ход, после которого Ваня смог выиграть за один ход. НЕ требуется, чтобы Петя проигрывал при любом своём ходе — достаточно, что существует хотя бы один ход, ведущий к выигрышу Вани берем lose1_bad (any).

def moves(heap):
    h1, h2 = heap
    return (h1 + 1, h2), (3 * h1, h2), (h1, h2 + 1), (h1, 3 * h2)

def game_over(heap):
    return sum(heap) >=65

def win1(heap):
    return not game_over(heap) and \
        any(game_over(m) for m in moves(heap))

def lose1(heap):
    return not win1(heap) and \
        all(win1(m) for m in moves(heap))  # Петя не может выиграть за 1 ход, а Ваня сможет выиграть за 1 ход.

def lose1_bad(heap):
    return not win1(heap) and \
        any(win1(m) for m in moves(heap))  # Петя не может выиграть за 1 ход, но при этом есть хотя бы один ход, после которого Ваня сможет выиграть за 1 ход.

def win2(heap):
    return not win1(heap) and \
        any(lose1(m) for m in moves(heap))

def lose2(heap):
    return all(win1(m) or win2(m) for m in moves(heap)) and \
        any(win2(m) for m in moves(heap))

z19 = [S for S in range(1, 59) if lose1_bad((6, S))]  #64-6=58 и берем на 1 больше 59
z20 = [S for S in range(1, 59) if win2((6, S))]
z21 = [S for S in range(1, 59) if lose2((6, S))]

print(min(z19))
print(z20[0], z20[1])
print(min(z21))

Желтым то же что и в задаче на 1 кучу

19 Две кучи камней. Первый ход делает Петя. За один ход игрок может:
- убрать из одной из куч (по своему выбору) 3 камня;
- уменьшить количество камней в одной из куч (по своему выбору) в 3 раза ( округляется до меньшего).
Игра завершается - в двух кучах суммарно 53 камня или меньше.
В начальный момент в первой куче 19 камней, во второй куче — S камней; S≥35.
Известно, что Ваня выиграл своим первым ходом после неудачного хода Пети. Укажите минимальное значение S, при котором такая ситуация возможна.
20 Для игры, описанной в задании 19, найдите наименьшее и наибольшее значения S, при которых у Пети есть выигрышная стратегия, причём одновременно выполняются два условия:
- Петя не может выиграть за один ход;
- Петя может выиграть своим вторым ходом независимо от того, как будет ходить Ваня.
Найденные значения запишите в ответе в порядке возрастания.
21 Для игры, описанной в задании 19, найдите наименьшее значение S, при котором одновременно выполняются два условия:
- у Вани есть выигрышная стратегия, позволяющая ему выиграть первым или вторым ходом при любой игре Пети;
- у Вани нет стратегии, которая позволит ему гарантированно выиграть первым ходом.

def moves(heap):
    h1, h2 = heap
    return (h1 - 3, h2), (h1//3, h2), (h1, h2 - 3), (h1, h2//3)

def gameover(heap):
    return sum(heap) <=53

def win1(heap):
    return not gameover(heap) and \
        any(gameover(m) for m in moves(heap))

def lose1(heap):
    return not win1(heap) and \
        all(win1(m) for m in moves(heap))   # Петя не может выиграть никаким своим первым ходом! Какой бы ход Петя ни сделал, Ваня сможет выиграть своим следующим ходом


def canlose1(heap):
    return any(not gameover(m) and  \
               win1(m) for m in moves(heap))  # У Пети есть хотя бы 1 проигрышный ход, после которого Ваня выиграет

def win2(heap):
    return not win1(heap) and \
        any(lose1(m) for m in moves(heap))

def lose2(heap):
    return all(win1(m) or win2(m) for m in moves(heap)) and \
        any(win2(m) for m in moves(heap))

z19 = [S for S in range(35, 1000) if canlose1((19, S))]  #54-19=35
z20 = [S for S in range(35, 1000) if win2((19, S))]
z21 = [S for S in range(35, 1000) if lose2((19, S))]

print(min(z19))            # 38
print(z20[0], z20[-1])   # 108  323 
print(min(z21))         # 111

Лайфхак на 1 кучу

при увеличении

Выигрыш при куче в 58 и более камней, значит 57 ближайший проигрыш. Действия
+1
+4
*2

все знаки меняются
19) делим ближайший проигрышный вариант на 2, округляем вниз 57/2=28
20) отнимаем 1 28 - 1 = 27
отнимаем 4 28 - 4 = 24 берем для решения 21-го
делим на 2 (если нацело не делится, не берем!) 28 / 2 = 14
берем 2 меньших
21) меньший ответ задания 20 (кроме ответа от деления) минус 1 24 - 1 =23

при уменьшении

Выигрыш при куче 15 и менее, то есть проигрыш при 16
-3
-7
: 4

все знаки меняются
19) умножим ближайший проигрышный вариант на цифру из деления 16 * 4 = 64
20) прибавим 3 64 + 3 = 67 и следующая 68, так как надо 2 минмальных
21) к ответу от 20-го прибавим 3 или 7 с проверкой 67 + 3 = 70 67 + 7 = 74
П1 70 - 3 = 67
В1 67 - 3 = 64 67 - 7 = 60 67/4 = 16
П2 64
В1 vin
Ответ в 21-м 70

Задание 22. Процессы

Выделяем столбец С - Данные - текст по столбцам: галочки на разделитель и на точка с запятой - ок. Процессы разделятся на 2 столбика. Объединяем ячейки заголовка для наглядности. В новом столбике заменяем пустые ячейки на нули (смотрите чтобы был числовой формат).
Добавляем нулевой процесс в конец столбика A ОБЯЗАТЕЛЬНО.
Рядом оставляем столько же столбцов, сколько в процессах. Заголовок делаем Время влияющих процессов.
в E2 пишем =ВПР(С2;$A:$H;8;0) копируем и вставляем на 2 столбца.
Дальше еще 2 столбца: 1 начало 2-й конец процессов.
Начало: =макс(E2:F2)+1 (максимум из времени влияющих +1)
Конец: =G2+B2-1
Копируем числа из столбика КОНЕЦ, вставляем рядом "Вставить как числа". Сортируем по возрастанию. Отсчитываем 17 процессов. Видим, что 17 процессов завершились за 12 минут. Или если спросят сколько процессов за 12 минут смотрим минуты и пишем ответ 17 процессов.

Задание 23

def F(x, y): # возвращает количество путей из x в y 
# если начальное больше
if x > y or x == <число, не содержащееся в траектории>:
return 0 # возвращаем 0 путей 
# количество путей из числа в само себя равно 1 
if x == y:
return 1
# в остальных случаях x < y 
return <Сумма функций с учетом команд>
# в выводе указываем начало, конец, а также все промежуточные числа по траектории
print(F(<начальное знач>, <доп. знач. 1>) * F(<доп. знач. 2>, <конечное знач.>) )

ceil(n / 2) - округлить в большую сторону при делении на 2, надо подключить from math import ceil
floor - округляет в меньшую сторону, from math import floor
n**0.5 - извлечение корня, возвращает вещественное число (float), даже если корень целый, поэтому используют с округлением в меньшую сторону

Если НЕ содержит 2 числа, то вместо if n == deny: пишем if n in deny:
а вместо 12, к примеру (12,18) именно так в скобках.

Если содержит 2 числа, то будет разбиение не на 2 промежутка, а на 3.

Если надо увеличить старшую цифру числа на 1 это значит прибавить 10 (старшая это десятки, увеличили на 1 десяток).

Исполнитель преобразует число на экране. У исполнителя есть две команды, которые обозначены номерами:
1. Прибавь 1
2. Поменяй местами
Первая из этих команд увеличивает число на экране на 1. Вторая команда может применяться только к числу, у которого цифра разряда десятков по значению меньше цифры, стоящей в разряде единиц, и действует, заменяя число на экране числом, в котором цифры двух младших разрядов поменялись местами. Программа для исполнителя — это последовательность команд. Сколько существует программ, для которых при исходном числе 110 результатом является число 154?

def F(s, e):
if s > e:
return 0
if s == e:
return 1
return F(s + 1, e) + F(int(f"{str(s)[0]}{str(s)[2]}{str(s)[1]}")
if str(s)[1]<str(s)[2] else 100000, e)
print(F(110, 154)) #34

$154 ?$

Исполнитель преобразует число на экране.
У исполнителя есть две команды, которые обозначены латинскими буквами:
1) Прибавь 1
2) Поменяй местами
Первая из этих команд увеличивает число на экране на 1. Вторая команда применяется только к числу, у которого цифра в разряде десятков по значению меньше цифры, стоящей в разряде единиц, и действует, заменяя число на экране числом, в котором цифры двух младших разрядов поменялись местами. Программа для исполнителя – это последовательность команд. Сколько существует программ, для которых при исходном числе 100 результатом является число 150?
Траектория вычислений программы - это последовательность результатов выполнения всех команд программы. Например, для программы АВА при исходном числе 13 траектория состоит из чисел 14, 41, 42.

def f(n, targ):
    if n >= targ:
        return n == targ
    ns = list(str(n))
    if ns[-2] < ns[-1]:
        ns[-2], ns[-1] = ns[-1], ns[-2]
        return f(n + 1, targ) + f(int(''.join(ns)), targ)
    return f(n + 1, targ)
print(f(100, 150))   #35

Исполнитель преобразует число на экране. У исполнителя есть две команды, которые обозначены латинскими буквами:
1) Прибавь 1
2) Измени цифру
Первая из этих команд увеличивает число на экране на 1. Вторая команда применяется только к числу, у которого в записи присутствует хотя бы одна цифра 1, и действует, заменяя число на экране числом, в котором каждая цифра 1 заменена на цифру 2. Программа для исполнителя - это последовательность команд. Сколько существует программ, для которых при исходном числе 11 результатом является число 92?
Траектория вычислений программы – это последовательность результатов выполнения всех команд программы. Например, для программы ABA при исходном числе 13 траектория состоит из чисел 14, 24, 25.

def f(n, targ):
    if n >= targ:
        return n == targ
    ns = str(n)
    if ns.count('1'):
        nn = int(ns.replace('1', '2'))
        return f(n + 1, targ) + f(nn, targ)
    return f(n + 1, targ)
print(f(11, 92))   # 1408

Задание 24

Задание 25

Задание 26

: Обновлено: 03 июля 2026