Задание 24 ЕГЭ по информатике

1. 1. Шаг 1. Пишем цикл с двумя переменными: cur — длина текущей серии, best — максимум. Начинаем с cur = 1, best = 1.
2. 2. Шаг 2. Код: for i in range(1, len(s)): cur = cur + 1 if s[i] == s[i-1] else 1; best = max(best, cur). Сравнение с предыдущим символом начинается с индекса 1, поэтому выхода за границу нет.
3. 3. Шаг 3. Прогоняем вручную: 7 (1), AA (2), 33 (2), BBB (3), 1 (1), CCCC (4), 22 (2), DDDDD (5), 9 (1).
4. 4. Шаг 4. Максимум обновлялся так: 1 → 2 → 3 → 4 → 5.
5. 5. Шаг 5. Ответ: 5 (серия DDDDD).
6. 6. Важно: при таком способе хвост не теряется, потому что best обновляется на каждом шаге, а не только при смене символа. Если писать «обнулять счётчик при смене символа и там же сравнивать с максимумом», последнюю серию придётся проверять отдельно после цикла.

Ответ: 5

1. 1. Шаг 1. Заводим величину bal: прибавляем 1 за цифру и вычитаем 1 за заглавную букву. Тогда «цифр столько же, сколько букв» на участке означает, что bal в его начале и конце совпадают.
2. 2. Шаг 2. Заводим словарь first = {0: -1}: он хранит самую левую позицию, где встретилось данное значение баланса. Значение 0 «встречено» до начала строки, на позиции −1.
3. 3. Шаг 3. Идём по строке: для каждой позиции i обновляем bal, а затем — если такое значение уже встречалось — обновляем ответ длиной i − first[bal]; если не встречалось, запоминаем first[bal] = i.
4. 4. Шаг 4. Проходим строку AAA12BC3D4E5FGH67: три буквы A дают bal = −1, −2, −3 (все значения встретились впервые, запоминаем позиции 0, 1, 2). Цифра 1 на позиции 3 поднимает баланс до −2 — такое значение уже было на позиции 1, значит нашёлся участок длиной 3 − 1 = 2 (это «A1»). Цифра 2 на позиции 4 даёт баланс −1, который был на позиции 0, — участок длиной 4 − 0 = 4 («AA12»).
5. 5. Шаг 5. Продолжая проход, баланс продолжает колебаться, и лучший результат достигается на участке 12BC3D4E5FGH67 — он начинается сразу после третьей буквы A.
6. 6. Шаг 6. Проверим этот участок вручную: цифры 1, 2, 3, 4, 5, 6, 7 — семь штук; заглавные буквы B, C, D, E, F, G, H — семь штук. Количество совпадает, длина участка 14.
7. 7. Шаг 7. Больше 14 быть не может: во всей строке 7 цифр и 10 заглавных букв, поэтому в любой участок длиной 15 и более обязательно попадёт хотя бы одна лишняя буква A, и равенство нарушится.
8. 8. Ответ: 14. Обрати внимание: наивный перебор всех подстрок на строке из 30 000 символов — это около 450 миллионов срезов, программа не успеет; приём с балансом делает один проход.

Ответ: 14

1. 1. Шаг 1. Метод s.count('2025') считает только непересекающиеся вхождения слева направо.
2. 2. Шаг 2. Универсальный способ — перебрать все стартовые позиции: c = 0; for i in range(len(s) - 3): if s[i:i+4] == '2025': c += 1.
3. 3. Шаг 3. Находим вхождения в строке: позиции 0, 5, 10, 14 и 19 — это подстроки перед A, перед B, две подряд между B и C и последняя.
4. 4. Шаг 4. Всего 5 вхождений. Здесь оба способа дали одинаковый результат, потому что подстрока 2025 не может перекрывать саму себя: у неё нет одинакового начала и конца.
5. 5. Шаг 5. А вот для подстроки AA в строке AAAA ответы разойдутся: count даст 2, а честный перебор — 3. В условии всегда смотри, требуются ли перекрывающиеся вхождения.

Ответ: 5

1. 1.

   s = open('24.txt').read().strip()

   ZNAK = 'E'
   LIMIT = 2

   left = 0
   skolko = 0        # сколько ZNAK внутри окна
   best = 0
   for right in range(len(s)):
       if s[right] == ZNAK:
           skolko += 1
       while skolko > LIMIT:
           if s[left] == ZNAK:
               skolko -= 1
           left += 1
       dlina = right - left + 1
       if dlina > best:
           best = dlina

   print(best)

