Е26.43 определите наибольший суммарный объём, переданных на сервер с одного клиентского устройства данных

Сервер выполняет запросы на передачу данных, при этом сведения о каждом выполненном запросе (время регистрации, идентификатор клиента, объём переданных данных) сохраняются в журнале работы, а переданные данные — в специальном разделе памяти сервера, имеющем ограниченный объём. Каждый раз, когда остаётся недостаточно свободной памяти, сервер создаёт резервную копию всех накопленных там данных, после чего освобождает раздел и продолжает выполнение запросов. Напишите программу для обработки журнала работы сервера и с её помощью определите наибольший суммарный объём, переданных на сервер с одного клиентского устройства данных, не превышающий 150 000 Кбайт, а также сумму объёмов (в Кбайт) двух последних по времени резервных копий специального раздела, выполненных не позднее 11:59:59.

Входные данные

Первая строка входного файла (журнала работы сервера) содержит два натуральных числа: N (N < 1 000 000) — количество строк в журнале и K (K < 1 000 000) — вместимость специального раздела памяти сервера в Кбайт. Каждая из следующих N строк содержит информацию об одном выполненном запросе: время регистрации запроса в формате ЧЧ:ММ:СС (часы, минуты, секунды), а также два натуральных числа: C (C < 1 000 000) — идентификатор клиентского устройства и S (S < K) — объём данных запроса в Кбайт.

Выходные данные

В ответе запишите два числа: сначала наибольший суммарный объём данных с одного клиентского устройства, не превышающий 150 000 Кбайт, а затем сумму объёмов (в Кбайт) двух последних по времени резервных копий специального раздела, выполненных не позднее 11:59:59.

Типовой пример организации данных во входном файле

8 140000

01:01:01 101 20000

03:03:03 202 110000

05:05:05 101 90000

07:07:07 303 62000

10:10:10 101 48000

15:15:15 202 12000

21:21:21 303 120000

23:23:23 404 134000

При таких исходных данных резервное копирование специального раздела выполняется четыре раза: в 5:05:05 (в объёме 130 000 Кбайт), в 07:07:07 (в объёме 90 000 Кбайт), в 21:21:21 (в объёме 122 000 Кбайт) и в 23:23:23 (в объёме 120 000 Кбайт).

Всего на сервер должно быть передано 596 000 Кбайт данных: 158 000, 122 000, 182 000 и 134 000 Кбайт от клиента идентификатором 101, 202, 303, 404 соответственно. Ответ для приведённого примера: 134 000 220 000.

Типовой пример имеет иллюстративный характер.

Для выполнения задания используйте данные из прилагаемого файла.

файла.

TXT

наибольший суммарный объём данных с одного клиентского устройства, не превышающий 150 000 Кбайт

сумму объёмов (в Кбайт) двух последних по времени резервных копий специального раздела, выполненных не позднее 11:59:59

Резервная волна ЕГЭ по информатике 22.06.2026 – задание №26

Решение:

Решение на Python

f = open('26.txt')

N, K = map(int, f.readline().split())

data = []
clients = {}

for _ in range(N):
    t, c, s = f.readline().split()
    c = int(c)
    s = int(s)

    h, m, sec = map(int, t.split(':'))
    time = h * 3600 + m * 60 + sec

    data.append((time, s))

    clients[c] = clients.get(c, 0) + s

data.sort()

mx = max(x for x in clients.values() if x <= 150000)

memory = 0
copies = []

limit = 11 * 3600 + 59 * 60 + 59

for time, s in data:
    if memory + s > K:
        if time <= limit:
            copies.append(memory)

        memory = 0

    memory += s

print(mx, copies[-1] + copies[-2])

f = open('26.txt')

N, K = map(int, f.readline().split())

data = []

clients = {}

for _ in range(N):

t, c, s = f.readline().split()

c = int(c)

s = int(s)

h, m, sec = map(int, t.split(':'))

time = h * 3600 + m * 60 + sec

data.append((time, s))

clients[c] = clients.get(c, 0) + s

data.sort()

mx = max(x for x in clients.values() if x <= 150000)

memory = 0

copies = []

limit = 11 * 3600 + 59 * 60 + 59

for time, s in data:

if memory + s > K:

if time <= limit:

copies.append(memory)

memory = 0

memory += s

print(mx, copies[-1] + copies[-2])

Объяснение решения

В задаче необходимо получить два значения:

наибольший суммарный объём данных от одного клиента, не превышающий 150000 Кбайт;
сумму объёмов двух последних резервных копий, созданных не позднее 11:59:59.

Считывание исходных данных

