1. Строится запись числа N в системе счисления с основанием 12.
2. Далее эта запись обрабатывается по следующему правилу:

а) если число N делится на 4, то слева к нему приписывается «2», а справа «64»;

б) если число N на 4 не делится, то в конец числа дописывается его максимальная цифра в системе счисления с основанием 12.
Полученная таким образом запись является двенадцатеричной записью искомого числа R.

3. Результат переводится в десятичную систему и выводится на экран.

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

alphabet = sorted('0123456789QWERTYUIOPASDFGHJKLZXCVBNM')
def convert(num, base):
    r = ''
    while num > 0:
        r += alphabet[num % base]
        num //= base
    return r[::-1]


R = []
for n in range(1, 10000):
    s = convert(n, 12)
    if n % 4 == 0:
        s = '2' + s + '64'
    else:
        s += max([x for x in s])
    r = int(s, 12)
    if r > 1799:
        R.append(r)
print(min(R))

# Ответ: 1806

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

Определение функции convert с аргументами num (число для конвертации) и base (основание системы счисления).

Инициализация пустой строки r, которая будет содержать конвертированное число.

Начало цикла, который будет выполняться, пока число num больше нуля.

Добавление символа из алфавита в строку r, соответствующего остатку от деления числа num на base.

Целочисленное деление числа num на base.

Возврат результата функции, перевернутого конвертированного числа.

Создание пустого списка R для хранения результата.

Цикл, перебирающий числа от 1 до 9999.

Конвертация числа n в двенадцатеричную систему и сохранение результата в строке s.

Проверка условия: если число n делится на 4 без остатка.

Если условие из пункта 11 выполняется, изменяем строку s, добавляя к ней '2' в начале и '64' в конце.

Добавляем к строке s максимальное значение из всех символов.

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

Проверка условия: если результат r больше 1799.

Добавление числа r в список R.

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

В прилагаемом файле определите максимальное количество символов в непрерывной подпоследовательности, состоящей из идущих подряд групп символов KLMN в указанном порядке, при этом в начале и в конце искомой последовательности группа символов KLMN может быть неполной.

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

s = open('24.txt').readline()
count = 3
maxi = 0
for i in range(len(s)-3):
    if s[i:i+4] in ('KLMN', 'LMNK', 'MNKL', 'NKLM'):
        count += 1
        maxi = max(maxi, count)
    else:
        count = 3
print(maxi)

# Ответ: 182

Чтение строки из файла "24.txt" и сохранение ее в переменную s.

Инициализация переменной count со значением 3, которая будет использоваться для подсчета последовательности.

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

Цикл, перебирающий индексы от 0 до len(s)-4 для итерации по всем четверным подстрокам строки s.

Проверка, содержится ли текущая четверная подстрока строки s в заданных последовательностях 'KLMN', 'LMNK', 'MNKL' или 'NKLM'.

Увеличение значения переменной count на 1, если найдена подходящая четверная последовательность.

Обновление значения переменной maxi на максимальное из текущего значения и count.

В случае, если текущая четверная подстрока не соответствует заданным последовательностям:

Сброс значения переменной count до 3 для начала подсчета заново.

Вывод максимального количества найденных последовательностей заданного типа в строке s после завершения цикла.

M = [int(x) for x in open('17.txt')]

M = [1, 2, 3, 4, 5]
for i in range(len(M)-1):
    x, y = M[i:i+2]
    print(f'{x}{y}', end=' ') 

# Вывод: 
# 12 23 34 45

M = [1, 2, 3, 4, 5]
for i in range(len(M)-2):
    x, y, z = M[i:i+3]
    print(f'{x}{y}{z}', end=' ')  

# Вывод:
# 123 234 345

M = [1, 2, 3, 4, 5]
for i in range(0, len(M)):
    for j in range(i+1, len(M)):
        x, y = M[i], M[j]
        print(f'{x}{y}', end=' ')
    print()

# Вывод:
# 12 13 14 15
# 23 24 25
# 34 35
# 45

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

s = open('24.txt').readlines()
maxi = 0
for x in s:
    count = 2
    for i in range(len(x)-2):
        if x[i:i+3] in ('XYZ', 'YZX', 'ZXY'):
            count += 1
            maxi = max(maxi, count)
        else:
            count = 2
print(maxi)

# Ответ: 53

Чтение всех строк из файла "24.txt" и сохранение их в виде списка строк в переменную s.

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

Цикл, который перебирает строки из списка s для анализа каждой строки отдельно.

Инициализация переменной count со значением 2, которая будет использоваться для подсчета последовательности в текущей строке.

Внутренний цикл, который перебирает индексы от 0 до длины строки x минус 2 для итерации по каждой тройной подстроке в текущей строке.

Проверка условия: если текущая тройная подстрока x присутствует в кортеже заданных строк 'XYZ', 'YZX' или 'ZXY'.

Увеличение значения переменной count на 1, если найдена подходящая тройная последовательность.

Обновление значения переменной maxi на большее из текущего значения и count.

В случае, если текущая тройная подстрока не соответствует заданным последовательностям:

Сброс значения переменной count на 2 для начала подсчета заново в текущей строке.

Вывод наибольшего значения переменной maxi.

Текстовый файл состоит из символов T, U, V, W, X, Y и Z.

