Алгоритм вычисления значения функции F[n], где п - натуральное число, задан следующими соотношениями:
F(n) = 1 при n = 1
F(n) = 2 * n * F(n - 1), если п >1
Чему равно значение выражения (F(2024) - 4 * F(2023)) / F(2022) ?

from functools import *
@lru_cache(None)
def F(n):
    if n == 1:
        return 1
    if n > 1:
        return 2 * n * F(n - 1)

for i in range(2025):
    F(i)

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

# Ответ: 16362024

Импорт модуля `functools`, который предоставляет несколько полезных функций, связанных с функциональным программированием.

Декоратор `@lru_cache(None)`, который используется для кэширования результатов функции `F`, чтобы избежать повторных вычислений.

Объявление функции `F` с аргументом `n`.

Проверка условия: если `n` равно 1.

Проверка условия: если `n` больше 1.

Возвращение результата умножения `2 * n` на рекурсивный вызов функции `F` с аргументом `(n - 1)`.

Цикл `for`, который проходит по значениям от 0 до 2024 (не включая 2025).

Вызов функции `F` для каждого значения `i` в диапазоне от 0 до 2024.

Вывод на экран результата выражения `(F(2024) - 4 * F(2023)) // F(2022)`, которое содержит вызовы функции `F` с различными аргументами.

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.
1. Строится двоичная запись числа N.
2. Далее эта запись обрабатывается по следующему правилу:
а] Если сумма цифр двоичной записи числа четная, то к этой записи справа дописывается 0, и затем два левых разряда двоичной записи заменяются на 10.
б) Если сумма цифр двоичной записи числа нечетная, то к этой записи справа дописывается 1, а затем два левых разряда двоичной записи заменяются на 11. Полученная таким образом запись является двоичной записью искомого числа R.
3. Результат переводится в десятичную систему и выводится на экран.

Укажите максимальное число N, после обработки которого с помощью этого алгоритма получается число R, меньшее 20.

R = []
for n in range(2000):
    s = bin(n)[2:]
    if s.count('1') % 2 == 0:
        s = '10' + s[2:] + '0'
    else:
        s = '11' + s[2:] + '1'
    r = int(s, 2)
    if r < 20:
        R.append(n)
print(max(R))

# Ответ: 12

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

Цикл `for`, который проходит по значениям от 0 до 1999.

Преобразование числа `n` в двоичное представление и сохранение его в переменной `s`, исключая первые два символа, которые обозначают приставку "0b".

Проверка условия: если количество единиц в строке `s` делится на 2 без остатка.

Изменение строки `s`, добавляя приставку "10" в начало и "0" в конец исходной строки `s`, начиная с третьего символа.

Выполняется, если условие в пункте 4 не выполнено.

Изменение строки `s`, добавляя приставку "11" в начало и "1" в конец исходной строки `s`, начиная с третьего символа.

Преобразование строки `s` из двоичного представления в целое число и сохранение результата в переменной `r`.

Проверка условия: если значение `r` меньше 20.

Добавление значения `n` в список `R`.

Вывод на экран максимального значения из списка `R`.

Значение арифметического выражения 3**100 - х, где х - целое положительное число, не превышающее 2030, записали в троичной системе счисления.
Определите наименьшее значение х, при котором в троичной записи числа, являющегося значением данного арифметического выражения, содержится ровно два нуля.
В ответе запишите число в десятичной системе счисления.

 
for x in range(1, 2030):
    n = 3**100 - x
    R = []
    while n > 0:
        R = [n % 3] + R
        n //= 3
    if R.count(0) == 2:
        print(x)
        break

# Ответ: 9

Цикл `for`, который проходит по значениям `x` от 1 до 2029.

Вычисление значения `n` как разности между `3` в степени `100` и `x`.

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

Цикл `while`, который выполняется до тех пор, пока `n` больше нуля.

Добавление остатка от деления числа `n` на 3 в начало списка `R`.

Целочисленное деление числа `n` на 3 для перехода к следующей цифре троичной записи.

Проверка условия: если в списке `R` ровно два раза встречается цифра 0.

Вывод значения `x`, которое соответствует условиям задачи.

Прерывание цикла, если было найдено первое подходящее значение `x`.

Дано арифметическое выражение:
123XAB_31 + 3CEX321_31

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