Сначала открываем файл и считываем количество записей N и объём специального раздела памяти K:

f = open('26.txt')

N, K = map(int, f.readline().split())

f = open('26.txt')

N, K = map(int, f.readline().split())

Создаём два объекта:

data = []
clients = {}

data = []

clients = {}

В список data будем сохранять запросы, а в словаре clients — суммарный объём данных для каждого клиента.

Обработка запросов

Каждая строка содержит время, идентификатор клиента и объём данных:

for _ in range(N):
    t, c, s = f.readline().split()
    c = int(c)
    s = int(s)

for _ in range(N):

t, c, s = f.readline().split()

c = int(c)

s = int(s)

Время записано в формате ЧЧ:ММ:СС. Для удобства переведём его в количество секунд от начала суток:

h, m, sec = map(int, t.split(':'))
time = h * 3600 + m * 60 + sec

h, m, sec = map(int, t.split(':'))

time = h * 3600 + m * 60 + sec

Например, время 01:01:01 будет преобразовано в:

1 * 3600 + 1 * 60 + 1

1 2	1 * 3600 + 1 * 60 + 1

После этого добавляем запрос в список:

data.append((time, s))

1 2	data.append((time, s))

Подсчёт объёма данных для каждого клиента

Для каждого идентификатора клиента накапливаем общий объём переданных данных:

clients[c] = clients.get(c, 0) + s

1 2	clients[c] = clients.get(c, 0) + s

Метод get(c, 0) возвращает уже накопленную сумму для клиента c. Если такого клиента ещё нет в словаре, используется значение 0.

Сортировка запросов по времени

По условию необходимо моделировать работу сервера в хронологическом порядке, поэтому сортируем запросы:

data.sort()

1 2	data.sort()

Так как первым элементом каждой пары является время, список автоматически сортируется по времени выполнения запроса.

Первое число ответа

Теперь в словаре clients находятся суммарные объёмы данных всех клиентов.

Нужно выбрать максимальный объём, не превышающий 150000 Кбайт:

mx = max(x for x in clients.values() if x <= 150000)

1 2	mx = max(x for x in clients.values() if x <= 150000)

Выражение перебирает все суммарные объёмы и оставляет только значения, удовлетворяющие условию:

x <= 150000

1 2	x <= 150000

Из них выбирается максимальное.

Моделирование работы памяти сервера

Переменная memory хранит текущий объём данных в специальном разделе памяти:

memory = 0

1 2	memory = 0

В список copies будем записывать объёмы резервных копий:

copies = []

1 2	copies = []

Ограничение по времени

Нас интересуют только резервные копии, созданные не позднее 11:59:59.

Переведём это время в секунды:

limit = 11 * 3600 + 59 * 60 + 59

1 2	limit = 11 * 3600 + 59 * 60 + 59

Когда создаётся резервная копия

Перебираем запросы по времени:

for time, s in data:

1 2	for time, s in data:

Перед добавлением нового запроса проверяем, помещается ли он в оставшуюся память:

if memory + s > K:

1 2	if memory + s > K:

Если сумма текущего объёма памяти и нового запроса превышает вместимость K, значит новый запрос уже не помещается.

В этот момент сервер создаёт резервную копию всех данных, которые уже находятся в памяти.

Сохранение нужных резервных копий

Если время создания резервной копии не превышает 11:59:59, сохраняем её объём:

if time <= limit:
    copies.append(memory)

if time <= limit:

copies.append(memory)

Важно, что резервная копия создаётся именно перед выполнением текущего запроса. Поэтому временем копирования считается время запроса, который уже не помещается в память.

Очистка памяти

После резервного копирования специальный раздел освобождается:

memory = 0

1 2	memory = 0

Теперь текущий запрос записывается уже в пустую память:

memory += s

1 2	memory += s

Если запрос помещается без резервного копирования, он просто добавляется к уже накопленным данным.

Второе число ответа

В списке copies находятся объёмы всех подходящих резервных копий в хронологическом порядке.

Нужно взять две последние:

copies[-1]
copies[-2]

copies[-1]

copies[-2]

И найти их сумму:

copies[-1] + copies[-2]

1 2	copies[-1] + copies[-2]

Вывод результата

В конце выводим два требуемых числа:

print(mx, copies[-1] + copies[-2])

1 2	print(mx, copies[-1] + copies[-2])

Первое число — максимальный суммарный объём данных одного клиента, не превышающий 150000 Кбайт.

Второе число — сумма объёмов двух последних резервных копий, созданных не позднее 11:59:59.

Ответ: 149369 45828