import turtle as t

t.tracer(0)

t.fd(10)  # t.bk(10)
t.rt(90)  # t.lt(90)

t.up()
t.down()

x, y = 0, 0
t.goto(x, y)
t.dot(2, 'red')

t.done()

from itertools import product
from itertools import permutations

combinations = list(product([1, 2, 3], repeat=2))
for combination in combinations:
    print(combination)

perms = list(permutations("abc"))
for perm in perms:
    print(''.join(perm))
   

from ipaddress import *
net = ip_network('адрес узла/маска', 0)
print(net, net.netmask, net.num_addresses)
   

Одна увеличивает глубину рекурсии:

import sys
sys.setrecursionlimit(10000)
   

Вторая ускоряет вычисления через использование кэширования:

from functools import *
@lru_cache(None)
def F(n):
   

from fnmatch import fnmatch
if fnmatch('123', '*?3'):
    pass
   

import string
alphabet = string.ascii_uppercase
print(alphabet)  # ABCDEFGHIJKLMNOPQRSTUVWXYZ

print(string.punctuation)
# !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
   

import math as m
print(m.sqrt(16))
print(m.ceil(7/2))
   

1. Строится восьмеричная запись числа N.

2. а) если количество чётных цифр в записи числа нечётно, то к трём последним разрядам восьмеричной записи справа дописывается 46;

б) если количество чётных цифр в записи числа чётно, то остаток от деления числа на 8 умножается на 5, переводится в восьмеричную запись и дописывается слева.

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

R = []
for n in range(81, 10000):
    s = oct(n)[2:]  # f'{n:o}'
    chet = [x for x in s if x in '02468']
    if len(chet) % 2 != 0:
        s = s[-3:] + '46'
    else:
        x = (n % 8) * 5
        s = oct(x)[2:] + s
    r = int(s, 8)
    R.append(r)
print(min(R))

# Ответ: 38

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

Цикл, который перебирает числа от 81 до 9999.

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

Формирование списка, содержащего только символы, которые являются четными цифрами.

Если количество четных цифр в строке нечетное.

Если условие из пункта 5 выполняется, изменяем строку s, добавляя к ней '46'.

Вычисляем значение x как остаток от деления n на 8, умноженное на 5.

Обновляем значение s, добавляя к нему начальную часть, преобразованную из x в восьмеричную систему.

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

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

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

n = 24
num_2 = bin(n)[2:]  # 11000
num_8 = oct(n)[2:]  # 30
num_16 = hex(n)[2:] # 18

n = 24
num_2 = f'{n:b}'  # 11000
num_8 = f'{n:o}'  # 30
num_16 = f'{n:x}' # 18

from string import *
alphabet = digits + ascii_uppercase
# alphabet = sorted('0123456789QWERTYUIOPASDFGHJKLZXCVBNM')

def my_convert(num, base):
    result = ''
    while num > 0:
        result += alphabet[num % base]
        num //= base
    return result[::-1]

n = 24
num_2 = my_convert(n, 2)   # 11000
num_8 = my_convert(n, 8)   # 30
num_16 = my_convert(n, 16) # 18
num_3 = my_convert(n, 3)   # 220

r = int(num_base, base)
print(int('1000', 2))  # 8

s = '101001'

# Добавить '10' справа (в конец)
s = s + '10'  # 10100110


# Добавить '01' слева (в начало)
s = '01' + s  # 0110100110
print(s)

# Добавить '+' по середине
s = s[:len(s)//2] + '+' + s[len(s)//2:]
# 01101*00110

# Заменить все нули на единицы, а единицы на нули
s = s.replace('1', '*')
s = s.replace('0', '1')
s = s.replace('*', '0')

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.