import sys
sys.setrecursionlimit(10000)

def F(n):
    if n == 1:
        return 1
    if n > 1:
        return (n - 1) * F(n - 1)

print((2*F(2024) - F(2023)) / F(2022))

def F(a, b):
    if a >= b:
        return a == b
    return F(a+1, b) + F(a+2, b) + F(a+3, b)

print(F(3, 9) * F(9, 13))

M = [int(x) for x in open('17.txt')]
D = [x for x in M if x > 0]
R = []
for i in range(len(M)-1):
    x, y = M[i], M[i+1]
    if x < 0 or y < 0:
        if x + y % min(D) == 0:
            R.append(x + y)
print(len(R), max(R))

cnt = 0
for s in open('9.csv'):
    M = [int(x) for x in s.split(';')]
    copied = [x for x in M if M.count(x) == 2]
    not_copied = [x for x in M if M.count(x) == 1]
    if len(copied) == 4 and len(not_copied) == 2:
        if sum(copied) < sum(not_copied):
            cnt += 1
print(cnt)

def F(x, y):
    return (x + y <= 26) or (y <= x - 4) or (y >= A)

for A in range(1000):
    if all(F(x, y) for x in range(100) for y in range(100)):
        print(A)

user = "Андрей"
action = "покупка"
log_message = f'Пользователь {user} зашел на сайт и выполнил действие: {action}'
print(log_message)
# Пользователь Андрей зашел на сайт и выполнил действие: покупка

Определите, какова сумма протяжённостей дорог из пункта F в пункт B и из пункта E в пункт D.

Данный код позволяет нам в универсальном случае определить последовательность вершин графа. И если знаем вершины, то не сложно найти длины и сумму длин!

from itertools import permutations

table = '12 15 16 21 23 24 32 36 37 42 47 51 56 61 63 65 73 74'
graph = 'AB BA AF FA FB BF FE EF BD DB ED DE EC CE DG GD CG GC'

for per in permutations('ABCDEFG'):
    new_table = table
    for i in range(1, 7+1):
        new_table = new_table.replace(str(i), per[i-1])
    if set(new_table.split()) == set(graph.split()):
        print('1 2 3 4 5 6 7')
        print(*per)

# 1 2 3 4 5 6 7
# B D E G A F C

# FB = 53, ED = 2, => 55

# 1 2 3 4 5 6 7
# F E D C A B G

# ED = 53, FB = 2, => 55

Импортируем функцию permutations из модуля itertools для генерации всех возможных перестановок элементов.

Определяем строку 'table', представляющую набор чисел, разделенных пробелами, которые описывают соединения в графе.

Определяем строку 'graph', которая описывает возможные связи между буквами A, B, C, D, E, F, G в графе.

Запускаем цикл, перебирающий все возможные перестановки букв A, B, C, D, E, F, G.

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

Запускаем вложенный цикл, который проходит по всем числам от 1 до 7.

Заменяем каждое число в 'new_table' на соответствующую букву из текущей перестановки 'per', используя индексы.

Проверяем, совпадает ли множество уникальных элементов в 'new_table' с множеством уникальных элементов в 'graph'.

Если множества совпадают, выводим строку '1 2 3 4 5 6 7', что означает, что найдено подходящее соответствие.

Печатаем текущее соответствие букв из перестановки, используя распаковку для форматированного вывода.

Автомат обрабатывает натуральное число N > 1 по следующему алгоритму:

1. Строится двоичная запись числа N.
2. В записи последний ноль заменяется на первые две цифры в полученной записи.
3. Запись записывается справа налево (в обратную сторону).
4. Полученное двоичное число переводится в десятичную систему счисления.

Для какого максимального значения в результате работы алгоритма получится число 119?

Про возможность обрабатывать исключения try я писал в этом посте.

R = []
for n in range(2, 1000):
    s = f'{n:b}'
    try:
        m = s.rindex('0')
        s = s[:m] + s[:2] + s[m+1:]
        s = s[::-1]
        r = int(s, 2)
        if r == 119:
            R.append(n)
    except Exception as E:
         print(s, E)
print(max(R))

# Ответ: 58

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

Запускаем цикл, перебирающий числа от 2 до 999 включительно.

Преобразуем текущее число n в строку, содержащую его двоичное представление.

Начинаем блок try для обработки возможных исключений в последующем коде.

Находим индекс последнего вхождения символа '0' в строке s.

Формируем новую строку: оставляем часть до последнего '0', вставляем первые два символа исходной строки и добавляем оставшуюся часть исходной строки после последнего '0'.

Переворачиваем строку s задом наперед.

Преобразуем строку s обратно в целое число из двоичной системы счисления.

Проверяем, равно ли получившееся число 119.

Если условие верно, добавляем исходное число n в список R.

Обрабатываем возможные исключения, которые могут возникнуть в блоке try.

В случае исключения выводим текущую строку s и описание ошибки E.

Выводим максимальное число из списка R.

У исполнителя есть три команды, которым присвоены номера:
A. Прибавить 2
B. Прибавить 3
C. Умножить на 2

Сколько существует программ, для которых при исходном числе 3 результатом является число 20, а последняя в них команда - A или С?

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

def F(a,b, c: str):
    if a >= b:
        return a == b and c[-1] != 'B'
    return F(a + 2, b, c + 'A') + F(a + 3, b, c + 'B') + F(a*2, b, c + 'C')

print(F(3,20,''))

# Ответ: 60

