Задание 26 ЕГЭ по информатике: сортировка целочисленной информации

Задание 26 ЕГЭ по информатике (КЕГЭ) — это программа для среды программирования, которая обрабатывает большой файл целых чисел. За него дают 2 первичных балла — это одно из двух самых дорогих заданий всего экзамена — при уровне сложности высокий (В). Проверяемый элемент содержания — КЭС 3.10, код требования — 2.12, а формулировка умения по обобщённому плану ФИПИ звучит так: «умение обрабатывать целочисленную информацию с использованием сортировки». Ядро задания — сортировка: без неё жадный алгоритм, на котором строится решение, просто не работает. Ниже — вся теория, два типовых сюжета с рабочим Python-кодом и разбор правила частичного зачёта, которое есть только у двух заданий экзамена — 26 и 27. Потренироваться можно на реальных заданиях 26 ЕГЭ по информатике онлайн — с мгновенной проверкой ответа.

Что проверяет задание 26 ЕГЭ по информатике

Задание 26 относится к разделу кодификатора «Алгоритмы и программирование». Программу пишут в одной из сред, доступных на экзамене (C#, C++, Pascal, Java, Python), читают данные из прилагаемого файла *.txt и печатают ответ. Входные данные — большой массив целых чисел, обычно тысячи или десятки тысяч значений, поэтому решение «на бумаге» и перебор в уме исключены: тут нужен именно алгоритм.

Проверяемые умения (КЭС 3.10, требование 2.12):

«умение обрабатывать целочисленную информацию с использованием сортировки» — дословная формулировка умения по обобщённому плану ФИПИ для задания 26;
читать входной файл программно: сначала количество элементов N, затем сами данные — по одному значению в строке или в паре чисел на строке;
выбирать подходящий ключ сортировки и порядок (по возрастанию или по убыванию) под конкретную задачу;
строить и обосновывать жадный алгоритм на отсортированном массиве;
вести по ходу единственного прохода массива не одну, а две величины: то, что вернёт первое число ответа, и то, что вернёт второе.

Задание 26 требует среды программирования, но не единственное: то же самое верно для заданий 16, 17, 18, 22, 24, 25 и 27. Файл *.txt прилагается только к заданиям 17, 24, 26 и 27 (задание 27 получает сразу два файла). На момент публикации статьи актуальна спецификация ФИПИ 2026 года; проекты КИМ-2027 ФИПИ публикует в конце августа 2026 года, а структура работы не менялась с 2025 года.

Параметр	Значение
Максимальный балл	2 первичных — вместе с заданием 27 это самые дорогие задания экзамена
Уровень сложности	Высокий (В) — таких заданий во всей работе всего 5
Раздел кодификатора	Алгоритмы и программирование; КЭС 3.10; код требования 2.12
Форма ответа	Два числа, каждое в своей ячейке таблицы ответа (не строка через пробел)
Файл и спец. ПО	Прилагается файл `*.txt`; нужна среда программирования (C#, C++, Pascal, Java, Python)
Рекомендуемое время	35 минут (по обобщённому плану ФИПИ) — больше только на задание 27 (40 минут)
Связанные задания	Задание 17 (та же форма ответа — два числа в двух ячейках, но проще), задание 25 (тот же код требования 2.12, но ответ — таблица N×2, а не две ячейки), задание 27 (второе задание с частичным зачётом)

Тренируйтесь на реальных файлах данных

Задания 26 ЕГЭ по информатике из открытого банка ФИПИ с прикреплёнными файлами и мгновенной проверкой ответа — бесплатно на Repet.ai.

Решать задание 26

Как выглядит формулировка

Сюжеты задания 26 разные — торты, коробки, файлы на диске, заявки в конференц-зал, — но у всех одна структура: описание правила отбора элементов, вход из N чисел во входном файле и требование найти сразу две величины. Вот реальные формулировки из открытого банка ФИПИ:

«В кондитерской есть N круглых форм для коржей. Специализация кондитерской – многоярусные торты, в которых диаметр каждого верхнего коржа меньше диаметра предыдущего. Один корж можно поместить на другой, если его диаметр хотя бы на 4 единицы меньше диаметра другого коржа. Определите наибольшее количество коржей, которое можно использовать для создания многоярусного торта, и максимально возможный диаметр самого маленького коржа.»
«Одну коробку можно поместить в другую, если длина её стороны хотя бы на 3 единицы меньше длины стороны другой коробки. Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, и максимально возможную длину стороны самой маленькой коробки…»
«Системный администратор раз в неделю создаёт архив пользовательских файлов. Однако объём диска, куда он помещает архив, может быть меньше, чем суммарный объём архивируемых файлов… определите максимальное число пользователей, чьи файлы можно сохранить в архиве, а также максимальный размер имеющегося файла, который может быть сохранён в архиве…»
«Входной файл содержит сведения о заявках на проведение мероприятий в конференц-зале. В каждой заявке указаны время начала и время окончания мероприятия (в минутах от начала суток)… Определите, какое максимальное количество мероприятий можно провести в конференц-зале и каков при этом максимально возможный перерыв между двумя последними мероприятиями.»

Условие всегда заканчивается предупреждением: «Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов». Числа в тексте условия — это только демонстрация метода на пяти-десяти значениях; реальный входной файл содержит тысячи чисел, и посчитать его без программы невозможно.

Форма ответа: ДВА числа в ДВУХ ячейках таблицы

Ответ на задание 26 — это не строка «2172 50», а два отдельных числа в двух ячейках таблицы ответов: в первую ячейку — первое число, во вторую — второе, строго в том порядке, который требует условие (обычно сначала количество, затем величина). На бумаге и в тренажёре это выглядит как строка с двумя полями ввода, а не одно поле.

Слитная запись обоих чисел в одну ячейку (например, «2172 50» в одном поле) на реальном КЕГЭ не засчитывается по форме ответа — числа должны быть разнесены по ячейкам, а не написаны через пробел одной строкой.

Правило частичного зачёта — дословно

Задания 26 и 27 — это единственные два задания из 27, где кроме «всё верно / всё неверно» есть промежуточный результат в 1 балл. Все остальные 25 заданий оцениваются строго «полностью совпадает с эталоном — 1 балл, иначе 0». Вот дословная формулировка спецификации:

«За верный ответ на каждое из заданий 26 и 27 выставляется 2 балла. […] Если в ответе на задание 26 числа в ячейках таблицы перепутаны местами ИЛИ в ячейках таблицы присутствует только одно верное число (второе неверно или отсутствует), ставится 1 балл. В остальных случаях – 0 баллов.» (СПЕЦ ЕГЭ-2026 по информатике, §10)

Балл	Когда ставится
2 балла	Оба числа верны и стоят каждое в своей правильной ячейке
1 балл	Числа верны, но перепутаны местами (второе число стоит в первой ячейке и наоборот) ЛИБО в ячейках присутствует только одно верное число (второе неверно или отсутствует)
0 баллов	Всё остальное: оба числа неверны, оба отсутствуют, либо ответ записан не в форме двух ячеек (например, слитно одной строкой)

Обратите внимание на союз «ИЛИ» в тексте спецификации: правило частичного зачёта — это одно из двух независимых условий, а не сумма «одно число из двух» в упрощённом смысле. Формулировка «одно верное значение из двух — всегда 1 балл» неточна: если ответ записан не в виде двух ячеек, а слитной строкой, ни одно из двух условий формально не выполняется в том виде, в каком его проверяет автоматическая система, — рискуете получить 0 вместо 1. Правило 26 отличается от правила 27: задание 27 оперирует не отдельными числами, а парами чисел (строками таблицы), и правила зачёта у них разные, хоть и похожие по духу.

Теория: всё, что нужно для задания 26

Сортировка — ядро линии 26

Название линии в кодификаторе прямое: «обработка целочисленной информации с использованием сортировки». Это не украшение программы, а необходимое условие: без предварительной сортировки жадный алгоритм, на котором строится решение, перестаёт быть верным.

Возьмите неотсортированный список коржей — 30, 43, 32, 40, 50. Идя по нему в исходном порядке и жадно набирая корж, если он хотя бы на 4 меньше предыдущего взятого, вы легко «застрянете»: взяв 30 первым, вы упустите шанс начать с самого большого коржа 50 и построить более длинную башню. Отсортировав по убыванию (50, 43, 40, 32, 30), жадный проход слева направо гарантированно не пропускает более выгодных вариантов — но об этом подробнее в следующем блоке.

На Python сортировка занимает одну строку, и у неё есть три рабочих формы:

a.sort()                       # по возрастанию, меняет сам список
a.sort(reverse=True)           # по убыванию
b = sorted(a)                  # по возрастанию, возвращает новый список
b = sorted(a, reverse=True)    # по убыванию, новый список
pairs.sort(key=lambda p: p[1]) # по второму элементу пары (кортежа)
pairs.sort()                   # кортежи сравниваются лексикографически:
                                # сначала по первому элементу, при равенстве —
                                # по второму

Последняя строка — ключевая для второго типового сюжета этой статьи. Если элементы списка — не числа, а пары (кортежи), то sort() без аргументов сравнивает их лексикографически: сначала по первому числу пары, а при совпадении первых чисел — по второму. Это ровно то поведение, которое нужно для сортировки «по основному ключу, а при равенстве — по дополнительному», без явного key=.

Практический вывод: прежде чем писать цикл с условием отбора, задайте себе вопрос — «по какому полю сортировать и в каком порядке?». Ответ на этот вопрос почти всегда виден из формулировки («диаметр каждого верхнего коржа меньшедиаметра предыдущего» → сортировка по убыванию; «как можно больше мелких предметов» → сортировка по возрастанию).

Жадность после сортировки: многоярусный торт

Разберём типовой сюжет «многоярусный торт» целиком. Условие: есть N коржей с диаметрами, корж A можно поставить на корж B, если диаметр A хотя бы на 4 единицы меньше диаметра B. Нужно найти наибольшее число коржей в башне и максимально возможный диаметр самого маленького коржа в такой башне.

Алгоритм в три шага

Отсортировать диаметры по убыванию.
Идти по отсортированному списку и жадно брать очередной корж, если он хотя бы на 4 меньше последнего взятого (первый корж берём всегда — это самый большой из всех).
Ответ: количество взятых коржей и диаметр последнего взятого — он и есть самый маленький в построенной башне.

f = open("26.txt")
n = int(f.readline())
diameters = sorted((int(x) for x in f), reverse=True)

count = 0
last = None
for d in diameters:
    if last is None or d <= last - 4:
        count += 1
        last = d

print(count, last)

Почему жадность здесь оптимальна

Это классический аргумент «обмена» (exchange argument). Допустим, есть какая-то оптимальная башня максимальной длины, но её первый (самый большой) корж — не тот же, что глобальный максимум среди всех N коржей. Тогда можно заменить первый корж оптимальной башни на глобально самый большой: поскольку он не меньше исходного, разница с любым следующим коржом башни только увеличится, а значит условие «хотя бы на 4 меньше» для второго коржа выполнится и подавно. Длина башни от такой замены не уменьшится. Повторяя это рассуждение для каждой позиции, любую оптимальную башню можно превратить в ту, что строит жадный алгоритм, не потеряв в длине. А раз жадная башня не короче любой другой, она и есть самая длинная.

Диаметр самого маленького коржа при этом получается сам собой: жадный алгоритм на каждом шаге оставляет для следующих коржей максимально возможный запас «сверху» (он берёт самый большой из всех подходящих на данный момент), поэтому последний взятый корж — одновременно и самый маленький в самой длинной из возможных башен, и самый большой среди вариантов такой длины.

Второй сюжет: очередь и сортировка по нескольким ключам

Второй распространённый сюжет линии 26 — расписание или очередь заявок, каждая из которых описана не одним числом, а парой (например, время начала и время окончания мероприятия). Здесь сортировки одного ключа уже недостаточно: нужно отсортировать по одному полю, а при совпадении — по другому.

Пример: заявки на конференц-зал, каждая — пара «начало, конец». Можно провести только те мероприятия, чьи отрезки времени не пересекаются (совпадение конца одного с началом другого разрешено). Нужно найти максимальное число мероприятий и второе число — самый длинный перерыв между двумя последними из них.

Стандартный приём для такой задачи — отсортировать заявки по времени окончания и затем перебором с динамическим программированием найти самую длинную непересекающуюся цепочку. Удобно хранить заявки как пары (конец, начало) — тогда обычный list.sort() без явного key отсортирует их по времени окончания, а при совпадении конца — по времени начала (это и есть лексикографическая сортировка кортежей из блока выше):

f = open("26.txt")
n = int(f.readline())
events = []
for _ in range(n):
    start, end = map(int, f.readline().split())
    events.append((end, start))
events.sort()

dp = [1] * n
for i in range(n):
    for j in range(i):
        if events[j][0] <= events[i][1] and dp[j] + 1 > dp[i]:
            dp[i] = dp[j] + 1

best = max(dp)
gap = 0
for i in range(n):
    if dp[i] != best:
        continue
    for j in range(n):
        if dp[j] == best - 1 and events[j][0] <= events[i][1]:
            gap = max(gap, events[i][1] - events[j][0])

print(best, gap)

Здесь dp[i] — наибольшее число мероприятий в расписании, где мероприятие i идёт последним; находится оно как dp[j] + 1 по лучшей заявке j, которая заканчивается не позже начала i. Само по себе N до 1000, поэтому квадратичный перебор пар укладывается в отведённое время с большим запасом. Сортировка по (конец, начало) — обязательный первый шаг: без неё динамика по «предыдущим» индексам не имеет смысла, потому что «предыдущий» по времени элемент может стоять в файле как угодно далеко.

Как получить второе число ответа

Задание 26 всегда просит не одну величину, а две, и вторая редко требует отдельного прохода по массиву — обычно её можно получить, отслеживая дополнительную переменную по ходу того же прохода, которым вы уже считаете первое число.

В сюжете «торт/коробки» второе число — это диаметр (сторона) последнего взятого элемента. Его не нужно искать отдельно: он просто остаётся в переменной last после завершения цикла, которым посчитано первое число.
В сюжете «архив/переноска файлов» алгоритм двухшаговый: сначала жадно (по возрастанию) находят максимальное число элементов k, которые помещаются в объём S; затем, зафиксировав это k, ищут максимальный элемент, который ещё можно добавить, если остальные k − 1 взять как можно меньшими. Второе число — не «случайный элемент», а результат отдельного, но короткого пересчёта по уже отсортированному массиву.
В сюжете «очередь/расписание» второе число (перерыв, разрыв, задержка) вычисляется как побочный продукт заполнения таблицы динамического программирования — переменная обновляется внутри того же цикла, где считается оптимальная длина цепочки.

Общее правило: прежде чем писать код, распишите на черновике, какая переменная в вашем алгоритме будет хранить второе число к моменту, когда цикл закончится. Если такой переменной не находится — скорее всего, нужен второй, отдельный проход по уже отсортированному (и потому недорогому) массиву, как в сюжете с архивом.

Как правильно прочитать входной файл

Формат входного файла в задании 26 почти всегда один из двух:

первая строка — количество элементов N, затем N строк с одним числом в каждой (сюжеты «торт», «коробки»);
первая строка — два числа через пробел, например объём S и количество N, затем N строк с данными (сюжеты «архив», «переноска файлов», «конференц-зал»).

Рабочий шаблон чтения на Python — прочитать первую строку отдельно, а остаток файла отдать генератору или циклу:

f = open("26.txt")
n = int(f.readline())              # первая строка — это count, не данные
data = [int(x) for x in f]         # остаток файла построчно

f = open("26.txt")
s, n = map(int, f.readline().split())  # первая строка — два числа
data = [int(x) for x in f]

Открывать файл нужно с тем же именем, что указано в задании в тренажёре (обычно оно совпадает с номером задания), и в той же папке, что и сама программа. Перед сдачей полезно вывести len(data) и сверить с прочитанным N — если числа разошлись, значит первая строка была прочитана неверно.

Алгоритм решения задания 26

Прочитайте условие до конца и выпишите: что именно нужно найти первым числом, что вторым, и в каком порядке их печатать. Обратите внимание на пороговое слово («хотя бы на», «не более», «строго меньше») — от него зависит, будет ли сравнение строгим или нестрогим.
Определите формат входного файла: одно число N в первой строке или пара чисел; данные — одно число в строке или пара. Сверьтесь с типовым примером из условия, но помните, что реальный файл — не он.
Выберите ключ и порядок сортировки: если нужно набрать как можно больше мелких элементов — сортировка по возрастанию; если нужна убывающая цепочка с разницей не менее порога — по убыванию; если элементы — пары, отсортируйте кортеж целиком или укажите key=.
Постройте жадный проход (или DP) по отсортированному массиву, накопив в одной переменной первое число ответа.
Определите, какая переменная даст второе число — это либо значение, оставшееся в памяти после первого прохода (последний взятый элемент), либо результат короткого второго прохода по уже отсортированному массиву.
Проверьте программу на типовом примере из условия. Если она не воспроизводит числа из иллюстративного примера — в логике есть ошибка, и её проще найти на 5 числах, чем на 10 000.
Запишите два числа в две отдельные ячейки таблицы ответа в верном порядке — тот, что указан в условии («сначала… затем…»).

Доведите алгоритм до автоматизма

2 первичных балла за задание — это ощутимая доля в общем результате. Прорешайте несколько сюжетов линии 26 с реальными файлами из банка ФИПИ на Repet.ai.

Открыть тренажёр

Примеры с разбором

Пример 1. Многоярусный торт (сортировка по убыванию)

Условие (реальное задание из открытого банка ФИПИ):

В кондитерской есть N круглых форм для коржей. Специализация кондитерской – многоярусные торты, в которых диаметр каждого верхнего коржа меньше диаметра предыдущего. Один корж можно поместить на другой, если его диаметр хотя бы на 4 единицы меньше диаметра другого коржа. Определите наибольшее количество коржей, которое можно использовать для создания многоярусного торта, и максимально возможный диаметр самого маленького коржа. Входной файл: в первой строке — число N (не больше 10 000), далее N строк с диаметрами (натуральные числа, не больше 10 000).

Решение:

Сортируем диаметры по убыванию и жадно строим башню сверху вниз: берём очередной корж, если он хотя бы на 4 меньше последнего взятого.

f = open("26.txt")
n = int(f.readline())
diameters = sorted((int(x) for x in f), reverse=True)

count = 0
last = None
for d in diameters:
    if last is None or d <= last - 4:
        count += 1
        last = d

print(count, last)

На прилагаемом файле (N = 10 000 диаметров) программа печатает:

2172 50

Ответ: 2172 и 50 — это совпадает с эталоном банка. Проверка здравым смыслом: если бы порог был не 4, а 3 (как в иллюстративном примере условия для мини-набора из пяти коржей), результат для того мини-набора — 3 коржа с диаметром 32 в основании, что и написано в самом условии как образец работы метода.

Пример 2. Архив на диске (сортировка по возрастанию, второй проход)

Условие (реальное задание из открытого банка ФИПИ):

Системный администратор раз в неделю создаёт архив пользовательских файлов. Однако объём диска, куда он помещает архив, может быть меньше, чем суммарный объём архивируемых файлов. По заданной информации об объёме файлов пользователей и свободном объёме на архивном диске определите максимальное число пользователей, чьи файлы можно сохранить в архиве, а также максимальный размер имеющегося файла, который может быть сохранён в архиве, при условии, что сохранены файлы максимально возможного числа пользователей. Входной файл: в первой строке — S (свободное место, не больше 10 000) и N (число пользователей, не больше 1000), далее N строк с объёмами файлов (не больше 100).

Решение:

Задача решается в два шага. Сначала находим максимальное число файлов: сортируем объёмы по возрастанию и жадно набираем самые маленькие, пока сумма не превысит S — это и есть наибольшее возможное число файлов k (любой набор из k + 1 файлов весит не меньше, чем k + 1 самых маленьких, а те уже не помещаются). Затем, зафиксировав k, ищем максимальный файл, который ещё можно добавить, если остальные k − 1 взять как можно легче — то есть тоже самые маленькие из списка.

f = open("26.txt")
s, n = map(int, f.readline().split())
volumes = sorted(int(x) for x in f)

total = 0
k = 0
for v in volumes:
    if total + v <= s:
        total += v
        k += 1
    else:
        break

base = sum(volumes[:k - 1])
biggest = max(v for v in volumes[k - 1:] if base + v <= s)

print(k, biggest)

На прилагаемом файле (S = 8200, N = 970) программа печатает:

568 50

Ответ: 568 и 50 — совпадает с эталоном банка. На иллюстративном примере из условия (S = 100, файлы 80, 30, 50, 40) тот же алгоритм даёт 2 и 50 — ровно то, что написано в тексте задания как образец.

Пример 3. Заявки в конференц-зал (сортировка пар, DP)

Условие (реальное задание из открытого банка ФИПИ):

Входной файл содержит сведения о заявках на проведение мероприятий в конференц-зале. В каждой заявке указаны время начала и время окончания мероприятия (в минутах от начала суток). Если время начала одного мероприятия меньше времени окончания другого, то провести можно только одно из них. Если время окончания одного мероприятия совпадает со временем начала другого, то провести можно оба. Определите, какое максимальное количество мероприятий можно провести в конференц-зале и каков при этом максимально возможный перерыв между двумя последними мероприятиями. Входной файл: в первой строке — число заявок N (не больше 1000), далее N строк с парой чисел «начало конец» (натуральные, не больше 1440).

Решение:

Это задача о непересекающемся расписании. Первое число — наибольшее количество мероприятий — находится динамическим программированием по заявкам, отсортированным как пары (конец, начало): dp[i] — наибольшая длина расписания, заканчивающегося заявкой i. Второе число — самый длинный перерыв между двумя последними мероприятиями оптимального расписания — ищем перебором пар, где одна заявка завершает расписание максимальной длины, а другая ей предшествует.

f = open("26.txt")
n = int(f.readline())
events = []
for _ in range(n):
    start, end = map(int, f.readline().split())
    events.append((end, start))
events.sort()

dp = [1] * n
for i in range(n):
    for j in range(i):
        if events[j][0] <= events[i][1] and dp[j] + 1 > dp[i]:
            dp[i] = dp[j] + 1

best = max(dp)
gap = 0
for i in range(n):
    if dp[i] != best:
        continue
    for j in range(n):
        if dp[j] == best - 1 and events[j][0] <= events[i][1]:
            gap = max(gap, events[i][1] - events[j][0])

print(best, gap)

На иллюстративном примере из условия (5 заявок) программа выдаёт 3 и 20 — ровно то, что написано в тексте задания. На прилагаемом файле (990 заявок) программа печатает:

32 15

Ответ: 32 и 15 — совпадает с эталоном банка. При N до 1000 квадратичный перебор пар (около миллиона операций) укладывается в отведённое время с большим запасом.

Типичные ошибки и ловушки

Отсортировали по возрастанию вместо убывания (или наоборот)

В сюжете «торт» нужна сортировка по убыванию — башня строится сверху вниз, от самого большого коржа. В сюжете «архив», наоборот, нужно возрастание — чтобы максимизировать количество, берут самые маленькие элементы первыми. Перед написанием sort() явно проговорите: «мне нужны сначала большие или сначала маленькие?».

Строгое неравенство вместо нестрогого

Фраза «хотя бы на 4 единицы меньше» означает разницу не меньше 4, то есть условие в коде должно быть d ≤ last - 4 (эквивалентно last - d ≥ 4), а не строгое d < last - 4. Если диаметры отличаются ровно на 4, такая пара обязана засчитываться — строгое неравенство её отбросит и незаметно занизит первое число ответа.

Прочитали первую строку файла как данные, а не как N

Если сразу собрать все строки файла в список чисел без отдельного чтения первой строки, в массив данных попадёт лишнее число N (или пара S, N) — оно исказит и сортировку, и сумму. Всегда читайте первую строку отдельным вызовом f.readline(), а остаток файла — отдельным циклом или генератором.

Вывели числа в неверном порядке

Условие явно указывает порядок: «запишите в ответе два целых числа: сначала… затем…». Если поменять числа местами при выводе (например, напечатать сначала диаметр, а не количество), по правилу частичного зачёта это даст не 0, а 1 балл — но 2 балла всё равно будут упущены. Сверяйте порядок вывода с условием, а не с порядком, в котором величины были вычислены в коде.

Записали оба числа в одну ячейку

Ответ на задание 26 — два числа в двух отдельных ячейках таблицы, а не строка «2172 50» в одном поле. На реальном КЕГЭ слитная запись обоих чисел в одну ячейку не засчитывается по форме ответа — переносите в бланк каждое число в своё поле.

Второе число искали отдельным жадным проходом «с нуля»

В сюжете «архив» второе число нельзя получить, снова жадно идя по всему списку — там нужен пересчёт при фиксированном количестве k, найденном на первом шаге: берём k − 1 самых маленьких элементов и ищем максимальный, который ещё помещается в оставшийся объём. Пропуск этого условия («при фиксированном k») — частая причина неверного второго числа при верном первом.

Не проверили программу на примере из условия

Каждое условие задания 26 приводит короткий иллюстративный пример с известным ответом (например, «3 и 20» или «2 и 50»). Если программа перед запуском на реальном файле не воспроизводит этот пример, ошибка почти наверняка в логике, а не в данных — искать её на 10 000 строках гораздо дольше, чем на пяти.

Как задание 26 связано с остальным экзаменом

Всего в КЕГЭ 27 заданий с максимальным первичным баллом 29, работа выполняется за компьютером за 235 минут. Задание 26 занимает в этой конструкции особое место:

вместе с заданиями 21, 24, 25 и 27 входит в число пяти заданий высокого уровня сложности — самых дорогих и самых объёмных на весь экзамен;
делит код требования 2.12 с заданием 25 — тоже программирование с сортировкой, но ответ там записывается в виде таблицы N×2, а не двух ячеек;
разделяет форму ответа «два числа в двух ячейках» с заданием 17 — оно проще (повышенный уровень вместо высокого), но приём «сортировка → жадный проход → две отслеживаемые величины» общий для обоих;
вместе с заданием 27 — единственная пара заданий во всём экзамене с частичным зачётом (1 балл за неполный или переставленный ответ);
соседствует по типу входных данных (файл *.txt, нужна среда программирования) с заданием 24 — там программа обрабатывает символьную, а не целочисленную информацию.

Задание 17 — тот же формат ответа Задание 25 — тот же код требования Задание 27 — вторая пара с частичным зачётом Все задания ЕГЭ по информатике

План подготовки на 3 недели

Неделя 1 — сортировка и жадный алгоритм

День 1–2: повторите три формы сортировки в Python (sort(), sorted(), сортировку по key и сортировку кортежей) и научитесь быстро решать, какой порядок нужен под конкретную формулировку. День 3–5: разберите сюжет «многоярусный торт» на маленьком наборе из 5–10 чисел, который вы придумаете сами, и проверьте программу вручную. День 6–7: решите 3–4 задания сюжета «торт/коробки» из открытого банка с реальными файлами, каждый раз сверяясь с иллюстративным примером условия перед запуском на полном файле.

Неделя 2 — двухшаговые задачи и сортировка пар

День 1–3: разберите сюжет «архив/переноска файлов» — сортировка по возрастанию, жадный подсчёт количества, затем отдельный пересчёт второго числа при фиксированном k. День 4–5: разберите сюжет «конференц-зал» — сортировку пар (конец, начало) и динамическое программирование по отсортированному списку. День 6–7: решите по 2–3 задания каждого сюжета, засекая время — на всё задание должно уходить не больше 35 минут вместе с проверкой на иллюстративном примере.

Неделя 3 — форма ответа и разбор ошибок

День 1–3: отработайте запись ответа именно в две отдельные ячейки в правильном порядке — это отдельный навык, независимый от программирования. День 4–5: намеренно внесите в свой код типичные ошибки из этой статьи (строгое неравенство вместо нестрогого, чтение первой строки как данных) и убедитесь, что замечаете неверный результат сразу. День 6–7: прорешайте оставшиеся задания линии 26 из банка в тренажёре без подсказок, полностью укладываясь в 35 минут на задание.

Проверьте себя на реальных заданиях

На Repet.ai собраны задания ЕГЭ по информатике из открытого банка ФИПИ с прикреплёнными файлами. Решайте онлайн, проверяйте ответ мгновенно — бесплатно.

Перейти к практике

Частые вопросы

Часто задаваемые вопросы

Умение обрабатывать целочисленную информацию с использованием сортировки — так формулирует это умение обобщённый план ФИПИ. Нужно написать программу, которая читает из прилагаемого файла *.txt большой массив целых чисел, сортирует его и с помощью жадного алгоритма или динамического программирования находит два числа-ответа. Проверяемый элемент содержания — КЭС 3.10, код требования — 2.12.

2 первичных балла — вместе с заданием 27 это самые дорогие задания всего экзамена. Уровень сложности — высокий. По обобщённому плану ФИПИ на задание 26 отводится примерно 35 минут — больше только на задание 27 (40 минут).

Да, но с уточнением по форме записи. По спецификации 1 балл ставится, если числа в ячейках таблицы перепутаны местами ИЛИ в ячейках присутствует только одно верное число (второе неверно или отсутствует). Это правило работает именно для двух отдельных ячеек таблицы ответа — если ответ записан не в этой форме, а слитной строкой в одном поле, по форме ответа он не будет засчитан как верный.

Нет. Форма ответа задания 26 — два числа, каждое в своей ячейке таблицы, а не строка с пробелом в одном поле. Слитная запись обоих чисел в одну ячейку на реальном КЕГЭ не соответствует требуемой форме ответа. Записывайте первое число в первую ячейку, второе — во вторую, в том порядке, который указан в условии.

Потому что жадный алгоритм, на котором строится решение большинства сюжетов линии 26, работает верно только на отсортированных данных. Например, в сюжете «многоярусный торт» жадный проход слева направо по несортированному списку диаметров может пропустить более выгодный порядок набора коржей и занизить ответ. Сортировка превращает задачу в проход по массиву с локальным условием отбора, для которого жадность доказуемо оптимальна.

Чаще всего вторую величину можно получить, отслеживая дополнительную переменную по ходу того же прохода, которым считается первое число (например, диаметр последнего взятого коржа). В некоторых сюжетах, как в задаче про архив на диске, нужен короткий второй проход по уже отсортированному массиву при зафиксированном на первом шаге количестве элементов.

У заданий 26 и 17 одинаковая форма ответа — два числа в двух ячейках, но задание 17 повышенного уровня и проще по алгоритму. Задание 25 делит с заданием 26 код требования 2.12 (программирование с сортировкой), но там ответ — не два числа, а таблица N×2, где в первом столбце числа идут в порядке возрастания. Задание 27 — второе задание с частичным зачётом, но там правило устроено вокруг пар чисел (строк таблицы), а не отдельных чисел.

На экзамене доступны C#, C++, Pascal, Java и Python. Задание требует прочитать данные из прилагаемого файла *.txt, поэтому язык должен поддерживать чтение файлов — все перечисленные среды это умеют. В этой статье код приведён на Python как наиболее распространённом языке для подготовки к КЕГЭ.

Готовы взять 2 балла высокого уровня?

Задание 26 стоит вдвое дороже большинства заданий экзамена, а приём в его основе — сортировка плюс жадный проход — один и тот же для всех сюжетов линии. Отработайте его на реальных файлах из открытого банка ФИПИ с мгновенной проверкой ответа.

Тренировать задание 26 Пройти пробный экзамен Все задания ЕГЭ по информатике