f = open(’24_M5.txt’)
mx = 0
temp_str = ’’#строка,в которую мы будем сохранять строку, подходящую по условию
count_A = 0
soglas = ’QWRTPSDFGHJKLZXCVBNM’
for i in range(1000):
    s = f.readline()
    c = 0
    count_A += s.count(’A’)#после того как определили букву,
    #считаем, сколько раз она встретилась в файле.
    for j in range(len(s)):
        if s[j] in soglas:#если текущий символ является согласной
            c += 1#то увеличиваем счётчик
            if c > mx:#если счётчик больше mx
                mx = c#то перезаписываем mx
                temp_str = s# в temp_str указываем текущую строку
        else:#в ином случае
            c = 0#обнуляем счётчик
d = {x:temp_str.count(x) for x in sorted(’AEUIOY’)}
#словарь, в котором в качестве ключа указана гласная буква,
#а в качестве значения - сколько раз она встречается в temp_str
print([x for x in d.keys() if d[x] == min(d.values())])#определяем букву, которая встречается реже всего
print(count_A)

f = open(’24_M5.txt’)
mx = 0
temp_str =’’#строка, в которую мы будем сохранять подходящую по условию нам строку
glas = ’AEIUOY’
soglas = sorted(’QWERTYUIOPASDFGHJKLZXCVBNM’)#изначально создали список всех букв
count_DD = 0
for x in glas:#проходимся по строке гласных и удаляем их из списка всех букв.
    #в этом списке останутся только согласные буквы
    soglas.remove(x)
for i in range(1000):
    s = f.readline().strip()#считываем строку, функция strip убирает символ переноса строки(\n)
    ans = s# копируем значение строки в ans для того чтобы позже,
    # в случае чего, её и сохранить в temp_str
    for x in soglas:#заменяем все согласные на один какой-то символ
        s = s.replace(x,’*’)
    s = s.split(’*’)#делаем по нему сплит
    for i in range(len(s)-1):#проходимся по списку s
        if len(’*’.join(s[i:i+2])) >= mx:#если длина подстроки с ровно одной согласной больше mx
            mx = len(’*’.join(s[i:i+2]))#то перезаписываем mx
            temp_str = ans# в temp_str передаём текущую строку
    count_DD += ans.count(’DD’)
    #после определения пары мы считаем, сколько раз она встретилась во всём файле
d = {x+y:temp_str.count(x+y) for x in sorted(set(temp_str)) for y in sorted(set(temp_str))}
# c помощью словаря
#мы создаем в ключах всевозможные пары символов,
# в значениях - мы считаем сколько раз встретилась такая пара рядом стоящих символов в temp_str
print([x for x in d.keys() if d[x] == max(d.values())])#выводим пару,
# которая встретилась больше всего раз
print(count_DD)#выводим количество раз встреченных DD в файле.

Способ решения 1:
s = open(’24_M4.txt’).readline()
alph = sorted(’QWERTYUIOPASDFGHJKLZXCVBNM’)
for x in alph:
    for y in alph:
        s = s.replace(’M’+x+’K’+ y,f’M{x}K {x}K{y}’)#заменяем всевозможные подстроки на тройки,
        # разделяя пробелом,
        # для того чтобы избежать четверку этих символов вместе
s = s.split()
print(max(len(x) for x in s))#вычисляем максимальную длину

Способ решения 2:
s = open(’24_M4.txt’).readline()
mx = 0
temp_str = s[:3]# добавляем изначально первые три символа из строки s в наращиваемую строку
for i in range(3,len(s)):
    if temp_str[-3] + temp_str[-1] != ’MK’:
        #если первый элемент из тройки(третий от конца temp_str) не равен M
        #и третий элемент из тройки(первый от конца temp_str) не равен K,
        #тогда можем добавлять в наращиваемую строку текущий символ
        temp_str += s[i]
        mx = max(mx,len(temp_str))#вычисляем максимальную длину
    else:#в ином случае
        mx = max(mx,len(temp_str))
        temp_str = temp_str[-2] + temp_str[-1] + s[i]#новая наращиваемая строка строится
        # из двух последних символа temp_str и текущего символа
print(mx)

Способ решения 1:
s = open(’24_M4.txt’).readline()
alph = sorted(’QWERTYUIOPASDFGHJKLZXCVBNM’)
for x in alph:
    s = s.replace(’KAZ’ + x,f’KAZ AZ{x}’)#заменяем всевозможные комбинации на такие комбинации,
    # где данная четверка не находится вместе
s = s.split()#делаем сплит по пробелу
print(max(len(x) for x in s))#вычисляем максимальную длину