Объявление функции F с тремя параметрами: числовыми параметрами a, b и строковым параметром c

Проверяем, если значение a больше или равно значению b

Возвращаем результат логического выражения, которое проверяет, что a равно b и последняя буква строки c не равна 'B'

В противном случае возвращаем сумму результатов рекурсивных вызовов функции F с измененными параметрами: добавляем к a значения 2, 3 и умножаем его на 2, а к строке c добавляем 'A', 'B' и 'C' соответственно

Вызываем функцию F с начальными аргументами 3, 20 и пустой строкой, затем выводим результат вызова

Определите в прилагаемом файле максимальное количество идущих подряд символов, среди которых никакая гласная буква не стоит раньше согласной.

Примечание. Гласные буквы латинского алфавита: A, E, I, O, U, Y.

Аудио с пояснением к коду решения оставлю в комментариях.

s = open('24.txt').readline()
for x in 'AEIOUY':
    s = s.replace(x, '* ')
print(max([len(x) for x in s.split()]))

# Ответ: 9052

Считываем первую строку из файла '24.txt' и сохраняем ее в переменную s

Начинаем цикл, который будет поочередно обрабатывать каждую букву из строки 'AEIOUY'

Заменяем каждую гласную букву x в строке s на комбинацию символов '* '

Разбиваем строку s по пробелам, находим длину каждого полученного фрагмента и выводим максимальную длину этих фрагментов

Сеть задана IP-адресом 119.124.96.0 и маской сети 255.255.240.0. Сколько в этой сети IP-адресов, двоичная запись которых оканчивается на 0?

from ipaddress import *
net = ip_network('119.124.96.0/255.255.240.0', 0)
cnt = 0
for ip in net:
    s = f'{ip:b}'
    # if s.endswith('0'):
    if s[-1] == '0':
        cnt += 1
print(cnt)

# Ответ: 2048

Импортируем все классы и функции из модуля ipaddress, который обеспечивает удобную работу с IP-адресами и сетями

Создаем объект сети net с заданным IP-адресом и маской подсети, указываем, что это IPv4 сеть с использованием маски в десятичном формате

Инициализируем счетчик cnt, который будет хранить количество IP-адресов, удовлетворяющих определенному условию

Начинаем цикл, который перебирает каждый IP-адрес в заданной сети net

Преобразуем текущий IP-адрес ip в двоичное строковое представление с помощью форматирования

Cтарая версию проверки, тоже работает.

Проверяем, оканчивается ли двоичная строка s на '0', то есть является ли последний бит нулем

Увеличиваем счетчик cnt на единицу, если последний бит IP-адреса равен нулю

Выводим количество IP-адресов в сети net, у которых последний бит равен нулю

Автомат обрабатывает натуральное число N (0≤N≤255) по следующему алгоритму:
1) Строится восьми битная двоичная запись числа N.
2) Удаляются средние 4 цифры.
3) Полученное число переводится в десятичную запись и выводится на экран.

Какое наибольшее число, меньшее 110, после обработки автоматом даёт результат 7?

R = []
for n in range(0, 255+1):
    s = f'{n:b}'.zfill(8)
    s = s[:2] + s[-2:]
    r = int(s, 2)
    if n < 110 and r == 7:
        R.append(n)
print(max(R))

# Ответ: 107

Создаем пустой список для хранения подходящих чисел

Начинаем цикл, перебираем числа от 0 до 255 включительно

Переводим текущее число n в двоичную строку, дополняя нулями до 8 бит (в формате строки)

Оставляем только первые две и последние две цифры двоичного представления

Преобразуем полученную строку обратно в целое число в десятичной системе счисления

Проверяем, если число меньше 110 и преобразованное число равно 7

Добавляем число в список R, если оно соответствует условиям

Выводим наибольшее число из списка R

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) # {1, 2, 3, 4, 5}

intersection_set = set1.intersection(set2)
print(intersection_set) # {3}

difference_set = set1.difference(set2)
print(difference_set) # {1, 2}

symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set) # {1, 2, 4, 5}

Все пятибуквенные слова, в составе которых могут быть только русские буквы Л, А, Й, М, записаны в алфавитном порядке и пронумерованы начиная с 1.
Вот начало списка:
1. ААААА
2. ААААЙ
3. ААААЛ
4. ААААМ
5. АААЙА

Под каким номером в списке идёт последнее слово, которое не содержит ни одной буквы М, ни одной буквы Л и не содержит букв Й стоящих рядом?

Простейшую вариацию решения этого номера опубликую в комментариях к этому посту. Делитесь своими решениями!

from itertools import *
R = []
for num, p in enumerate(product(sorted('ЛАЙМ'), repeat=5), 1):
    word = ''.join(p)
    if 'М' not in word and 'Л' not in word:
        if 'ЙЙ' not in word:
            R.append(num)
print(max(R))

# Ответ: 274

Импортируем все функции из модуля itertools для работы с итераторами.

Инициализируем пустой список R для хранения номеров подходящих комбинаций.

Используем product для генерации всех возможных комбинаций 5 букв из слова 'ЛАЙМ', сортируем буквы и пронумеровываем их с 1.

Объединяем кортеж p в строку для получения текущего слова.

Проверяем, что буквы 'М' и 'Л' отсутствуют в текущем слове.

Проверяем, что двойная буква 'ЙЙ' отсутствует в текущем слове.

Если условия выполнены, добавляем номер комбинации в список R.

Выводим максимальный номер из списка R, который соответствует самой последней подходящей комбинации.