alphabet = sorted('0123456789QWERTYUIOPASDFGHJKLZXCVBNM')
for x in alphabet[:31]:
    A = int(f'123{x}AB', 31)
    B = int(f'3CE{x}321', 31)
    if (A + B) % 17 == 0:
        print((A + B) // 17)

# Ответ: 179431046

Создание отсортированного списка `alphabet`, содержащего символы цифр и заглавных латинских букв.

Цикл `for`, который перебирает первые 31 элемент из списка `alphabet`.

Преобразование строки `f'123{x}AB'` в число в системе счисления 31 и сохранение этого числа в переменной `A`.

Преобразование строки `f'3CE{x}321'` в число в системе счисления 31 и сохранение этого числа в переменной `B`.

Проверка условия: если сумма чисел `A` и `B` делится на 17 без остатка.

Вывод на экран частного от деления суммы чисел `A` и `B` на 17.

Напишите программу, которая перебирает целые числа, большие 600 000, в порядке возрастания и ищет среди них такие, среди делителей которых есть хотя бы одно число, оканчивающееся на 7, но не равное 7 и самому числу. Необходимо вывести первые 5 таких чисел, и наименьший делитель, оканчивающийся на 7, не равный 7 и самому числу.
Формат вывода: для каждого из 5 таких найденных чисел в отдельной строке сначала выводится само число, затем  — наименьший делитель, оканчивающийся на 7, не равный 7 и самому числу.

def divisors(x):
    div = []
    for j in range(2, int(x ** 0.5) + 1):
        if x % j == 0:
            div += [j, x // j]
    return sorted(set(div))

cnt = 0
for n in range(600001, 10**10):
    d = [x for x in divisors(n) if x % 10 == 7 and x != 7]
    if len(d) > 0:
        print(n, min(d))
        cnt += 1
        if cnt == 5:
            break

# Ответ:
# 600001 437
# 600002 47
# 600003 1227
# 600005 217
# 600012 16667

f = open('27.txt')
n = int(f.readline())
M = [int(i) for i in f]
res = 0
for i in range(n):
    for j in range(i+1, n):
        for k in range(j+1, n):
            s1 = M[i]
            s2 = M[j]
            s3 = M[k]
            if s1 > s2 < s3:
                res = max(res, (s1 - s2) + (s3 - s2))
print(res)
res = 0
m1 = m2 = m3 = r1 = 0
for i in range(n - 2):
    m1 = max(m1, M[i])
    if m1 - M[i+1] > r1:
        r1 = m1 - M[i + 1]
        m2 = M[i + 1]
    m3 = M[i + 2]
    res = max(res, m3 - m2 + r1)
print(res)

Текстовый файл состоит из заглавных букв латинского алфавита А, B, C, D, E и F.
Определите максимальное количество идущих подряд символов в прилагаемом файле, среди которых пара символов DE (в указанном порядке) встречается не более 240 раз.
Для выполнения этого задания следует написать программу.

s = open('24.txt').readline()
s = s.replace('DE', 'D E').split()
maxi = -1
for i in range(len(s)):
    r = ''.join(s[i:i+241])
    maxi = max(maxi, len(r))
print(maxi)

Чтение строки из файла '24.txt' и сохранение этой строки в переменной `s`.

Замена подстроки 'DE' на 'D E' в строке `s` с последующим разделением строки на список слов.

Инициализация переменной `maxi` c начальным значением -1 для хранения максимальной длины подстроки.

Цикл `for`, который проходит по индексам элементов в списке `s`.

Создание строки `r`, объединив элементы списка `s` от индекса `i` до индекса `i+241`.

Обновление переменной `maxi` значением, равным максимуму между текущим значением `maxi` и длиной строки `r`.

Вывод наибольшей длины строки `r` из всех подстрок в переменной `s`.

from itertools import *
cnt = 0
for p in product('0123456789AB', repeat=6):
    num = ''.join(p)
    if num[0] != '0' and num.count('7') == 1:
        if len([x for x in num if int(x, 12) > 9]) <= 3:
            cnt += 1
print(cnt)

# Ответ: 888669

bit_all = 1_475_560 * 280
pixels = 1024 * 960
i = 13
bit = bit_all / (pixels * i)
print(bit)

# 32.3296 -> 32

Найдем вес переданного пакета: 1 474 560 бит * 280 с = 412 876 800 бит
Найдет количество бит, необходимых для кодирования одного пикселя: 2^13 = 8192. (13 бит)
Найдем количество снимков: 412 876 800 / (1024 * 960 * 13) ~ 32.307
Округляем в нижнюю сторону, получаем 32 снимка.
Ответ: 32

from ipaddress import *
for mask in range(32+1):
    net = ip_network(f'170.155.137.181/{mask}', 0)
    if str(net) == f'170.155.136.0/{mask}':
        print(net.netmask) 

from ipaddress import *
maxi = []
for mask in range(32+1):
    net = ip_network(f'170.155.137.181/{mask}', 0)
    if str(net) == f'170.155.136.0/{mask}':
        maxi.append(int(str(net.netmask).split('.')[2]))

print(max(maxi)) 

def F(x, A):
    B = 70 <= x <= 90
    return (x % A == 0) or (B <= (x % 27 != 0))

for A in range(1, 1000):
    if all(F(x, A) for x in range(1, 10000)):
        print(A)

from ipaddress import *

net = ip_network('106.184.0.0/255.255.240.0', 0)
cnt = 0
for ip in net:
    s = f'{ip:b}'
    if s.count('1') % 3 == 0:
        cnt += 1
print(cnt)

M = [int(x) for x in open('17.txt')]
D = [x for x in M if x % 32 == 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) < len(D):
            R.append(x + y)
print(len(R), max(R))