Как решать задание 24 ЕГЭ по информатике — обработка символьных строк

О чём задание 24

Задание 24 — работа с длинной текстовой строкой из файла. Тебе дают файл (обычно 24.txt) с одной строкой длиной до миллиона символов, и нужно найти некоторую числовую характеристику: длину самой длинной серии, количество подстрок определённого вида, сумму длин подходящих кусков и т.д.

Задание стоит 1 первичный балл. В КЕГЭ 2026 это одно из 25 одноочковых заданий (задания 1-25), итого 29 первичных баллов с учётом двухочковых 26 и 27. Если хочешь 80+ тестовых, такие стабильные задания нужно сдавать на автомате — об этом есть отдельная статья Как набрать 90+ баллов ЕГЭ по информатике.

Типовые запросы

За годы экзамена выкристаллизовались несколько форматов условия:

Тип задачи	Что ищем
Самая длинная серия	Максимальная длина подряд идущих одинаковых символов
Серия без символа	Максимальная длина подстроки, не содержащей букву X
Количество подстрок	Сколько раз встречается ABC, AB+, X*Y и т.п.
Серия с свойством	Подстрока, в которой символы строго возрастают по ASCII
Чередование	Максимум подряд идущих пар AB AB AB ...
Самая длинная подстрока из двух букв	Максимум подряд идущих символов только из {A, B}

Независимо от конкретного условия, 90% задач сводятся к одному и тому же шаблону — скользящему счётчику.

Базовый шаблон решения

with open('24.txt') as f:
    s = f.read().strip()

max_len = 0
cur = 0
for i, c in enumerate(s):
    if условие(c, s, i):
        cur += 1
        if cur > max_len:
            max_len = cur
    else:
        cur = 0

print(max_len)

Три ключевые строки:

1. cur += 1 — текущая серия растёт, если условие выполняется.
2. max_len = max(...) — обновляем максимум сразу после инкремента, а не в else. Это страхует от случая, когда строка заканчивается серией.
3. cur = 0 — сброс при нарушении условия.

Шаблон работает на любой задаче 24, если условие можно вычислить по текущему символу c и его соседям s[i-1], s[i+1].

Когда нужен индекс, а когда — нет

Если условие зависит только от текущего символа (например, «буква A»), можно писать коротко:

cur = 0
max_len = 0
for c in s:
    if c == 'A':
        cur += 1
        max_len = max(max_len, cur)
    else:
        cur = 0

Если условие сравнивает текущий символ с предыдущим (например, «возрастает по ASCII»), нужен индекс:

cur = 1  # первый символ — серия длины 1
max_len = 1
for i in range(1, len(s)):
    if s[i] > s[i-1]:
        cur += 1
        max_len = max(max_len, cur)
    else:
        cur = 1

Обрати внимание: cur и max_len инициализируются единицей, а не нулём — одиночный символ уже сам по себе последовательность длины 1.

Альтернатива: регулярные выражения

Для ряда задач удобнее использовать модуль re. Типовые конструкции:

import re

# Самая длинная серия одной буквы
matches = re.findall(r'A+', s)
print(max(len(m) for m in matches))

# Количество вхождений подстроки
print(len(re.findall(r'ABC', s)))

# Самая длинная подстрока из только A и B
matches = re.findall(r'[AB]+', s)
print(max(len(m) for m in matches))