Способ решения 2:
s = open(’24_M4.txt’).readline()
mx = 0
temp_str = s[:3]#изначально в наращиваемую строку добавляем первых три элемента строки s
for i in range(3,len(s)):
    if temp_str[-3:] != ’KAZ’:#если последние три символа наращиваемой строки не равны KAZ,
        # то в наращиваемую строку мы можем добавить новый символ.
        temp_str += s[i]
        mx = max(mx,len(temp_str))#вычисляем максимум
    else:#в ином случае
        mx = max(mx,len(temp_str))
        temp_str = temp_str[-2]+temp_str[-1]+s[i]#мы образуем новую наращиваемую строку длиной 3,
        #из последних двух символов наращиваемой строки и текущего символа.
print(mx)

s = open(’24_M3.txt’).readline().split(’.’)
alph = sorted(’QWERTYUIOPASDFGHJKLZXCVBNM’)
first_chapter = ’’.join(alph[:13])
second_chapter = ’’.join(alph[13:])
mx = 0
for i in range(1,len(s)-2):
    substr = ’.’.join(s[i:i+5])
    count_first = sum([substr.count(x) for x in first_chapter])
    count_second = sum([substr.count(x) for x in second_chapter])
    if count_first > count_second:
        mx = max(mx,len(substr))
print(mx)

s = open(’24_M3.txt’).readline()
for x in ’AEUIOY’:
    s = s.replace(x,’A’)#заменяем все гласные на какую-то одну гласную для удобства проверки
s = s.split(’.’)
mx = 0
for i in range(len(s)-6):
    substr = ’.’.join(s[i:i+7])#скрепляем элементы списка в строку,
    #между элементами списка будет символ точка
    if substr.count(’A’) > 15:
        mx = max(mx,len(substr))#вычисляем максимум
print(mx)

s = open(’24_M2.txt’).readline().replace(’DA’,’D A’).split(’ ’)#разделяем DA на D A и делаем сплит,
#таким образом, мы не удалим символы из файла
need_substrings = [x for x in s if ’AD’ in x]
#собираем в список все подстроки, которые нам подходят по условию
print(len(max(need_substrings,key = len)),len(need_substrings))#вычисляем длину самой длинной подстроки,
#а также общее количество подходящих по условию подстрок

s = open(’24_M2.txt’).readline()
count = 0
for i in range(len(s)-3):
    if (s[i] == s[i+3] and s[i+1] != s[i+2]) or (s[i] != s[i+3] and s[i+1] == s[i+2]):
        #нам подходят два случая: когда первый и последний символы совпадают, а второй и третий - нет,
        #и когда первый и последний символы не совпадают, а второй и третий - да.
        #Только в таких случаях мы можем образовать палиндром заменой ровно одного символа.
        count += 1
print(count)

Способ решения 1:
s = open(’24_M1.txt’).readline()
d = {x: 0 for x in sorted(set(s))}#словарь, в котором в качестве ключа у нас буква,
# а в качестве значения - количество раз, сколько она встречается по определенному условию
for i in range(len(s)-2):
    if s[i] == s[i+2]:#если два рядом стоящих символа равны между собой
        d[s[i+1]] += 1#то к значению той буквы, что стоит между этой пары добавляем единицу
#выводим букву и количество раз, сколько она встречается в файле
print([(x,s.count(x)) for x in d.keys() if d[x] == min(d.values())])

Способ решения 2:
s = open(’24_M1.txt’).readline()
count = [0]*len(set(s))# создаем массив длиной количества различных букв в файле,
#каждый элемент - это количество раз встреченных определенных букв по заданному условию.
#к примеру,count[0] - количество раз, сколько встретилась буква А,
#count[1] - количество раз, сколько встретилась буква B и так далее.
for i in range(len(s)-2):
    if s[i] == s[i+2]:
        count[ord(s[i+1]) % 65] += 1 #Функция ord возращает числовое значение буквы,
        #остаток от 65 берется поскольку у буквы A в таблице символов значение 65,
        #у буквы B - 66 и так далее.
        #нужно сделать так, чтобы числовое значение буквы А стало равным 0,
        #для B - 1 и так далее, для этого и берем остаток.
letter = chr(count.index(min(count)) + 65)
#Функция chr обратна ord, числовое значение превращает в символ
#определяем букву, которая встречалась минимальное количество раз по заданному условию.
print(letter,s.count(letter))

Способ решения 1:
s = open(’24_M1.txt’).readline()
d = {x: 0 for x in sorted(set(s))}#словарь, в котором в качестве ключа у нас буква,
# а в качестве значения - количество раз сколько она встречается по определенному условию
for i in range(len(s)-2):
    if s[i] == s[i+1]:#если два рядом стоящих символа равны между собой
        d[s[i+2]] += 1#то к значению той буквы, что стоит за этой парой, добавляем единицу
#выводим букву и количество раз, сколько она встречается в файле
print([(x,s.count(x)) for x in d.keys() if d[x] == max(d.values())])

