24.01 Поиск максимальной подстроки

# Открываем файл и читаем его содержимое
f = open("Задание_38_ДЗ.txt")
s = f.read()

# Инициализируем переменные
maxim, counter = 0, 1  # maxim — максимальная длина последовательности, counter — текущая длина

# Проходим по всем символам строки, кроме последнего
for i in range(len(s) - 1):
    # Проверяем, четные ли оба символа (текущий и следующий)
    if int(s[i]) % 2 == int(s[i + 1]) % 2:
        counter += 1  # Увеличиваем счетчик, если они имеют одинаковую четность
        maxim = max(maxim, counter)  # Обновляем максимальную длину последовательности
    else:
        counter = 1  # Сбрасываем счетчик, если четность различается

# Выводим максимальную длину последовательности одинаковой четности
print(maxim)

# Открываем файл и читаем его содержимое
f = open("Задание_39_ДЗ.txt").read()

# Инициализируем переменные
maxim = 0  # Переменная для хранения максимальной длины неубывающей подпоследовательности
count = 1  # Переменная для подсчета текущей длины последовательности

# Проходим по всем символам строки, кроме последнего
for i in range(len(f) - 1):
    # Проверяем, не убывает ли последовательность по таблице ASCII
    if f[i] <= f[i + 1]:
        count += 1  # Увеличиваем счетчик, если текущий символ меньше или равен следующему
        maxim = max(count, maxim)  # Обновляем максимальную длину, если текущая больше
    else:
        count = 1  # Сбрасываем счетчик на 1, если последовательность убывает

# Выводим максимальную длину неубывающей подпоследовательности
print(maxim)

 

# Открываем файл и читаем его содержимое
f = open("Задание_40_ДЗ.txt")
s = f.read()  # Считываем все символы из файла в строку s

# Инициализируем переменные
count = 1  # Счетчик текущей длины последовательности
maxim = 0  # Переменная для хранения максимальной длины последовательности

# Проходим по всем символам строки, кроме последнего
for i in range(len(s) - 1):
    # Проверяем, является ли текущий символ предшественником следующего в алфавите
    if ord(s[i]) == ord(s[i + 1]) - 1:
        count += 1  # Увеличиваем счетчик, если символы идут в алфавитном порядке
        maxim = max(maxim, count)  # Обновляем максимальную длину последовательности
    else:
        count = 1  # Сбрасываем счетчик на 1, если последовательность нарушена

# Выводим максимальную длину последовательности букв в алфавитном порядке
print(maxim)

 

Решение 1.

s = open("Задание_41_ДЗ__tcne.txt").read()
counter = 1
fl = True # Ждем больше
ans = 0
for i in range(len(s) - 1):
    if s[i] > s[i + 1] and fl:
     # Ждали больше, нашли больше
        counter += 1
        fl = False # Ждем меньше
    elif s[i] < s[i + 1] and not fl:
     # Ждали меньше, нашли меньше
counter += 1
        fl = True # Ждем больше
    elif s[i] > s[i + 1] and not(fl):
     # Ждали меньше, нашли больше (получается больше больше)
        # Для ситуации CBAB, ждали меньше, получили больше, учитываем
        # вторую пару больше как начало новой последовательности,
        # флаг можно не менять, так как он уже ждет меньше
        counter = 2
    elif s[i] < s[i + 1] and fl:
     # Ждали больше, нашли меньше
        # Флаг можно не менять, так как он уже ждет меньше
        counter = 1
    else:
        counter = 1
    ans = max(counter, ans)
print(ans)

Решение 2. В данном решении надо отдельно рассмотреть последний символ глазами.

with open(’Задание_41_ДЗ.txt’) as f:
    text = f.read().strip()

max_seq_len = 0
for i in range(len(text)):
    seq_len = 1
    for j in range(i+1, len(text)):
        if (j-i) % 2 == 1 and ord(text[j]) > ord(text[j-1]) or \
           (j-i) % 2 == 0 and ord(text[j]) < ord(text[j-1]):
            seq_len += 1
        else:
            break
    max_seq_len = max(max_seq_len, seq_len)

print(max_seq_len+1)