# Подстроки ровно вида "AB", повторяющегося несколько раз
matches = re.findall(r'(?:AB)+', s)
print(max(len(m) for m in matches) // 2)  # делим на 2 — считаем пары

Плюсы re — короче код и меньше шансов ошибиться в индексах. Минусы — регулярки не умеют считать арифметику на символах (например, «ASCII текущего = ASCII предыдущего + 1»), и для таких условий всё равно придётся писать цикл.

Правило выбора: если условие — это фиксированный шаблон из букв, используй re. Если условие — неравенство/сравнение между соседями, пиши цикл.

Разобранная задача 1: самая длинная серия одинаковых цифр

В файле 24.txt дана строка из цифр 0-9. Найди длину самой длинной последовательности подряд идущих одинаковых цифр.

Разбор

Это классика. Условие — «текущий символ равен предыдущему». Пишем:

with open('24.txt') as f:
    s = f.read().strip()

cur = 1
max_len = 1
for i in range(1, len(s)):
    if s[i] == s[i-1]:
        cur += 1
        if cur > max_len:
            max_len = cur
    else:
        cur = 1

print(max_len)

Почему cur = 1, а не 0

Первый символ уже начинает потенциальную серию длины 1. Если бы мы инициализировали cur = 0, то при строке AAA получили бы максимум 2, а не 3 — потому что цикл идёт с i=1, и в нём cur увеличивается ровно дважды.

Альтернатива через re

import re
with open('24.txt') as f:
    s = f.read().strip()
print(max(len(m.group()) for m in re.finditer(r'(.)\1*', s)))

Регулярка (.)\1* ловит любой символ и его повторения. Короче, но нужно понимать, как работают обратные ссылки.

Типичная ошибка

Новички часто пишут:

else:
    max_len = max(max_len, cur)
    cur = 1

И этот код не работает, если строка заканчивается длинной серией. Последняя серия никогда не попадёт в else, и max_len не обновится. Обновляй max_len сразу после инкремента, как в основном шаблоне выше.

Разобранная задача 2: самая длинная подстрока со строго возрастающими ASCII-кодами

В файле 24.txt дана строка из латинских букв A-Z. Найди длину самой длинной подстроки, в которой каждый следующий символ больше предыдущего по ASCII.

Разбор

Условие — ord(s[i]) > ord(s[i-1]), что в Python эквивалентно s[i] > s[i-1] (строки сравниваются посимвольно).

with open('24.txt') as f:
    s = f.read().strip()

cur = 1
max_len = 1
for i in range(1, len(s)):
    if s[i] > s[i-1]:
        cur += 1
        if cur > max_len:
            max_len = cur
    else:
        cur = 1

print(max_len)

Почему нельзя re

Регулярное выражение не умеет сказать «следующая буква больше предыдущей». Возможны только фиксированные шаблоны. Поэтому — только цикл.

Вариация: неубывающая последовательность

Если в условии «не меньше», а не «больше», меняй только знак:

if s[i] >= s[i-1]:

Будь внимателен: ЕГЭ любит подкидывать именно такие мелочи, и между «строго возрастающая» и «неубывающая» огромная разница в ответе.

Типичная ошибка

Путаница с границами цикла. Код for i in range(len(s)) и обращение s[i-1] при i=0 даст s[-1] — последний символ строки. Это не вызовет ошибку, но исказит ответ. Всегда начинай цикл с range(1, len(s)) при сравнении соседей.

Одним проходом vs поиск подстрок

Иногда в условии звучит «найди количество подстрок вида ABC». Два подхода:

Через цикл

count = 0
for i in range(len(s) - 2):
    if s[i] == 'A' and s[i+1] == 'B' and s[i+2] == 'C':
        count += 1
print(count)

Через count

print(s.count('ABC'))

Вторая версия — однострочник, работает за O(n). Используй её для фиксированных подстрок без всяких «плюсов» и «звёздочек».

Для шаблонов с повторениями (например, «любое количество A подряд, потом B») — re.findall(r'A+B', s).

Тайминг и стратегия

Задание 24 — одноочковое, и по времени на него стоит выделять не больше 10-15 минут. Схема работы:

1. 1 минута — прочитать условие, понять, что именно ищем: длину, количество, сумму.
2. 2-3 минуты — сформулировать условие для цикла: какое свойство проверяем между соседями или в каждом символе.
3. 3-5 минут — написать код по шаблону, запустить на маленьком тестовом примере.
4. 2-3 минуты — запустить на полном файле, скопировать ответ.
5. 1 минута — перепроверить формат вывода (просто число или число с пояснением).

Если после 15 минут задача не идёт — пропусти и вернись в конце. Терять 30 минут на задание за 1 балл невыгодно: за это же время можно решить 2-3 других. Подробнее про распределение времени — в статье Как сдавать пробники ЕГЭ по информатике.

Типичные ошибки

Ошибка	Что происходит	Как исправить
Обновление max_len только в else	Последняя серия не учитывается	Обновляй внутри ветки if сразу после cur += 1
cur = 0 при сравнении соседей	Теряется 1 символ в ответе	Инициализируй cur = 1, max_len = 1
Цикл от i=0 с обращением к s[i-1]	Обращение к s[-1] портит ответ	Начинай с range(1, len(s))
Забытый strip()	Лишний \n в конце сбивает счётчик	Всегда s = f.read().strip()
Неверное условие на краях	Нет проверки на i+1 < len(s) в шаблонных задачах	Ограничивай цикл range(len(s) - k + 1) для шаблона длины k
Копирование условия из другой задачи	Решение работает, но отвечает не на тот вопрос	Перечитывай условие 2 раза перед запуском

Ошибка, которая стоит особенно дорого

Лишний += в не той ветке:

# НЕПРАВИЛЬНО
for i in range(1, len(s)):
    if s[i] == s[i-1]:
        cur += 1
    else:
        cur += 1   # опечатка — должно быть cur = 1
        max_len = max(max_len, cur)

Код компилируется, работает, но считает мусор. Всегда проверяй, что в else именно сброс, а не инкремент.

Как тренироваться

1. Реши 5 типов условий на автомат: серия одинаковых символов, серия без символа X, возрастающая по ASCII, серия из множества {A, B}, количество шаблона ABC. Каждый тип — по 3-5 задач.
2. Пиши шаблон с нуля, не копируя. На экзамене под давлением копипаст не спасёт.
3. Тренируй устный разбор. Смотри на 20 символов и глазами считай ответ — это тренирует понимание.
4. Прогоняй большие файлы. Миллион символов на слабом ноутбуке должен считаться меньше 1 секунды.

Дополнительно полезны:

• Задание 1 ЕГЭ по информатике — простое начало для прогрева
• Задание 6 ЕГЭ по информатике — работа с алгоритмами
• Задание 27 ЕГЭ по информатике — финальное задание на 2 балла
• Типичные ошибки на ЕГЭ по информатике — что проверить перед сдачей
• Python-идиомы для ЕГЭ — короткие приёмы, которые экономят минуты

Выводы

• Задание 24 — один балл, но стабильно решаемый за 10 минут, если выучить шаблон.
• Базовая схема — цикл со счётчиком текущей серии и переменной максимума. Обновляй максимум сразу после инкремента.
• Регулярки хороши для фиксированных подстрок, цикл — для сравнений между соседями.
• Главная ошибка — неправильный сброс и потеря последней серии. Проверяй на тестах, заканчивающихся длинной серией.
• Не зависай на задании дольше 15 минут — дальше оно перестаёт оправдывать время.

В КЕГЭ 2026 на 27 заданий даётся 235 минут. Это 8-9 минут на задание в среднем. Если каждое одноочковое решаешь за 5-10 минут, остаётся запас на сложные 25, 26, 27 — а именно там куётся высокий балл.