24.02 Поиск символа/строки по частоте

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)

 

f = open("24.txt")
n = f.readline()

glas = "AEIOUY"
for x in glas:
    n = n.replace(x, "*")
print(n.count("*"))

 

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)

 

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)

Решение №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)

f = open("24.txt")
a = [i for i in f]

k = 0
for i in range(len(a)):
    if a[i].count("X") == a[i].count("Y"):
        k += 1
print(k)

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)

 

s = open("24_3.txt").readline()

print(s.count("D"))

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))])

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(’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:/2414.txt")
a = f.readlines()

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

f = open(’24.txt’)
s = f.readline()  # Считываем строчку
# Определяем, сколько в ней символов X, Y и Z:
print(’X:’, s.count(’X’),
      ’Y:’, s.count(’Y’),
      ’Z:’, s.count(’Z’))
# Получаем X: 500019 Y: 333396 Z: 166585
# X - самый часто встречающийся в файле символ
# Z - самый редко встречающийся в файле символ

# Сначала найдём четную максимальную длину подстроки, состоящей из символа X
s1 = s.replace(’Y’, ’Z’)  # Заменяем все символы Y на символы Z
s1 = s1.split(’Z’)  # Разбиваем строчку по символу Z

# Каждый элемент массива s1 (строчки, состоящие из символов X, и пустые строчки)
# превращаем в их длину.
# То есть, если была строчка ’XXXXX’, то станет просто число 5.
s1 = list(map(len, s1))
mc = max([i for i in s1 if i % 2 == 0])  # Составляем массив mc только из чётных длин массива s1
                                         # и берём максимальную

# Найдём нечетную максимальную длину подстроки, состоящей из символа Z
s2 = s.replace(’Y’, ’X’)  # Заменяем все символы Y на символы X
s2 = s2.split(’X’)  # Разбиваем строчку по символу X

# Каждый элемент массива s2 (строчки, состоящие из символов Z, и пустые строчки)
# превращаем в их длину.
s2 = list(map(len, s2))
mnc = max(
    [i for i in s2 if i % 2 == 1])  # Составляем массив mnc только из нечётных длин массива s1
                                    # и берём максимальную

# Выводим найденные длины
print(mc, mnc)

alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
dic = {a: 0 for a in alph} # создаем словарь, где ключ это буква, а значение 0
                           # будем сохранять в нем количество для каждой буквы
f = open(’24.txt’)
st = f.readline()

for i in range(len(st)):
    tmp = str(st[i]).upper() //переводим в верхний регистр
    dic[tmp] += 1
cnt = 0
for i in range(len(alph)):
    if dic.pop(alph[i]) == 0:
        cnt += 1
print(cnt)

f=open(’6.txt’)
kmax=0
file = ’’
for s in f.readlines():
    file += s
    k = s.count(’O’)
    if k>kmax:
        kmax=k
        string = s
x = ’AEYUOI’
alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
dic = {a: 0 for a in alph} # создаем словарь, где ключ это буква, а значение 0
                           # будем сохранять в нем количество для каждой буквы
for i in range(1, len(string) - 1):
    if string[i-1] not in x:
        tmp = str(string[i]).upper()
        dic[tmp] = dic[tmp] + 1
print(dic)

# находим максимальное знаечение и считает количество этой буквы в файле
print(file.count(’A’))

f = open("24.txt")
st = f.readlines()
cnt = 0
for i in range(len(st)):
    if st[i].count("K") > st[i].count("U"):
        cnt += 1
print(cnt)

f = open("5.txt")
s = f.readline()

count = 0
index = 0
for i in range (0, len(s) - 2):
    if ord(s[i + 1]) > ord(s[i]) and ord(s[i + 1]) > ord(s[i + 2]):
        count += 1
        index = i

print(count, index)

 

f = open("24.txt")
s = f.readlines()

c = 0
for i in range(len(s)):
    if s[i].count("Y") > s[i].count("T"):
        c += 1
print(c)

 

f = open("24_13100.txt").readline()

while "TXTXT" in f:
    f = f.replace("TXTXT", "TXTTXT")
print(f.count("TXT"))

 

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])))