Решение 3.

with open(’Задание_41_ДЗ.txt’) as f:
    text = f.read().strip() + "-"

seq_len = 1
max_seq_len = 0
for i in range(1, len(text) - 1, 2):
    if text[i - 1] > text[i] < text[i + 1] and text[i + 1] != "-":
        seq_len += 2
        max_seq_len = max(max_seq_len, seq_len)
    else:
        if text[i - 1] > text[i]:
            seq_len += 1
            max_seq_len = max(max_seq_len, seq_len)
        seq_len = 1

for i in range(2, len(text) - 1, 2):
    if text[i - 1] > text[i] < text[i + 1] and text[i + 1] != "-":
        seq_len += 2
        max_seq_len = max(max_seq_len, seq_len)
    else:
        if text[i - 1] > text[i]:
            seq_len += 1
            max_seq_len = max(max_seq_len, seq_len)
        seq_len = 1
print(max_seq_len)

# Открываем файл и читаем его содержимое
f = open(’Задание_43_ДЗ.txt’)
s = f.read()  # Считываем все символы из файла в строку s

# Инициализируем переменные
count = 1  # Счетчик текущей длины возрастающей последовательности
maxim = 0  # Переменная для хранения максимальной длины последовательности

# Проходим по всем символам строки, кроме последнего
for i in range(len(s) - 1):
    # Проверяем, идет ли текущий символ перед следующим в порядке увеличения по ASCII
    if s[i] < s[i + 1]:
        count += 1  # Увеличиваем счетчик, если символы идут в порядке возрастания
        maxim = max(maxim, count)  # Обновляем максимальную длину последовательности
    else:
        count = 1  # Сбрасываем счетчик на 1, если последовательность нарушена

# Выводим максимальную длину возрастающей последовательности символов
print(maxim)

Решение через цикл:

Считаем строку из файла, введём переменную для подсчёта максимального числа троек подряд. Будем срезать по 3 тройки символов и проверять, подходят ли они нам, поскольку мы проверяем тройки - идти по строке будем с шагом 3. Если тройка не подошла - запишем, что уже нашли, далее обнулим счётчик. Пройдёмся по строке начиная с 0, 1 и 2 символа. Это исключит возможность потери каких-либо комбинаций троек. Ответ умножим на 3, чтобы получить количество символов, а не самих троек.

# Читаем строку из файла
s = open("Задание_24__tlln.txt").readline()

# mx - максимальное количество подряд идущих троек (OSR или RSO)
mx = 0

# Перебираем 3 возможных начальных позиции (0, 1, 2)
for k in range(0, 3):
    # c - счетчик текущей последовательности троек
    c = 0
    # Проходим по строке с шагом 3, начиная с позиции k
    for i in range(k, len(s), 3):
        # Проверяем текущую тройку символов
        if s[i:i + 3] in ["RSO", "OSR"]:
            # Если тройка подходит, увеличиваем счетчик
            c += 1
            # Обновляем максимальное значение
            mx = max(c, mx)
        else:
            # Если тройка не подходит, сбрасываем счетчик
            c = 0

# Умножаем на 3, чтобы получить длину в символах (а не в тройках)
print(mx * 3)

f = open(’2.txt’)
s = f.read()
max_size_substring = 0
temp_size = 0
for i in range(len(s)):
    if s[i] == ’E’:
        temp_size += 1
        max_size_substring = max(max_size_substring, temp_size)
    else:
        temp_size = 0
print(max_size_substring)

f = open(’3.txt’)
s = f.read()
max_size_substring = 0
temp_size = 0
for i in range(len(s)):
    if s[i] in ’BCD’:
        temp_size += 1
        max_size_substring = max(max_size_substring, temp_size)
    else:
        temp_size = 0
print(max_size_substring)

f = open(’4.txt’)
s = f.read()
max_size_substring = 0
temp_size = 0
for i in range(len(s)):
    if s[i] != ’A’:
        temp_size += 1
        max_size_substring = max(max_size_substring, temp_size)
    else:
        temp_size = 0
print(max_size_substring)

