Способ решения 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))

s = open(’24_13100.txt’).readline()
d = {x: s.count(x) for x in sorted(set(s))}
mx = 0
letters = ’’
for i in d.items():
    if i[1] > mx:
        mx = i[1]
        letters += i[0]
# Определили две самые часто встречающиеся буквы
letters = letters[-2:]
print(s.count(letters[::-1]))

s = open(’24_13100.txt’).readline()
#словарь, в котором записана буква и сколько раз она встречается в файле
d = {x: s.count(x) for x in sorted(set(s))}
mn = 10**20
symb = ’’
#определили букву, которая встречается меньше всего раз и сколько раз она встречается
for i in d.items():
    if i[1] < mn:
        mn = i[1]
        symb = i[0]
m = {x: 0 for x in sorted(set(s))}
for i in range(len(s)):
    if s[i] == symb:
        m[s[i+1]] += 1
        m[s[i-1]] += 1
# определили букву, которая встречается чаще всего рядом с Y
x = [i for i in m.items() if i[1] == max(m.values())]
print(x[0][0] + str(s.count(x[0][0])))

f = open(’24_13100.txt’).readline()
while ’TXTXT’ in f:
    f = f.replace(’TXTXT’, ’TXTTXT’)
print(f.count(’TXT’))

f = open(’C:/2414.txt’)
a = f.readlines()

c = 0
for s in a:
    if s.count(’KRL’) > 1:
        c += 1
print(c)

f = open(’C:/2413.txt’)
a = f.readlines()

# Ведём поиск строки,
# в которой буква O встречается чаще
mx = 0
ms = ’’
for s in a:
    if s.count(’O’) > mx:
        mx = s.count(’O’)
        ms = s

# Ищем букву,
# которая встречается после согласной чаще всего
mx = 0
b = ’’
abc1 = ’AEIOUY’
abc2 = ’BCDFGHJKLMNPQRSTVWXZ’
for j in abc1:
    c = 0
    for k in abc2:
        c += ms.count(k+j)
    if c > mx:
        mx = c
        b = j

# Ищем, сколько раз в файле встречается эта буква
c = 0
for s in a:
    c += s.count(b)

print(b, c)

f = open(’C:/2412.txt’)
a = f.readlines()

# l — текущая длина, ml — максимальная
# ms — строка с самой длинной цепочкой из одинаковых букв
l = 1
ml = 1
ms = ’’
for s in a:
    # Чтобы не было ошибочных подсчётов длины,
    # перед началом проверки новой строки сбрасываем счётчик
    l = 1
    for i in range(len(s)-1):
        if s[i] == s[i+1]:
            l += 1
            # Если цепочка на текущий момент макс. длины,
            # то сохраняем текущую строку
            if l > ml:
                ms = s
            ml = max(l, ml)
        else:
            l = 1

# Ищем букву,
# которая встречается реже в сохранённой строке
# (при этом она там должна быть)
mn = 10**10
b = ’’
abc = ’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
for j in abc:
    if ms.count(j) < mn and ms.count(j) > 0:
        mn = ms.count(j)
        b = j

# Считаем, сколько раз в файле найденная буква стоит перед F
c = 0
for s in a:
    c += s.count(b+’F’)

print(b, c)

f = open(’2prob/24__1sajl.txt’)
s = f.readline()
s = s.split(’Z’)[1:] #Разделяем строку по Z. Избавляемся от самой первой подстроки, потому что перед ней вовсе не было буквы Z.
# Для красоты записи используем срез, однако это можно было реализовать и в самом цикле, задав его промежутки как (1, len(s)).

alp = ’ABCDEFGHIJKLMNOPQRSTUVWXYZ’ # Задали весь алфавит
counter = [0]*26 # Создали массив, где в ячейке хранится количество встреч соответствующей буквы сразу за Z.
# То есть, в ячейке counter[1] хранится количество, сколько раз после буквы Z встретилась буква B = alp[1].

for substring in s: # Пробегаемся по всем подстрокам
    if substring: # Если подстрока substring не пустая. Иначе, если она пустая, то возникнет ошибка.
        elem = substring[0] # Берём самый первый элемент подстроки; он стоит сразу после буквы Z. Остальные элементы нас не интересуют.
        for i in range(len(alp)): # Пробегаемся по алфавиту
            if elem == alp[i]: # Если наш elem равен букве алфавита с индексом i
                counter[i] += 1 # Увеличиваем соответствующую ячейку в массиве на единицу

# Дальше можем сравнить значения глазами при помощи следующих выводов
print(alp)
print(counter)
print(max(counter))

# Либо можем изощриться:
print(alp[counter.index(max(counter))])

s = open(’24_3.txt’).readline()
print(s.count(’D’))

file = open(’24.txt’)
s = file.read()
counter = 0
for i in range(len(s) - 4):
    if s[i] == s[i + 4] and s[i + 1] == s[i + 3]:
        counter += 1
print(counter)

Решение №1

f = open(’24.txt’)
s = f.readline()
ans = 0
for i in range(len(s)):
    if s[i] == ’A’: #Возможно, здесь начинается нужная подстрока
        for j in range(i + 1, len(s)): #Запускаем цикл со следующего элемента
            if s[j] == ’A’: #Если попали на вторую букву А, то подстрока нам не подходит
                break
            if s[j] == ’D’: #Если попали на букву D
                if (j - i + 1) >= 10: #Если длина подстроки больше 10
                    ans += 1 #Нашли подходящую подстроку, увеличиваем счётчик
                break #Либо нашли подходящую подстроку, либо длина меньше 10 и мы её пропускаем
print(ans)

Решение №2

f = open(’24.txt’)
s = f.readline()
k = 0
for i in range(len(s) - 9): #Изменили длину цикла
    if s[i] == ’A’:
        for n in range(9, len(s)): #Подходящая последовательность может быть при n = 9. Длина подстроки, заключённой
                                #между эл-тами s[0] и s[9] равна 9 - 0 + 1 = 10 >= 10.
            if s[i + n] == ’D’:
                b = s[i:i + n + 1]
                if b.count(’A’) == 1 and b.count(’D’) == 1:
                    k += 1
                    print(b)
                else: #Если условие выше не выполнилось, то в текущей подстроке уже несколько букв A или D, которые,
                    #очевидно, останутся в подстроке, даже если мы сдвинем её правую границу (n)
                    break #Прерываем цикл с такой подстрокой
print(k)

file = open(’24.txt’)
s = file.read()
count_occurrence = 0
index_occurrence = ’’
for i in range(len(s) - 5):
    if s[i:i + 5] == "BEBAD":
        count_occurrence += 1
        if count_occurrence == 4:
            index_occurrence = i
print(index_occurrence + 1)

file = open(’24.txt’)
s = file.read()
occurrence_counter = 0
occurrence_index = ’’
for index in range(len(s) - 5):
    if s[index: index + 5] == "CCADE":
        occurrence_counter += 1
        if occurrence_counter == 5:
            occurrence_index = index
            break
print(occurrence_index + 1)

f = open(’1.txt’)
s = f.read()
index_substring = ’’
counter_substring = 0
for i in range(len(s)):
    if s[i:i + 5] == "AAEBD":
        counter_substring += 1
    if counter_substring == 3:
        index_substring = i + 1
        break
print(index_substring)