Определите в прилагаемом файле максимальную длину подстроки, состоящую из пар символов XX, YY или ZZ в произвольном порядке, при этом ни одна пара не должна повторяться два раза подряд.

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

s = open('24.txt').readline()
for a in 'TUVW':
    s = s.replace(a, ' ')
for a in 'XYZ':
    while a*4 in s:
        s = s.replace(a*4, f'{a*2} {a*2}')
    while a*3 in s:
        s = s.replace(a*3, f'{a*2} {a*2}')
print(max([len(x) for x in s.split()]))
print(max(map(len, s.split())))

# Ответ: 52

Чтение первой строки из файла "24.txt" и сохранение ее содержимого в переменную s.

Цикл, который перебирает символы 'T', 'U', 'V', 'W' для замены их на пробел в строке s.

Замена каждого символа 'T', 'U', 'V', 'W' на пробел в строке s.

Цикл, который перебирает символы 'X', 'Y', 'Z' для выполнения дополнительных преобразований в строке s.

Пока последовательность из 4 символов a присутствует в строке s.

Замена последовательности из 4 символов a на строку, состоящую из 2 символов a, пробела и еще 2 символов a.

Пока последовательность из 3 символов a присутствует в строке s.

Замена последовательности из 3 символов a на строку, состоящую из 2 символов a, пробела и еще 2 символов a.

Вывод максимальной длины слова после разделения строки s по пробелам и определения максимальной длины с помощью List Comprehension.

Еще одна аналогичная запись.

1. раздели на 2
2.  вычти 1

Составьте алгоритм получения из чиcла 65 числа 4, содержащий не более 5 команд. В ответе запишите только номера команд.

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

def F(a, b, t):
    if a < b or len(t) > 5:
        return 0
    elif a == b and len(t) <= 5:
        print(t)
        return 1
    else:
        return F(a / 2, b, t+'1') + F(a-1, b, t+'2')

F(65, 4, '')  

# Ответ: 21111

Определение функции F с тремя параметрами a, b, и t.

Проверка условия: если a меньше b или длина строки t превышает 5 символов.

Возврат значения 0, если условие из пункта 2 истинно.

Другое условие: если a равно b и длина строки t не превышает 5 символов.

Вывод текущего состояния строки t.

Возврат значения 1, если условие из пункта 4 истинно.

В случае, если ни одно из вышеперечисленных условий не выполнено.

Рекурсивный вызов функции F с различными значениями аргументов: для первого вызова a уменьшается вдвое и к строке t добавляется символ '1', для второго вызова a уменьшается на 1, к строке t добавляется символ '2'.

Вызов функции F с начальными значениями a=65, b=4, и пустой строкой t.

Найдите последние семь цифр суммы F(2020) + F(2200).

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

from functools import *
@lru_cache(None)
def F(n):
    if n < 2025:
        return n**2
    if 2025 <= n < 2050:
        return 2 * F(n-1) - F(n-2) + n
    if 2050 <= n <= 2100:
        return F(n-1) + 2 * F(n-2) + 3 * F(n-3)
    if n > 2100:
        return 2 * F(n-1) + F(n-2) + n

print(str(F(2020) + F(2200))[-7:])

Ответ: 5098903

Импорт всех функций из модуля functools.

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

Определение функции F с одним параметром n.

Проверка условия: если n меньше 2025.

Возврат квадрата числа n, если условие из пункта 4 истинно.

Проверка условия: если n больше либо равно 2025 и меньше 2050.

Возврат значения, вычисленного по формуле, если условие из пункта 6 истинно.

Проверка условия: если n от 2050 до 2100 включительно.

Возврат значения, вычисленного по формуле, если условие из пункта 8 истинно.

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

Возврат значения, вычисленного по формуле, если условие из пункта 10 истинно.

Вызов функции F с аргументами 2020 и 2200, вычисление их суммы, преобразование в строку, взятие последних семи символов и вывод результата.

s = '3721893721'

summa1 = 0
for x in s:
    summa1 += int(x)
print(summa1)

summa2 = 0
for i in range(0, 10):
    summa2 += s.count(str(i)) * i
print(summa2)

# или: summa2 = s.count('1') + s.count('2') * 2 + ...

summa3 = sum(map(int, s))
print(summa3)

summa4 = sum([int(x) for x in s])
print(summa4)

# или: summa4 = sum([int(x) for x in s if x.isdigit()])

В некоторой системе счисления с основанием p < 37 выполняется равенство TH_p + NQ_p + U_p = 1L7_p

Определите значение 𝑝 и укажите его в ответе в десятичной системе счисления.

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

for p in range(31, 36+1):  # U - 30
    if int('TH', p) + int('NQ', p) + int('U', p) == int('1L7', p):
        print(p)

# Ответ: 33

Цикл for, который проходит по значениям p от 31 до 36 включительно. Комментарий указывает на то, что в данном случае символ 'U' представляет число 30 в системе счисления с основанием p.

Условное выражение, которое проверяет, равно ли суммарное значение чисел, представленных строками 'TH', 'NQ' и 'U' в системе счисления с основанием p, числу, представленному строкой '1L7' в той же системе счисления.

Если условие из предыдущего пункта истинно, выводится значение p, при котором выполняется условие.