Способ решения 2:
s = open(’24_M1.txt’).readline()
count = [0]*len(set(s))# создаем массив длиной количества различных букв в файле,
#каждый элемент - это количество раз встреченных определенных букв по заданному условию.
#к примеру,count[0] - количество раз, сколько встретилась буква А,
#count[1] - количество раз, сколько встретилась буква B и так далее.
for i in range(len(s)-2):
    if s[i] == s[i+1]:
        count[ord(s[i+2]) % 65] += 1 #Функция ord возвращает числовое значение буквы,
        # остаток от 65 берется, поскольку у буквы A в таблице символов значение 65,
        # у буквы B - 66 и так далее.
        # нужно сделать так, чтобы числовое значение буквы А стало равным 0,
        # для B - 1 и так далее, для этого и берем остаток.
letter = chr(count.index(max(count)) + 65)
# Функция chr обратна ord, числовое значение превращает в символ
#определяем букву, которая встречалась максимальное количество раз по заданному условию.
print(letter,s.count(letter))

f = open(’24__3ns0t.txt’)
s = f.read()

s = s.split(’B’)
mx = -1

for i in range(len(s) - 53):
    new_s = ’’.join(s[i:i+54])
    mx = max(len(new_s) + 53, mx)

print(mx)

s = open(’24_13715.txt’).readline().replace(’A’,’*’).replace(’E’,’*’)
mn = 10**20
start = 0 if s[0] == ’*’ else 1
end = 0 if s[-1] == ’*’ else 1
s = s.split(’*’)
for i in range(start, len(s) - end):
    if len(s[i]) > 0:
        word = ’*’+s[i] + ’*’
        if len(word) < mn:
            mn = len(word)
print(mn)

s = open(’24_13715.txt’).readline().replace(’A’,’*’).replace(’E’,’*’).split(’*’)
mx = 0
for i in range(len(s)-1):
    word = ’*’.join(s[i:i+2])
    mx = max(mx,len(word))
print(mx)

s = open(’24.txt’).readline()
cnt = mx = i = 0
while i < len(s) - 2:
    if s[i] in ’BCD’ and s[i + 1] in ’AE’ and s[i + 2] in ’BCD’:
        cnt += 1
        mx = max(mx, cnt)
        i += 3
    elif i > 1 and s[i - 2] in ’BCD’ and s[i - 1] in ’AE’and s[i] in ’BCD’:
        cnt = 1
        i += 1
    else:
        cnt = 0
        i += 1
print(mx)

s = open(’24_13715.txt’).readline().replace(’CD’, ’C_D’).split(’_’)
mx = 0
for i in range(len(s)-50):
    word = ’’.join(s[i:i+51])
    mx = max(mx,len(word))
print(mx)

s = open(’24_12946.txt’).readline()
cnt = mx = i = 0
digits = ’0123456789’
while i < len(s) - 1:
    if s[i] in digits and s[i + 1] not in digits or (s[i] not in digits and s[i + 1] in digits):
        cnt += 1
        mx = max(mx, cnt)
        i += 2
    elif i > 1 and (s[i - 1] in digits and s[i] not in digits or s[i - 1] not in digits and s[i] in digits):
        cnt = 1
        i += 1
    else:
        cnt = 0
        i += 1
print(mx)

s = open(’24_12946.txt’).readline()

m = ’QWRTYUIOPSGHJKLZXVNM’

for i in m:
    s = s.replace(i,’*’)
s = s.split(’*’)
num = [x for x in s if len(x) > 0 and int(x,16) > 132]
print(len(set(num)))

s = open(’24_12946.txt’).readline()
digits = ’0123456789’
count = 0
words = []
for i in range(len(s)):
    # Чтобы иметь возможность проверить подстроки в конце строки, воспользуемся
    # контролируемым блоком кода, чтобы избежать ошибки выхода за границы индексации
    try:
        if s[i] in digits and int(s[i]) > 0:
            if all(s[j] not in digits for j in range(i + 1, i + int(s[i]) + 1)):
                count += 1
                words += [s[i:i + int(s[i]) + 1]]
    except IndexError:
        pass
print(len(words))

def divs(x):
    d =set()
    for i in range(2,int(x**0.5)+1):
        if x % i == 0:
            d |= {i,x//i}
    return sorted(d)
f = open(’24_12946.txt’).readline().strip()
for i in ’QWERTYUIOPASDFGHJKLZXCVBNM’:
    f = f.replace(i,’*’)
f = f.split(’*’)
numb = [x for x in f if len(x) > 0 and len(divs(int(x))) == 6]
print(len(set(numb)))

def simple(x):return x > 1 and all(x % y for y in range(2,int(x**0.5)+1))
f = open(’24_12946.txt’).readline().strip()
for i in ’QWERTYUIOPASDFGHJKLZXCVBNM’:
    f = f.replace(i,’*’)
f = f.split(’*’)

simple_numbers = [x for x in f if len(x) > 0 and simple(int(x))]
print(len(simple_numbers))