2. 2. Индексы строки: 0 — A, 1 — B, 2 — E, 3 — E, 4 — C, 5 — D, 6 — E, 7 — F, 8 — E, 9 — G, 10 — H.
3. 3. right = 0 (A). Не E, счётчик 0. Окно 0…0, длина 1. best = 1.
4. 4. right = 1 (B). Окно 0…1, длина 2. best = 2.
5. 5. right = 2 (E). Счётчик стал 1 — предел не превышен. Окно 0…2, длина 3. best = 3.
6. 6. right = 3 (E). Счётчик 2 — ровно предел, «не более двух» выполнено. Окно 0…3, длина 4. best = 4.
7. 7. right = 4 (C) и right = 5 (D). Счётчик не меняется, окно растёт: длины 5 и 6. best = 6.
8. 8. right = 6 (E). Счётчик стал 3 — предел нарушен, включается внутренний цикл. Выводим s[0] = A (не E, счётчик тот же), left = 1. Выводим s[1] = B, left = 2. Выводим s[2] = E — счётчик уменьшается до 2, left = 3. Условие восстановлено. Окно 3…6, длина 4, рекорд не бьётся: best = 6.
9. 9. right = 7 (F). Окно 3…7, длина 5. best = 6.
10. 10. right = 8 (E). Счётчик 3 — снова нарушение. Выводим s[3] = E, счётчик 2, left = 4. Окно 4…8, длина 5. best = 6.
11. 11. right = 9 (G). Окно 4…9, длина 6. best = 6.
12. 12. right = 10 (H). Окно 4…10, длина 7. Это новый рекорд: best = 7. Участок CDEFEGH — в нём две буквы E, что и требовалось.
13. 13. Ответ: 7. Посчитаем работу: правая граница сделала 11 шагов, левая — 4. Всего 15 операций на строке из 11 символов, то есть меньше 2n. На боевом файле в 30 000 символов это 60 000 операций — доли миллисекунды.
14. 14. Частая ошибка — писать if skolko > LIMIT вместо while. Одного сдвига левой границы может не хватить: если выводимый символ не тот, что нарушил условие, сдвигать придётся дальше. В нашей трассировке на шаге right = 6 потребовалось три сдвига подряд.

Ответ: 7

1. 1.

   s = open('l24.txt').read().strip()
   print(len(s), s[:40])        # проверка чтения — убрать перед ответом

   best = 0
   cur = 0
   for c in s:
       if 'A' <= c <= 'Z':
           cur += 1
       else:
           cur = 0
       if cur > best:
           best = cur

   print(best)

2. 2. Шаг 1. read() читает файл целиком одной строкой, strip() убирает перевод строки в конце. Без strip() последний символ строки окажется невидимым \n, и он не сломает ответ в этой задаче — но сломает в задаче про «нет двух одинаковых подряд», где сравниваются соседи.
3. 3. Шаг 2. Отладочная печать len(s), s[:40] — привычка, которая окупается. Длина должна совпасть с тем, что написано в разборе или выглядеть правдоподобно (десятки тысяч), а первые сорок символов — быть цифрами и заглавными буквами, а не чем-то неожиданным.
4. 4. Шаг 3. Условие 'A' <= c <= 'Z' вместо c.isupper(). Оба работают, но первое точнее: isupper() истинно и для русской «Ф», и для греческой «Ω», а условие требует именно латинских заглавных. В файлах ФИПИ других букв не бывает, но привычка писать условие буквально ничего не стоит.
5. 5. Шаг 4. Обнуление в else — это и есть «идущих подряд»: любой неподходящий символ разрывает цепочку.
6. 6. Шаг 5. Обновление рекорда стоит вне ветвления, то есть выполняется на каждом символе. Если перенести его в ветку else (обновлять только при разрыве цепочки), то цепочка, дотянувшаяся до самого конца файла, в рекорд не попадёт — разрыва после неё не будет. Это главная ошибка линии 24, и заметить её трудно: программа выдаёт правдоподобное число.
7. 7. Шаг 6. Чтобы получить вариант «только десятичных цифр», достаточно поменять одно условие: '0' <= c <= '9' или c.isdigit(). Чтобы получить вариант «нет двух одинаковых подряд» — сравнивать не с алфавитом, а с предыдущим символом. Каркас остаётся тем же.
8. 8. Шаг 7. Время работы: один проход по 30 000 символов — 30 000 операций, мгновенно. Для сравнения, перебор всех подстрок этой строки дал бы около 450 миллионов срезов, причём каждый срез сам по себе стоит времени, пропорционального своей длине.

Ответ: Число печатается программой; каркас один на всю первую семью линии 24