f = open(’5.txt’)
s = f.read()
max_size_substring = 0
temp_size_alf = 0
temp_size_numbers = 0
for i in range(len(s)):
    if s[i] in ’0123456789’:
        temp_size_numbers += 1
        temp_size_alf = 0
        max_size_substring = max(max_size_substring, temp_size_numbers)
    else:
        temp_size_alf += 1
        temp_size_numbers = 0
        max_size_substring = max(max_size_substring, temp_size_alf)
print(max_size_substring)

f = open(’6.txt’)
s = f.read()
max_size_substring = 1
temp_size_substring = 1
max_symbol = ’’
for i in range(len(s) - 1):
    if s[i] == s[i + 1]:
        temp_size_substring += 1
    else:
        temp_size_substring = 1
    if temp_size_substring >= max_size_substring:
        max_size_substring = temp_size_substring
        max_symbol = s[i]
print(max_symbol, max_size_substring, sep="")

f = open(’7.txt’)
s = f.read()
max_size_substring = 2
temp_size_substring = 2
for i in range(len(s) - 2):
    if s[i] != s[i + 1] and s[i + 1] != s[i + 2] and s[i] != s[i + 2]:
        temp_size_substring += 1
        max_size_substring = max(max_size_substring, temp_size_substring)
    else:
        temp_size_substring = 2
print(max_size_substring)

import string

f = open(’8.txt’)
s = f.read()
max_size_substring = 1
temp_size_substring = 1
# Создали список английских букв
alf = list(string.ascii_uppercase)
counter_alf = [0] * 26
old_symbol = ’’
for i in range(len(s)):
    if s[i] == old_symbol:
        temp_size_substring += 1
    else:
        temp_size_substring = 1
        old_symbol = s[i]
    if temp_size_substring >= max_size_substring:
        max_size_substring = temp_size_substring
        # Заполняем список максимального количества определенной буквы
        counter_alf[alf.index(old_symbol)] = max_size_substring
max_counter = max(counter_alf)
print(max_counter, end="")
for i in range(len(counter_alf)):
    if counter_alf[i] == max_counter:
        print(alf[i], end="")

f = open(’10.txt’)
s = f.read()
max_counter = 0
for start_step in range(2):
    temp_counter = 0
    for i in range(start_step, len(s) - 1, 2):
        if s[i] + s[i + 1] == "CD":
            temp_counter += 2
            max_counter = max(max_counter, temp_counter)
        else:
            temp_counter = 0
print(max_counter, "CD" * (max_counter // 2), sep="")

a = open(’24.txt’).readline()
k = 0
mx = 0
for i in range(len(a)):
    if a[i] == ’B’:
        k += 1
    else:
        k = 0
    mx = max(mx, k)
print(mx)

file = open(’24.txt’)
s = file.read()#Считываем файл
max_size = 0
temp_size = 0
for i in range(len(s)):#Проходимся по строке
    if s[i] == ’B’:#Если текущий элемент равен B,то увеличиваем счётчик текущей комбинации на 1
        temp_size += 1
        max_size = max(max_size, temp_size)
    else:
        temp_size = 0#В ином случае, мы обнуляем счётчик текущей комбинации
print(max_size)

file = open(’24.txt’)
s = file.read()
max_size = 0
temp_size = 0
for i in range(len(s)):
    if s[i] in "ABE":
        temp_size += 1
        max_size = max(max_size, temp_size)
    else:
        temp_size = 0
print(max_size)

file = open(’24.txt’)
s = file.read()
max_size = 0
temp_size = 0
for i in range(len(s)):
    if s[i] != ’D’:
        temp_size += 1
        max_size = max(max_size, temp_size)
    else:
        temp_size = 0
print(max_size)

file = open(’24.txt’)
s = file.read()
max_size = 0
temp_size_numbers = 0
temp_size_alf = 0
numbers = "0123456789"
for i in range(len(s)):
    if s[i] in numbers:
        temp_size_numbers += 1
        max_size = max(max_size, temp_size_numbers)
        temp_size_alf = 0
    else:
        temp_size_alf += 1
        max_size = max(max_size, temp_size_alf)
        temp_size_numbers = 0
print(max_size)