26-е задание ЕГЭ по информатике может выпасть простым, а может и сложным.
Задания линейки 26 из разных источников
Задание 26. Информатика. ЕГЭ 2026. Статград. 16.12.2025
Просмотры: 298
Изменено: 16 декабря 2025
В высокотехнологичном центре кибербезопасности круглые сутки работают автоматические системы анализа трафика. Каждое сканирование сети имеет время запуска и завершения (в миллисекундах от начала суток). Считается, что в момент запуска и в момент завершения сканирование всё ещё активно. Необходимо проанализировать работу центра за сутки и определить интервалы (непрерывные промежутки времени), когда не выполнялось ни одно сканирование сети.
Входные данные
В первой строке указано натуральное число \(N\) \((N < 100~000)\) – количество сканирований за сутки.
Следующие \(N\) строк содержат пары чисел: время начала и время окончания каждого сканирования (неотрицательные числа, меньшие \(86400000).\)
Запишите в ответе два натуральных числа: сначала найденное количество периодов, когда ни одно сканирование не проводилось, а затем их суммарную длительность (в мс).
Типовой пример организации данных во входном файле
\(5\)
\(10 \,\, 100\)
\(20 \,\, 120\)
\(130 \,\, 170\)
\(150 \,\, 200\)
\(250 \,\, 400\)
При таких исходных данных и длительности работы центра в \(500\) мс было \(4\) периода без сканирования: с \(0\) до \(10\) мс, с \(120\) до \(130\) мс, с \(200\) до \(250\) мс и с \(400\) до \(500\) мс. Их суммарная длительность равна $$(10 – 0) + (130 – 120) + (250 – 200) + (500 – 400) = 170.$$ Ответ для примера: \(4; \,\, 170.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
f = open('26.txt')
N = int(f.readline())
ti = [tuple(map(int, line.split())) for line in f]
ti.sort()
te, fin = 0, 86400000
p = 0
q, total = 0, 0
for p in range(N):
if ti[p][0] > te:
q += 1
total += ti[p][0] - te
te = max(te, ti[p][1])
if fin > te:
q += 1
total += fin - te
print(q, total)
Ответ: \(360 \,\, 376359\)
Задание 26. Информатика. ЕГЭ 2026. ЕГКР. 13.12.2025
Просмотры: 148
Изменено: 15 декабря 2025
Менеджеры интернет-магазина составляют рейтинговый список новых моделей смартфонов по данным о продолжительности автономной работы устройства в режиме ожидания и в активном режиме использования. У каждой модели известны оба показателя. Для объективности бренды и марки устройств скрыты, в списке все смартфоны пронумерованы начиная с единицы.
Алгоритм формирования рейтинга выглядит следующим образом:
все \(2N\) чисел, обозначающих продолжительности работы в режиме ожидания и в режиме активного использования для \(N\) устройств, располагаются по возрастанию;
если наименьший показатель соответствует продолжительности работы в режиме ожидания, устройство занимает первое свободное место от начала рейтинга;
если наименьший показатель относится к продолжительности работы в активном режиме использования смартфона, устройство занимает первое свободное место от конца рейтинга;
показатели устройств, ранее включённых в рейтинговый список, игнорируются.
Определите порядковый номер смартфона, чей рейтинг будет определён последним, и количество устройств, занявших позиции ниже него. Запишите в ответе два натуральных числа: сначала номер последнего устройства, для которого будет определено его место в рейтинге, затем количество устройств, которые займут в рейтинге более низкие места.
Входные данные
В первой строке входного файла находится натуральное число \(N\) \((N \leqslant 1000)\) — количество смартфонов. Следующие \(N\) строк содержат пары чисел, обозначающих соответственно продолжительность работы устройства в режиме ожидания в режиме активного использования (все числа натуральные, различные).
Решение:
Python
f = open('26.txt', 'r')
N = int(f.readline())
rating = [None] * N
data = []
for i in range(N):
w, a = map(int, f.readline().split())
data += [(w, 'w', i + 1), (a, 'a', i + 1)]
data.sort()
pb, pe = 0, N-1
smart = set()
curr, pc = 0, -1
for d in data:
t, r, n = d
if n not in smart:
smart.add(n)
curr = n
if r == 'w':
rating[pb] = t
pc = pb
pb += 1
else:
rating[pe] = t
pc = pe
pe -= 1
print(curr, N - 1 - pc)
Ответ: \(667 \,\, 517\)
Задание 26. Информатика. ЕГЭ 2026. Крылов. Вариант 1
Просмотры: 109
Изменено: 12 декабря 2025
Организаторам спортивных соревнований необходимо доставить как можно большее число команд в некоторый город. Для доставки используются самолёты определённой поссажировместимости. Входной файл содержит сведения о количестве человек в команде и о пассажировместимости самолётов, которые имеются в наличии.
Из соображений безопасности в одном самолёте может лететь только одна команда. Найдите способ доставить на соревнования максимально возможное число команд. Если способов несколько, то нужно выбрать такой, чтобы можно было доставить команду с максимальным числом участников.
Входные данные
В первой строке входного файла находятся два натуральных числа \(N\) \((N \leqslant 1000 )\) и \(M\) \((M \leqslant 1000 )\) — количество команд и количество самолётов соответственно. Следующие \(N\) строк содержат числа, обозначающие количество человек в команде, затем идут \(M\) строк, где указана пассажировместимость самолётов. Числа \(M\) и \(N\) могут быть не равны.
Запишите в ответе два натуральных числа: сначала максимальное количество команд, которые могут прибыть на соревнования, затем максимальную численность команды в этом случае.
Решение:
Python
f = open('26var01.txt')
N, M = map(int, f.readline().split())
teams = []
air = []
for i in range(N):
teams.append(int(f.readline()))
for i in range(M):
air.append(int(f.readline()))
teams.sort()
air.sort()
q, pt, pa = 0, 0, 0
lt, la = len(teams), len(air)
while pt < lt and pa < la:
if teams[pt] <= air[pa]:
q += 1
pt += 1
pa += 1
else:
pa += 1
pt = lt - 1
while teams[pt] > air[-1]:
pt -= 1
print(q, teams[pt])
Ответ: \(679 \,\, 194496\)
Задание 26. Информатика. ЕГЭ 2026. Статград. 23.10.2025
Просмотры: 832
Изменено: 24 октября 2025
В одном городе есть более \(100\) жилых домов. Все дома пронумерованы, начиная с единицы. Управляющая компания получила заявки на капитальный ремонт от жителей домов. В заявке указан номер дома и номер подъезда, где требуется ремонт, при этом каждой заявке присваивается уникальный идентификатор – натуральное число, не превышающее \(1~000~000.\) На один и тот же подъезд могут быть заявки сразу от нескольких жителей.
Определите номер дома, который имеет наибольшее количество подряд идущих подъездов с заявками на капитальный ремонт. Если есть несколько домов с одинаковым максимальным количеством подъездов, необходимо выбрать тот дом, у которого наименьший искомый подъезд имеет максимальный номер заявки.
Входные данные
В первой строке входного файла находится натуральное число \(N\) \( (N \leqslant 200~000)\) – количество полученных заявок на капитальный ремонт. Следующие \(N\) строк содержат три числа: номер заявки, номер дома и номер подъезда (все числа натуральные, не превышающие \(1~000~000).\)
Выходные данные
Запишите в ответе два натуральных числа: сначала номер дома с максимальным количеством подряд идущих подъездов, затем номер первого найденного подъезда из максимального числа подряд идущих подъездов в этом доме.
Решение:
Python
f = open('26.txt')
N = int(f.readline())
# houses - словарь, ключём является номер дома, значение - словарь, у которого ключ - номер подъезда
# а значение, номер заявки на этот подъезд
houses = {}
for line in f:
z, d, p = map(int, line.split())
if houses.get(d) is None:
houses[d] = {p: z}
else:
if houses[d].get(p) is None:
houses[d][p] = z
else:
houses[d][p] = max(houses[d][p], z)
max_z = 0 # в этой переменной будем хранить максимальное кодичество подряд идущих подъездов с заявками на ремонт
max_h = [] # список пар: первое число - наименьший номер подъезда из подряд идущих, второе число - номер заявки на этот подъезд
for d, v in houses.items():
m = 1 # текущее значение подряд идущих подъездов
mm = 1 # максимальное число подряд идущих подъездов для данного дома
pod = sorted(list(v.keys())) # список подъездов
st = pod[0] # текущее значение наименьшего подъезда при сканировании
stm = pod[0] # наименьший номер подъезда в максимальной группе подряд идущих подъездов
for p in range(1, len(pod)): # сканируем весь массив
if pod[p] == pod[p-1] + 1:
m += 1
else:
if mm < m:
mm = m
stm = st
st = pod[p]
m = 1
if mm < m: # обработка хвоста массива
mm = m
stm = st
if mm > max_z:
max_z = mm
max_h = [(d, stm)]
elif mm == max_z:
max_h.append((d, stm))
res = [(d, p, houses[d][p]) for d, p in max_h]
res.sort(key=lambda r: r[2], reverse=True) # сортировка по номеру заявки. максимальный номер на первом месте
print(res[0][0], res[0][1])
Ответ: \(171 \,\, 701\)
Задание 26. Информатика. ЕГЭ. Основная волна. Пересдача. 03.07.2025
Просмотры: 810
Изменено: 21 августа 2025
Для дачных участков СНТ необходимо закупить снегоуборщики. Для каждого из \(N\) участков будет куплен свой снегоуборщик. Известны минимальные требования к мощности этой техники для каждого из участков.
Для закупки доступно \(K\) моделей снегоуборщиков определённой мощности и стоимости. Количество экземпляров каждой модели не ограничено. Для каждого участка выбирается снегоуборщик минимальной стоимости, мощность которого не меньше требуемой; при одной и той же стоимости выбирается модель максимальной мощности.
Требуется определить общую стоимость закупки и максимальную мощность снегоуборщика, входящего в число купленных. В ответе запишите два числа: сначала суммарную стоимость всех купленных снегоуборщиков, затем максимальную мощность среди них.
Входные данные
Первая строка входного файла содержит два натуральных числа: \(N\) \((1 \leqslant N \leqslant 1~000~000)\) — количество участков СНТ и \(K\) \((1 \leqslant K \leqslant 100~000)\) — количество моделей снегоуборщиков соответственно. Следующие \(N\) строк содержат по одному натуральному числу, не превышающему \(1000,\) минимальные мощности снегоуборщиков, которые можно закупить для каждого из \(N\) участков. Далее в каждой из \(K\) строк содержится пара натуральных чисел — мощность очередной модели снегоуборщика и её стоимость соответственно. Мощность снегоуборщиков не превосходит \(1000,\) стоимость — \(100~000.\) Гарантируется, что любые две модели снегоуборщиков различаются по мощности или по стоимости. Закупить подходящий набор снегоуборщиков всегда можно.
Выходные данные
В ответе укажите два искомых числа: суммарную стоимость всех купленных снегоуборщиков и максимальную мощность среди них.
Типовой пример организации данных во входном файле
\(3 \, 4\)
\(1\)
\(2\)
\(3\)
\(10 \, 7\)
\(1 \, 5\)
\(3 \, 7\)
\(2 \, 3\)
При таких исходных данных для первого и второго участков оптимально закупить одинаковые снегоуборщики мощностью \(2\) и стоимостью \(3,\) для третьего участка будет закуплен снегоуборщик мощностью \(10.\) Стоимость закупки составит \(3 + 3 + 7 = 13.\) Ответ: \(13; \,\, 10.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемого файла.
Решение:
Python
fd = open('26.txt')
N, K = map(int, fd.readline().split())
wanted = []
for _ in range(N):
wanted.append(int(fd.readline()))
price_power = {}
for _ in range(K):
power, pr = map(int, fd.readline().split())
price_power[pr] = max(power, price_power.get(pr, 0))
snow = [[0, 0] for _ in range(1001)]
snow[0] = [10**20, 10**20]
for price, power in sorted(list(price_power.items())):
if not snow[power][1]:
i = power
while not snow[i][1]:
snow[i] = [price, power]
i -= 1
total_sum, max_pow = 0, 0
for power in wanted:
total_sum += snow[power][0]
max_pow = snow[power][1]
print(total_sum, max_pow)
Ответ: \(1879667450 \,\, 924\)
Задание 26. Информатика. ЕГЭ. Основная волна. Резерв. 23.06.2025
Просмотры: 400
Изменено: 21 августа 2025
В магазине для упаковки подарков есть \(N\) кубических коробок. Самой интересной считается упаковка подарка по принципу матрёшки — подарок упаковывается в одну из коробок, та в свою очередь в другую коробку и т.д. Дана изначальная коробка, а одну коробку можно поместить в другую, если длина её стороны хотя бы на \(D + K\) единиц больше длины стороны другой коробки \((K\) — порядковый номер новой коробки в матрешке, нумерация с нуля). Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, при условии что длина стороны самой большой коробки, где будет находиться подарок, будет иметь минимально возможную длину.
Входные данные
В первой строке входного файла находится число \(N\) — количество коробок в магазине (натуральное число, не превышающее \(10~000),\) \(S\) — изначальная коробка (натуральное число, не превышающее \(10~000)\) и \(D\) (натуральное число, не превышающее \(1~000).\) В следующих \(N\) строках находятся значения длин сторон коробок (все числа натуральные, не превышающие \(10~000),\) каждое — в отдельной строке.
Запишите в ответе два целых числа: сначала наибольшее количество коробок, которое можно использовать для упаковки одного подарка, затем минимально возможную длину стороны самой большой коробки в таком наборе.
Типовой пример организации данных во входном файле
\(5 \, 26 \, 6\)
\(50\)
\(41\)
\(33\)
\(40\)
\(55\)
При таких исходных данных условию задачи удовлетворяют наборы коробок с длинами сторон \(26,\) \(33,\) \(41,\) \(50\) или \(26,\) \(33,\) \(41,\) \(55,\) т.е. количество коробок равно \(4,\) а минимальная длина стороны самой большой коробки равна \(50.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26.txt')
N, S, D = map(int, fd.readline().split())
boxes = [int(x) for x in fd]
boxes.sort()
q = 1
prev = S
for p in range(len(boxes)):
if boxes[p] < prev + D + q:
continue
q += 1
prev = boxes[p]
print(q, prev)
Ответ: \(101 \,\, 9881\)
Задание 26. Информатика. ЕГЭ. Основная волна. Резерв. 19.06.2025
Просмотры: 936
Изменено: 21 августа 2025
На соревнованиях по спортивному ориентированию каждый участник должен пройти маршрут, посещая контрольные точки. Все контрольные точки пронумерованы натуральными числами начиная с \(1.\) В начале сезона соревнований каждому спортсмену присваивается уникальный номер — натуральное число, не превышающее \(1~000~000.\) Жюри фиксирует факт прохождения спортсменом контрольной точки. На разных этапах соревнований спортсмен может посетить одну и ту же контрольную точку в произвольном порядке несколько раз или не посетить совсем. Тренер в конце сезона анализирует результаты этапов соревнования, чтобы выявить контрольную точку, которую посетило наибольшее число спортсменов с идущими подряд номерами.
Определите максимальное число спортсменов с идущими подряд номерами и номер найденной контрольной точки. Если таких групп спортсменов несколько, укажите наименьший номер посещённой группой контрольной точки
Входные данные
В первой строке входного файла находится число \(N\) (натуральное число, не превышающее \(1~000~000)\) — количество посещений спортсменами контрольных точек в течение всего сезона соревнований. Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(1~000~000:\) номер спортсмена и номер посещённой им контрольной точки.
Выходные данные
Два целых неотрицательных числа: максимальное число спортсменов с идущими подряд номерами, посетивших одну и туже точку, и номер этой точки.
Типовой пример организации входных данных
\(9\)
\(41 \,\, 3\)
\(43 \,\, 125\)
\(50 \,\, 33\)
\(42 \,\, 125\)
\(42 \,\, 126\)
\(42 \,\, 127\)
\(41 \,\, 125\)
\(50 \,\, 126\)
\(42 \,\, 126\)
Для приведённого примера точку с номером \(125\) посетили три спортсмена с номерами \(41,\) \(42\) и \(43.\) Ответом является пара чисел: \(3 \,\, 125.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26_23383.txt')
#fd = open('26.txt')
N = int(fd.readline())
cp = {}
for line in fd:
n, pt = map(int, line.split())
if cp.get(pt):
cp[pt].add(n)
else:
cp[pt] = set([n])
arr = []
for pt in cp:
sportsmen = sorted(list(cp[pt]))
qmax = 1
q = 1
for p1 in range(1, len(sportsmen)):
if sportsmen[p1] - sportsmen[p1 - 1] > 1:
qmax = max(qmax, q)
q = 1
else:
q += 1
qmax = max(qmax, q)
arr.append((q, -pt))
arr.sort(reverse=True)
print(arr[0][0], -arr[0][1])
Ответ: \(56 \,\, 30113\)
Задание 26. Информатика. ЕГЭ. Основная волна. 11.06.2025
Просмотры: 1043
Изменено: 21 августа 2025
Входной файл содержит информацию заявках граждан, обращающихся во многофункциональный центр (МФЦ) в течение календарных суток. В заявке указаны время начала и время окончания приёма специалистом (в минутах от начала суток). Рабочие места специалистов МФЦ (окна) пронумерованы натуральными числами начиная с 1. Приём одного гражданина ведёт свободный специалист в окне с минимальным номером. Новый посетитель может обратиться к освободившемуся специалисту начиная со следующей минуты после завершения приёма предыдущего. Если в момент обращения в МФЦ свободных специалистов нет, то гражданин уходит. Определите, сколько граждан смогут попасть на приём в МФЦ в течение \(24\) ч, и каков номер окна специалиста, который начнёт принимать посетителя Если таких окон несколько, укажите наименьший номер окна.
Входные данные
В первой строке входного файла находится натуральное число \(K,\) не превышающее \(1000,\) — количество окон в МФЦ. Во второй строке — натуральное число \(N\) \((N \leqslant 10~000),\) обозначающее количество граждан. Каждая из следующих \(N\) строк содержит два натуральных числа, каждое из которых не превышает \(1440:\) указанные в заявке время начала и время окончания приёма (в минутах от начала суток).
Запишите в ответе два числа: количество граждан, которые смогут воспользоваться услугами МФЦ, и номер окна, в котором специалист примет последнего гражданина.
Типовой пример организации данных во входном файле
\(2\)
\(5\)
\(30 \,\, 60\)
\(40 \,\, 100\)
\(59 \,\, 60\)
\(61 \,\, 100\)
\(101 \,\, 144\)
При таких исходных данных воспользоваться услугами МФЦ смогут первый, второй, четвёртый и пятый граждане. Наименьший номер окна, где последний из граждан будет принят специалистом, — \(1,\) так как будут свободны окна \(1\) и \(2.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fp = open('26_23283.txt')
K = int(fp.readline())
N = int(fp.readline())
pos = [tuple(map(int, line.split())) for line in fp]
pos.sort()
windows = [0] * (K+1)
q = 0
last = 0
for p in pos:
st, end = p
for i in range(1, K+1):
if st > windows[i]:
windows[i] = end
q += 1
last = i
break
print(q, last)
Ответ: \(793 \,\, 2\)
Задание 26. Информатика. ЕГЭ. Основная волна. 10.06.2025-2
Просмотры: 610
Изменено: 11 июня 2025
Входной файл содержит сведения о заявках на проведение занятий в конференцзале. В каждой заявке указаны время начала и время окончания мероприятия (в минутах от начала суток). Если время начала одного мероприятия меньше времени окончания другого, то провести можно только одно из них. Если время окончания одного мероприятия совпадает с временем начала другого, то провести можно оба. Определите максимальное количество мероприятий, которое можно провести в конференц-зале и самое позднее время окончания последнего мероприятия.
Входные данные представлены в файле следующим образом. Первая строка входного файла содержит натуральное число \(N\) \((1 \leqslant N \leqslant 1000)\) – количество заявок на проведение мероприятий. Следующие \(N\) строк содержат пары чисел, обозначающих время начала и время окончания мероприятий. Каждое из чисел натуральное, не превосходящее \(1440.\) Запишите в ответе два числа: максимальное количество мероприятий, которое можно провести в конференц-зале и самое раннее время начала последнего мероприятия (в минутах от начала суток).
Пример входного файла
\(5\)
\(10 \,\, 150\)
\(100 \,\, 110\)
\(131 \,\, 170\)
\(131 \,\, 180\)
\(120 \,\, 130\)
При таких исходных данных можно провести максимум три мероприятия, например, по заявкам \(2,\) \(3\) и \(5.\) Последнее мероприятие в конференц-зала начнётся самое раннее на \(131\)-й минуте, если состоятся мероприятия по заявкам \(2,\) \(4,\) \(5.\) Ответ: \(3 \,\, 131.\)
Решение:
Python
fd = open('26_2.txt')
N = int(fd.readline())
meets = []
for line in fd:
tt = [int(x) for x in line.split()]
meets.append(tt)
meets.sort(key = lambda x: x[1])
chains = [0] * N
chains[0] = 1
for i in range(1, N):
chains[i] = max([chains[j] for j in range(i) if meets[i][0] >= meets[j][1]], default=0) + 1
m = max(chains)
print(m, min([meets[i][0] for i in range(N) if chains[i] == m]))
Ответ: \(16 \,\, 992\)
Задание 26. Информатика. ЕГЭ. Апробация. 14.05.2025-1
Просмотры: 1386
Изменено: 15 мая 2025
В магазине для упаковки подарков есть \(N\) кубических коробок. Самой интересной считается упаковка подарка по принципу матрёшки — подарок упаковывается в одну из коробок, та в свою очередь в другую коробку и т.д. Одну коробку можно поместить в другую, если длина её стороны хотя на \(4\) единицы меньше длины стороны другой коробки. Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, и максимально возможную длину стороны самой маленькой коробки, где будет находиться подарок. Размер подарка позволяет поместить его в самую маленькую коробку.
Входные данные
В первой строке входного файла находится число \(N\) — количество коробок в магазине (натуральное число, не превышающее \(10~000).\) В следующих \(N\) строках находятся значения длин сторон коробок (все числа натуральные, не превышающие \(10~000),\) каждое — в отдельной строке.
Запишите в ответе два целых числа: сначала наибольшее количество коробок, которое можно использовать для упаковки одного подарка, затем максимально возможную длину стороны самой маленькой коробки в таком наборе.
Типовой пример организации данных во входном файле
\(5\)
\(43\)
\(40\)
\(32\)
\(40\)
\(30\)
Пример входного файла приведён для пяти коробок и случая, когда минимальная допустимая разница между длинами сторон коробок, подходящих для упаковки «матрёшкой», не менее \(3\) единиц. При таких исходных данных условию задачи удовлетворяют наборы коробок с длинами сторон \(30,\) \(40\) и \(43\) или \(32,\) \(40\) и \(43\) соответственно, т.е. количество коробок равно \(3,\) а длина стороны самой маленькой коробки равна \(32.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
boxes = []
for line in fd:
boxes.append(int(line))
edges = sorted(boxes, reverse=True)
q = 1
cur_len = edges[0]
for p in range(1, len(edges)):
if cur_len - edges[p] >= 4:
q += 1
cur_len = edges[p]
print(q, cur_len)
Ответ: \(2172 \,\, 50\)
Задание 26. Информатика. ЕГЭ. ЕГКР. 19.04.2025
Просмотры: 860
Изменено: 8 мая 2025
В банке дистанционной проверяющей системы имеется более \(100~000\) заданий. Все задачи пронумерованы начиная с единицы. Эти задания в течение учебного периода решают участники различных курсов. Каждому студенту при регистрации присваивается уникальный идентификатор — натуральное число, не превышающее \(1~000~000.\) Студент может сдать несколько различных правильных решений одной задачи, при этом в зачёт идёт только одно из них.
Преподаватель сделал выгрузку результатов за некоторый период времени и выбрал студента, который решил наибольшее количество задач из банка через одну (одну решил, следующую нет и т.д.).
Определите идентификационный номер студента, который решил наибольшее количество задач через одну, и количество решённых им задач. Если несколько студентов решили одинаковое максимальное количество задач, то укажите студента с наименьшим идентификационным номером.
Входные данные
В первой строке входного файла находится число \(N\) — количество зачтённых решений (натуральное число, не превышающее \(60~000)\) за некоторый период времени. Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(1~000~000:\) идентификатор студента и номер правильно решённой задачи.
Выходные данные
Два целых неотрицательных числа: наименьший идентификационный номер студента и наибольшее количество успешно решённых задач через одну.
Типовой пример организации входных данных
\(9\)
\(40 \,\, 3\)
\(60 \,\, 33\)
\(60 \,\, 33\)
\(50 \,\, 124\)
\(50 \,\, 126\)
\(50 \,\, 128\)
\(40 \,\, 4\)
\(50 \,\, 72\)
\(50 \,\, 126\)
Для приведённого примера студент с идентификационным номером \(50\) решил наибольшее количество задач через одну \((3\) задачи). Ответом является пара чисел: \(50 \, 3.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
students = {}
for _ in range(N):
id, problem = map(int, fd.readline().split())
if students.get(id):
students[id].add(problem)
else:
students[id] = {problem}
stud_prob = []
for id in students.keys():
pr = sorted(list(students[id]))
m = 1
p = 0
while p < len(pr) - 1:
p1 = p + 1
while p1 < len(pr) and pr[p1] - pr[p1-1] == 2:
p1 += 1
m = max(m, p1 - p)
p = p1
stud_prob.append((m, -id))
stud_prob.sort(reverse=True)
print(-stud_prob[0][1], stud_prob[0][0])
Ответ: \(10135 \,\, 42\)
Задание 26. Информатика. ЕГЭ. Досрочный экзамен. 08.04.2025
Просмотры: 1303
Изменено: 8 апреля 2025
В магазине для упаковки подарков есть \(N\) кубических коробок. Самой интересной считается упаковка подарка по принципу матрёшки — подарок упаковывается в одну из коробок, та в свою очередь в другую коробку и т.д. Одну коробку можно поместить в другую, если длина её стороны меньше длины стороны другой коробки не менее чем на \(9\) единиц. Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, и максимально возможную длину стороны самой маленькой коробки, где будет находиться подарок. Размер подарка позволяет поместить его в самую маленькую коробку.
Входные данные
В первой строке входного файла находится число \(N\) — количество коробок в магазине (натуральное число, не превышающее \(10~000).\) В следующих \(N\) строках находятся значения длин сторон коробок (все числа натуральные, не превышающие \(10~000),\) каждое — в отдельной строке.
Запишите в ответе два целых числа: сначала наибольшее количество коробок, которое можно использовать для упаковки одного подарка, затем максимально возможную длину стороны самой маленькой коробки в таком наборе.
Типовой пример организации данных во входном файле
\(5\)
\(43\)
\(40\)
\(32\)
\(40\)
\(30\)
Пример входного файла приведён для пяти коробок и случая, когда минимальная допустимая разница между длинами сторон коробок, подходящих для упаковки «матрёшкой», не менее \(3\) единиц. При таких исходных данных условию задачи удовлетворяют наборы коробок с длинами сторон \(30,\) \(40\) и \(43\) или \(32,\) \(40\) и \(43\) соответственно, т.е. количество коробок равно \(3,\) а длина стороны самой маленькой коробки равна \(32.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
base = ''
fd = open(base + '26.txt')
N = int(fd.readline())
boxes = set()
for line in fd:
boxes.add(int(line))
edges = sorted(list(boxes), reverse=True)
q = 1
cur_len = edges[0]
for p in range(1, len(edges)):
if cur_len - edges[p] > 8:
q += 1
cur_len = edges[p]
print(q, cur_len)
Ответ: \(1040 \,\, 57\)
Задание 26. Информатика. ЕГЭ. Апробация. 05.03.2025
Просмотры: 3572
Изменено: 6 марта 2025
При онлайн-покупке билета на концерт известно, какие места в зале уже заняты. Необходимо купить два билета на такие соседние места в одном ряду, чтобы перед ними все кресла с такими же номерами были свободны, а ряд находился как можно дальше от сцены. Если в этом ряду таких пар мест несколько, найдите пару с наименьшими номерами. В ответе запишите два целых числа: искомый номер ряда и наименьший номер места в найденной паре. Нумерация рядов и мест ведётся с \(1.\) Гарантируется, что хотя бы одна такая пара в зале есть.
Входные данные
В первой строже входного файла находятся три числа: \(N\) — количество занятых мест в зале (целое положительное число, не превышающее \(10~000),\) \(M\) — количество рядов (целое положительное число, не превышающее \(100~000)\) и \(K\) — количество мест в каждом ряду (целое положительное число, не превышающее \(100~000).\) В следующих \(N\) строках находятся пары натуральных чисел: номер ряда и номер места занятого кресла соответственно (первое число не превышает значения \(M,\) а второе — \(K).\)
Выходные данные
Два целых положительных числа: наибольший номер ряда и наименьший номер места в найденной паре кресел.
Типовой пример организации данных во входном файле
\(7 \, 7 \, 8\)
\(1 \, 1\)
\(6 \, 6\)
\(5 \, 5\)
\(6 \, 7\)
\(4 \, 4\)
\(2 \, 2\)
\(3 \, 3\)
При таких исходных данных ответом является пара чисел \(5\) и \(6.\) Условию задачи удовлетворяют места \(6\) и \(7\) в ряду \(5:\) перед креслами \(6\) и \(7\) нет занятых мест и это первая из двух возможных пар в этом ряду. В рядах \(6\) и \(7\) искомую пару найти нельзя.
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
base = ''
fd = open(base + '26.txt')
N, M, K = [int(x) for x in fd.readline().split()]
seats = [M] * (K + 1)
for line in fd:
row, seat = [int(x) for x in line.split()]
seats[seat] = min(seats[seat], row)
min_seat = float('inf')
max_row = 0
for s in range(1, K):
row = min(seats[s] - 1, seats[s+1] - 1)
if row > max_row:
max_row = row
min_seat = s
print(max_row, min_seat)
Ответ: \(21028 \,\, 6660\)
Задание 26. Информатика. ЕГЭ. Шастин. 7.6.2025
Просмотры: 329
Изменено: 8 июня 2025
(Д. Бахтиев) Во время погрузки корабля все грузы последовательно подаются к причалу. Каждый груз имеет массу (в килограммах) — целое положительное число.
Для равномерной загрузки и обеспечения безопасности все грузы нужно распределить по трюмам корабля по следующим правилам: в один трюм можно поместить любое количество грузов, но при этом разница между самым лёгким и самым тяжёлым грузом в трюме не должна превышать \(T\) кг, а общая масса грузов в трюме не должна превышать \(M\) кг. Также известно, что грузы помещаются в трюмы в порядке неубывания их масс. Если груз по массе не может быть добавлен ни в один из уже созданных трюмов, для него открывается новый трюм
Входные данные:
В первой строке заданы три целых числа \(N\) — количество грузов \((1 \leqslant N \leqslant 100000),\) \(T\) — максимальная разница между массами грузов одного трюма \((1 \leqslant T \leqslant 1000),\) \(M\) — максимальная общая масса грузов одного трюма \((1 \leqslant M \leqslant 10^9).\) Каждая из следующих \(N\) строк содержит одно целое число — массу груза в килограммах (от \(1\) до \(10^6),\) в произвольном порядке.
Запишите в ответе два числа: сначала минимально возможное общее количество трюмов, использованных для размещения всех грузов, затем при таком размещении определите максимально возможное количество грузов, размещённых в том же трюме, что и самый маленький по массе груз.
Типовой пример организации данных во входном файле
\(8 \,\, 50 \,\, 300\)
\(30\)
\(20\)
\(70\)
\(10\)
\(250\)
\(200\)
\(150\)
\(80\)
При таких исходных данных в первый трюм можно поместить грузы, с массами: \(30,\) \(20\) и \(10,\) во второй \(70\) и \(80,\) в третий, четвёртый и пятый будут складированы по одному грузу — \(150,\) \(200\) и \(250\) (из-за общего ограничения по массе в одном трюме). Ответ: \(5 \,\, 3.\)
Решение:
Python
fp = open('26_22606.txt')
N, T, M = map(int, fp.readline().split())
cargo = [int(x) for x in fp]
cargo.sort()
holds = [[cargo.pop(0)]]
while cargo:
g = cargo.pop(0)
f = False
for i in range(len(holds)):
if sum(holds[i]) + g < M and g - holds[i][0] <= T:
holds[i].append(g)
f = True
break
if not f:
holds.append([g])
print(len(holds), len(holds[0]))
Ответ: \(572 \,\, 29\)
Задание 26. Информатика. ЕГЭ. Шастин. 5.6.2025
Просмотры: 361
Изменено: 7 июня 2025
(Л. Шастин) При онлайн-покупке билета на концерт известно, какие места в зале уже заняты. Необходимо купить три билета на такие соседние места в одном ряду, чтобы перед каждым из них хотя бы \(V\) кресел (необязательно подряд идущих) с такими же номерами были заняты, а ряд находился как можно ближе к сцене. Если в этом ряду таких троек мест несколько, найдите тройку с наибольшими номерами. В ответе запишите два целых числа: искомый номер ряда и сумму номеров мест в найденной тройке. Нумерация рядов и мест ведётся с \(1.\) Гарантируется, что хотя бы одна такая тройка в зале есть.
Входные данные
В первой строке входного файла находятся четыре числа: \(N\) — количество занятых мест в зале (целое положительное число, не превышающее \(1~000~000),\) \(M\) — количество рядов (целое положительное число, не превышающее \(1~000),\) \(K\) — количество, мест в каждом ряду (целое положительное число, не превышающее \(1~000)\) и \(V\) — минимальное количество занятых кресел перед выбранными местами с теми же номерами (целое положительное число, не превышающее \(1~000).\) В следующих \(N\) строках находятся пары натуральных чисел: номер ряда и номер места занятого кресла соответственно (первое число не превышает значения \(M,\) а второе — \(K).\)
Выходные данные
Два целых положительных числа: наименьший номер ряда и сумму номеров мест в найденной тройке кресел.
Типовой пример организации данных во входном файле
\(6 \, 4 \, 5 \, 1\)
\(2 \, 3\)
\(1 \, 2\)
\(2 \, 2\)
\(3 \, 1\)
\(2 \, 4\)
\(1 \, 5\)
При таких исходных данных ответом является пара чисел \(3\) и \(12\) (места №3, 4 и 5 в ряду №3).
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемого файла.
Решение:
Python
fd = open('26_22577.txt')
M, N, K, V = map(int, fd.readline().split())
seats = [[0 for i in range(K+1)] for j in range(M + 1)]
for line in fd:
r, s = map(int, line.split())
seats[r][s] = 1
f = True
for row in range(V+1, M+1):
if not f:
break
for s in range(K, 2, -1):
if sum(seats[x][s] for x in range(row)) >= V \
and sum(seats[x][s-1] for x in range(row)) >= V \
and sum(seats[x][s-2] for x in range(row)) >= V:
print(row, 3*s - 3)
f = False
break
Ответ: \(636 \,\, 396\)
Задание 26. Информатика. ЕГЭ. Шастин. 3.6.2025
Просмотры: 559
Изменено: 5 июня 2025
(Л. Шастин) Исследователь отправляется в экспедицию через пустыню, чтобы добраться до древнего храма, расположенного на расстоянии \(R\) километров от стартовой точки (которая определена первым километром). В начале пути его верблюд полностью отдохнувший и может пройти \(V\) километров без остановки. По пути расположены оазисы, в которых можно напоить верблюда и позволить ему восстановить силы, чтобы снова пройти до \(V\) километров. Известны координаты \(N\) оазисов — километры от начала пути, на которых они расположены, а также запас воды в каждом из них (в у. е). Каждая \(1\) у.е. воды эквивалентна \(1\) километру пути, который может преодолеть верблюд. Определите, какое минимальное количество оазисов придется посетить, чтобы достигнуть древнего храма, а также минимально возможный номер километра расположения оазиса, который получится посетить последний раз.
Входные данные
В первой строке входного файла находится три натуральных числа: \(N\) \((N < 100~000)\) — количество оазисов на пути, \(R\) \((R < 10~000~000)\) — расстояние от стартовой точки до храма, и \(V\) \((V < R)\) — максимальное количество километров, которые может пройти полностью отдохнувший верблюд. В следующих \(N\) строках находятся по два числа: расстояние (в километрах) между стартовой точкой и очередным оазисом, и запас воды в каждом из них (в у. е.). Каждое из чисел целое, не превосходящее \(10~000~000.\)
Запишите в ответе два числа: минимальное количество оазисов, которые придется посетить, чтобы достигнуть древнего храма, и, при этих условиях, минимальный возможный номер километра (с оазисом), на котором будет выполнена последняя остановка.
Типовой пример организации данных во входном файле
\(7 \,\, 50 \,\, 20\)
\(10 \,\, 20\)
\(19 \,\, 9\)
\(15 \,\, 11\)
\(40 \,\, 20\)
\(31 \,\, 5\)
\(41 \,\, 10\)
\(30 \,\, 10\)
При таких исходных данных можно сделать \(3\) остановки: \(\{15, \, 30, \, 41\}\) или \(\{15, \, 30, \, 40 \}\) или \(\{10, \, 30, \, 40 \}.\) Ответ: \(3 \,\, 40.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26.txt')
N, R, V = map(int, fd.readline().split())
oasis = [tuple(map(int, line.split())) for line in fd]
oasis.sort()
p = 0
curr = 0
water = V
visited = 0
last_km = 0
while curr + water < R:
tmp = []
while p < N and oasis[p][0] - curr <= water:
next_pos = min(water - (oasis[p][0] - curr) + oasis[p][1], V)
tmp.append((next_pos, p))
if oasis[p][0] + next_pos >= R and not last_km:
last_km = oasis[p][0]
p += 1
best = max(tmp)
p = best[1]
water = min(water - (oasis[p][0] - curr) + oasis[p][1], V)
curr = oasis[p][0]
visited += 1
print(visited, last_km)
Ответ: \(330 \,\, 7939364\)
Задание 26. Информатика. ЕГЭ. Шастин. 1.6.2025
Просмотры: 527
Изменено: 2 июня 2025
(Д. Бахтиев) Во время матча в расширенной версии игры «Морской бой» велась автоматическая фиксация попаданий по игровому полю. Каждое попадание фиксируется по координатам клетки игрового поля (целые положительные числа \(x\) и \(y)\) и времени попадания — целому числу \(t\) (в секундах от начала матча).
Игровое поле — прямоугольное. Координаты попаданий \((x, \, y)\) указываются в формате: \(x\) — номер строки (считая сверху вниз, от \(1\) с шагом \(1),\) \(y\) — номер столбца (слева направо, от \(1\) с шагом \(1).\) Некоторые клетки могли быть поражены несколько раз.
Требуется определить такую клетку, в которую было произведено не менее двух попаданий, и среди них — найти ту, в которой минимальный интервал времени между любыми двумя её попаданиями — наименьший. В ответе нужно вывести сумму координаты этой клетки \((x + y),\) а также этот минимальный интервал в секундах. Если таких клеток несколько, выберите среди них клетку с наименьшим номером строки, а если таких тоже несколько — с наименьшим номером столбца.
Входные данные:
В первой строке записано одно целое число \(N\) — количество попаданий \((1 \leqslant N \leqslant 1000000).\) В следующих \(N\) строках заданы тройки целых чисел \(x \, y \, t\) — координаты клетки и время попадания \((1 \leqslant x \leqslant 10000, \,\,1 \leqslant y \leqslant 10000, \, 0 \leqslant t \leqslant 10^6).\)
Выходные данные.
Два целых числа: сумму номеров строки столбца подходящей клетки, затем минимальный интервал времени между двумя попаданиями в эту клетку.
Типовой пример организации входных данных:
\(7\)
\(2 \,\, 3 \,\, 10\)
\(1 \,\, 1 \,\, 3\)
\(2 \,\, 3 \,\, 15\)
\(3 \,\, 2 \,\, 20\)
\(1 \,\, 1 \,\, 10\)
\(2 \,\, 3 \,\, 17\)
\(1 \,\,1 \,\, 6\)
Для приведённого примера более одного попаданий было в клетки с координатами \((2, \, 3)\) и \((1, \, 1).\) Минимальный интервал между попаданиями, равный двум секундам, был у клетки с координатами \((2, \, 3).\) Ответ: \(5 \,\, 2.\)
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
cells = {}
for line in fd:
x, y, t = map(int, line.split())
if cells.get((x, y)):
cells[(x, y)].append(t)
else:
cells[(x, y)] = [t]
arr = []
for c in cells:
if len(cells[c]) > 1:
tmp = sorted(cells[c])
m = min(y - x for x, y in zip(tmp, tmp[1:]))
arr.append((m, c[0], c[1]))
arr.sort()
print(arr[0][1] + arr[0][2], arr[0][0])
Ответ: \(4552 \,\, 53\)
Задание 26. Информатика. ЕГЭ. Статград. Профиль. 12.05.2025-1
Просмотры: 521
Изменено: 18 мая 2025
В мастерской есть станок A и станок B. Для обработки детали требуется последовательно выполнить две операции: на станках A и В. Для каждой детали известны порядок операций и длительность каждой операции. В недельной технологической карте указаны время поступления детали в мастерскую на обработку в минутах от 00 ч. 00 мин. понедельника, длительность обработки на станке А и длительность обработки на станке B, а также какая операция выполняется первой. Гарантируется, что никакие две детали не поступают в мастерскую одновременно. Обработка новой детали на каждом станке может начинаться сразу по окончании обработки предыдущей детали. На перенос детали от станка A к станку B или, наоборот, от станка B к станку A дополнительное время не требуется (перенос уже учтён в длительности операций). Если станок свободен, то сразу начинается обработка очередной детали, если станок занят, то деталь попадает в соответствующую очередь. Если две детали поступают на станок одновременно, то первой в очередь попадает деталь, которая поступила в мастерскую раньше.
Входные данные
Первая строка входного файла содержит целое число \(N\) – общее количество деталей. Каждая из следующих \(N\) строк содержит три числа и букву A или B. Первое число – время поступления в мастерскую, второе число – длительность обработки на станке А, третье число – длительность обработки на станке B, буква показывает какая операция должна выполняться первой.
В ответе запишите два целых числа: сначала количество деталей, которые не сразу попали на обработку на станке A и были поставлены в очередь, затем время окончания обработки всех деталей на станке A (в минутах от 00ч. 00 мин. понедельника).
Пример входного файла
\(4\)
\(4 \, 3 \, 5 \, A\)
\(7 \, 4 \, 4 \, B\)
\(17 \, 2 \, 3 \, B\)
\(18 \, 6 \, 7 \, A\)
По этим данным детали будут обрабатываться в следующем порядке.
Первая деталь, станок А. 4 – 7 мин.
Первая деталь, станок B. 7 – 12 мин.
Вторая деталь, станок B. 12 – 16 мин. После ожидания.
Вторая деталь, станок A. 16 – 20 мин.
Третья деталь, станок B. 17 – 20 мин.
Четвёртая деталь, станок А. 20 – 26 мин. После ожидания.
Третья деталь, станок A. 26 – 28 мин. После ожидания.
Четвёртая деталь, станок B. 26 – 33 мин.
Станок А ожидали две детали. Обработка на станке А завершена в 28 мин.
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
details = []
for line in fd:
sp = line.split()
tmp = [int(x) for x in sp[:3]]
details.append(tmp + [sp[3], 0] + [tmp[0]]) #доп 4-е поле, 0 - сколько раз обрабатывалась деталь
# 5-е поле - время следующей обработки детали
details.sort()
fin_A, fin_B = 0, 0
q, set_A, set_B = [], set(), set()
det = details.pop(0)
cur_time = det[0]
if det[3] == 'A':
fin_A = cur_time + det[1]
det[3] = 'B'
det[5] = cur_time + det[1]
else:
fin_B = cur_time + det[2]
det[3] = 'A'
det[5] = cur_time + det[2]
det[4] += 1
q.append(det)
while details or q:
if details:
if (not q) or (q and max(x[5] for x in q) >= details[0][0]):
q.append(details.pop(0))
q.sort(key= lambda x: (x[5], x[0]))
#print(q)
cur_time = q[0][5]
if q[0][3] == 'A' and q[0][5] < fin_A:
q[0][5] = fin_A
cur_time = fin_A
set_A.add(tuple(q[0]))
elif q[0][3] == 'B' and q[0][5] < fin_B:
q[0][5] = fin_B
cur_time = fin_B
set_B.add(tuple(q[0]))
#print(cur_time)
det_process = [x for x in q if x[5] == cur_time]
det_process_A = [x for x in det_process if x[3] == 'A']
det_process_B = [x for x in det_process if x[3] == 'B']
if det_process_A:
det = det_process_A.pop(0)
q.remove(det)
det[4] += 1
det[3] = 'B'
det[5] = cur_time + det[1]
fin_A = det[5]
#print('Деталь', det, 'станок А', 'время', cur_time, det[5])
if det[4] < 2:
q.append(det)
for d in det_process_A:
d[5] = cur_time + det[1]
set_A.add(tuple(d))
if det_process_B:
det = det_process_B.pop(0)
q.remove(det)
det[4] += 1
det[3] = 'A'
det[5] = cur_time + det[2]
fin_B = det[5]
#print('Деталь', det, 'станок B', 'время', cur_time, det[5])
if det[4] < 2:
q.append(det)
for d in det_process_B:
d[5] = cur_time + det[2]
set_B.add(tuple(d))
#print(set_A, set_B)
print(len(set_A), fin_A)
Ответ: \(662 \,\, 10026\)
Задание 26. Информатика. ЕГЭ Статград. База. 12.05.2025
Просмотры: 324
Изменено: 16 мая 2025
При бронировании билетов на теплоход известно, какие каюты на жилой палубе уже заняты. Палуба представима в виде сетки из \(M\) рядов, каждый из которых содержит \(K\) кают. Необходимо забронировать две соседние каюты в таком ряду, чтобы в нём было забронировано не менее \(35\) кают, а в двух соседних рядах (сзади и спереди) было как можно больше свободных кают, причём крайние ряды для брони рассматривать не следует. Если существует несколько вариантов бронирования, удовлетворяющих этим условиям, следует выбрать ряд с наибольшим номером. В ответе запишите два целых числа: искомый номер ряда и суммарное количество забронированных кают в соседних (относительно выбранных мест) рядах. Нумерация рядов и кают ведётся с \(1.\) Гарантируется, что бронь, соответствующая условиям, возможна.
Входные данные
В первой строке входного файла находятся три числа: \(N\) – количество занятых кают на палубе (целое положительное число, не превышающее \(100~000),\) \(M\) – количество рядов (целое положительное число, не превышающее \(10~000)\) и \(K\) – количество кают в каждом ряду (целое положительное число, не превышающее \(1~000~000).\) В следующих \(N\) строках находятся пары натуральных чисел: номер ряда и номер занятой каюты соответственно (первое число не превышает значения \(M,\) а второе – \(K).\)
Выходные данные
Два целых положительных числа: наибольший номер подходящего ряда и суммарное количество забронированных кают в соседних рядах.
Типовой пример организации данных во входном файле
\(7 7 8\)
\(1 \,\, 1\)
\(6 \,\, 6\)
\(5 \,\, 5\)
\(6 \,\, 7\)
\(4 \,\, 4\)
\(2 \,\, 2\)
\(3 \,\, 3\)
При таких исходных данных и отсутствии ограничений на количество забронированных в ряду кают ответом является пара чисел \(6\) и \(1.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемого файла.
Решение:
Python
fd = open('26.txt')
N, M, K = map(int, fd.readline().split())
rows = {}
for line in fd:
m, k = map(int, line.split())
if rows.get(m):
rows[m].append(k)
else:
rows[m] = [k]
m_ans, br = 0, float('inf')
for i in range(2, M):
r = rows.get(i, [])
if len(r) > 32:
r.sort()
if any(y - x > 2 for x, y in zip(r, r[1:])):
t = len(rows.get(i-1, [])) + len(rows.get(i+1, []))
if t <= br:
m_ans = i
br = t
print(m_ans, br)
Ответ: \(1074 \,\, 29\)
Задание 26. Информатика. ЕГЭ. ЕГКР. 21.12.2024
Просмотры: 3326
Изменено: 11 мая 2025
В банке дистанционной проверяющей системы имеется более \(100~000\) заданий. Все задачи пронумерованы начиная с единицы. Эти задания в течение учебного периода решают участники различных курсов. Каждому студенту при регистрации присваивается уникальный идентификатор — натуральное число, не превышающее \(1~000~000.\) Студент может сдать несколько различных правильных решений одной задачи, при этом в зачёт идёт только одно из них.
Преподаватель сделал выгрузку результатов за некоторый период времени и выбрал студента, который решил наибольшее количество задач из банка с идущими подряд номерами, не пропустив ни одной.
Определите идентификационный номер студента, который решил наибольшее количество задач с идущими подряд номерами, и количество решённых им задач. Если несколько студентов решили одинаковое максимальное количество задач, то укажите наименьший идентификационный номер.
Входные данные
В первой строке входного файла находится число \(N\) — количество зачтённых решений (натуральное число, не превышающее \(60~000\)) за некоторый период времени. Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(100~000\): идентификатор студента и номер правильно решённой задачи.
Выходные данные
Два целых неотрицательных числа: наименьший идентификационный номер студента и наибольшее количество успешно решённых задач с подряд идущими номерами.
Решение:
Python
def pd(arr):
ans = 1
p = 0
while p < len(arr):
i = 1
while p + i < len(arr) and arr[p + i] == arr[p] + i:
i += 1
ans = max(ans, i)
p += i
return ans
base = ''
fd = open(base + '26.txt')
N = int(fd.readline())
tasks = {}
for line in fd:
i, n = map(int, line.split())
if tasks.get(i):
tasks[i].append(n)
else:
tasks[i] = [n]
arr = [(pd(sorted(v)), -k) for k, v in tasks.items()]
arr.sort(reverse=True)
print(-arr[0][1], arr[0][0])
Ответ: \(40031 \,\, 148\)
Задание 26. Информатика. ЕГЭ. Демо-2025
Просмотры: 3674
Изменено: 20 августа 2025
Во время сессии студенты сдают \(4\) экзамена, за каждый из которых можно получить от \(2\) до \(5\) баллов. Студенты, получившие хотя бы одну «двойку», считаются не сдавшими сессию. Результаты сессии публикуются в виде рейтингового списка, в котором сначала указаны идентификационные номера студентов (ID), сдавших сессию, в порядке убывания среднего балла за сессию, а в случае равенства средних баллов – в порядке возрастания ID. Затем располагаются ID студентов, не сдавших сессию: сначала – получивших одну «двойку», затем – две «двойки», потом ID студентов с тремя «двойками» и, наконец, ID студентов, получивших по \(2\) балла за каждый из экзаменов. Если студенты имеют одинаковое количество «двоек», то их ID в рейтинге располагаются в порядке возрастания.
Повышенную стипендию получают студенты, занявшие в рейтинговом списке первые \(25 \%\) мест, при условии отсутствия у них «двоек». Гарантируется, что без «двоек» сессию сдали не менее \(25 \%\) студентов.
Найдите ID студента, который занимает последнее место среди студентов с повышенной стипендией, а также ID первого в рейтинговом списке студента, который имеет более двух «двоек».
В ответе запишите два целых положительных числа: сначала ID студента, который занимает последнее место среди студентов с повышенной стипендией, затем ID первого в рейтинговом списке студента, который имеет более двух «двоек».
Входные данные
В первой строке входного файла находится число \(N\), обозначающее количество студентов (целое положительное число, не превышающее \(10~000\)). Каждая из следующих \(N\) строк содержит \(5\) чисел через пробел: ID студента (целое положительное число, не превышающее \(100~000\)) и четыре оценки, полученные им за сессию. Гарантируется, что общее число студентов \(N\) кратно \(4\) и хотя бы один студент имеет более двух «двоек». Во входном файле все ID различны.
Выходные данные
Два натуральных числа: искомые ID студентов в порядке, указанном в условии задачи. Типовой пример организации данных во входном файле
\(8\)
\(4 \, 4 \, 4 \, 4 \, 4\)
\(7 \, 5 \, 5 \, 5 \, 2\)
\(10 \, 3 \, 4 \, 4 \, 5\)
\(1 \, 4 \, 4 \, 4 \, 3\)
\(6 \, 3 \, 5 \, 5 \, 3\)
\(2 \, 2 \, 2 \, 2 \, 2\)
\(13 \, 2 \, 2 \, 2 \, 3\)
\(3 \, 3 \, 3 \, 3 \, 3\)
Решение:
Python
base = ''
fd = open(base + 'demo_2025_26.txt')
N = int(fd.readline())
stud = []
for line in fd:
arr = [int(x) for x in line.split()]
st = {'ID': arr[0],
'sr_ball': -sum(arr[1:]) if arr.count(2) == 0 else 0,
'neud': arr.count(2)}
stud.append(st)
stud.sort(key = lambda x: (x['neud'], x['sr_ball'], x['ID']))
for i in range(N):
if stud[i]['neud']< 3:
continue
id_neud = stud[i]['ID']
break
print(stud[N // 4 - 1]['ID'], id_neud)
Ответ: \(52326 \,\, 635\)
Задание 26. Информатика. ЕГЭ. Шастин. 7.05.2025
Просмотры: 498
Изменено: 11 мая 2025
(Л. Шастин) Частная клиника работает круглосуточно, в режиме 24/7. В течение суток в клинике проводятся медицинские приёмы, каждый из которых характеризуется временем начала и окончания (в миллисекундах, прошедших с начала суток). Считается, что в миллисекунды начала и конца приема он ещё идет. Необходимо проанализировать загруженность врачей за сутки и определить периоды простоя, то есть такие отрезки времени, когда ни один приём не проходил.
Входной файл содержит время начала и конца каждого приема (в мс) в течение суток. Определите, сколько периодов простоя было в течение суток, и укажите их суммарную длительность (в мс).
Входные данные
В первой строке входного файла находится натуральное число \(N\) \((N < 100~000)\) — количество приемов, проведенных за сутки. Следующие \(N\) строк содержат пары чисел, обозначающих соответственно время начала и время конца приёма (все числа натуральные, меньшие \(86400000).\)
Запишите в ответе два натуральных числа: сначала найденное количество периодов простоя, а затем их суммарную длительность (в мс).
Типовой пример организации данных во входном файле
\(6\)
\(10 \,\, 50\)
\(100 \,\, 150\)
\(110 \,\, 155\)
\(120 \,\, 160\)
\(130 \,\, 170\)
\(151 \,\, 170\)
При таких исходных данных и длительности работы клиники в \(200\) мс было три периода простоя: в отрезки времени с \(0\) по \(9\) мс, с \(51\) по \(99\) мс и с \(171\) по \(199\) мс. Их суммарная длительность равна \((10 - 0) + (100 - 51) + (200 - 171) = 88.\) Ответ для примера: \(3 \,\, 88.\) Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
intervals = []
for _ in range(N):
beg, end = map(int, fd.readline().split())
intervals.append([beg, end])
intervals.sort()
q, prost = 0, 0
beg, end = intervals[0][0], intervals[0][1]
if beg > 0:
q += 1
prost += beg
for p in range(1, len(intervals)):
if intervals[p][0] - end > 1:
q += 1
prost += intervals[p][0] - end - 1
beg, end = intervals[p][0], max(end, intervals[p][1])
if end < 86_400_000 - 1:
q += 1
prost += 86_400_000 - 1 - end
print(q, prost)
Ответ: \(36 \,\, 35834\)
Задание 26. Информатика. ЕГЭ. Статград. 01.04.2025-1
Просмотры: 1729
Изменено: 1 апреля 2025
Система наблюдения ежеминутно фиксирует вход и выход сотрудников из офиса (в минутах, прошедших от начала суток). Считается, что в моменты фиксации входа и выхода сотрудник находится в офисе. Нулевая минута соответствует моменту начала рабочего дня в офисе, который длится \(24\) ч в сутки без перерыва. Менеджер компании анализирует данные системы наблюдения за прошедшие сутки, и выявляет непересекающиеся отрезки времени наибольшей длины, в течение которых число сотрудников, находящихся в офисе, не изменялось. Входной файл содержит время входа и выхода каждого сотрудника компании. Определите минуту, когда в предпоследний раз за сутки число сотрудников поменялось, и укажите наибольшую длину отрезка времени, когда количество сотрудников оставалось неизменным.
Входные данные
В первой строке входного файла находится натуральное число \(N\) \((N \leqslant 100~000)\) — количество сотрудников компании. Следующие \(N\) строк содержат пары чисел, обозначающих соответственно время входа и время выхода сотрудника (все числа натуральные, не превышающие \(1440\)).
Запишите в ответе два натуральных числа: сначала минуту, когда в предпоследний раз за сутки число сотрудников поменялось, а затем наибольшую длительность промежутка времени, при котором количество сотрудников оставалось неизменным.
Типовой пример организации данных во входном файле
\(5\)
\(10 \, 1070\)
\(230 \, 1070\)
\(240 \, 1070\)
\(1070 \, 1400\)
\(1071 \, 1400\)
При таких исходных данных в течение суток было \(7\) промежутков времени, когда число сотрудников не менялось: \((0, \, 10),\) \((10, \, 230),\) \((230, \, 240),\) \((240, \, 1070),\) \((1070, \, 1071),\) \((1071, \, 1400),\) \((1400, \, 1440).\) Наибольшей длиной из этих отрезков является число \(830.\) В \(1071\) минуту в предпоследний раз за сутки изменилось число сотрудников.
Решение:
Python
base = ''
fd = open(base + '26.txt')
N = int(fd.readline())
tt = {i: 0 for i in range(1441)}
for line in fd:
i, o = map(int, line.split())
for x in range(i, o+1):
tt[x] += 1
chg = []
max_time = 0
tmp = 1
for x in range(1440):
if tt[x] == tt[x+1]:
tmp += 1
else:
max_time = max(max_time, tmp)
tmp = 1
chg.append(x+1)
print(chg[-2], max_time)
Ответ: \(1432 \,\, 15\)
Задание 26. Информатика. ЕГЭ. Статград. 04.03.2025
Просмотры: 657
Изменено: 7 марта 2025
На складе предприятия имеются заготовки двух видов: \(A\) и \(B,\) у каждой заготовки есть размер, измеряемый в миллиметрах. Для производства одного изделия необходима одна заготовка типа \(A\) и одна заготовка типа \(B,\) при этом разность размеров этих заготовок должна быть не более \(20\) мм. Прибыль от продажи полученного изделия численно равна сумме размеров использованных заготовок.
Руководство предприятия хочет использовать имеющиеся заготовки так, чтобы получить максимальную прибыль. Определите, сколько изделий для этого нужно произвести и какая прибыль будет получена.
Входные данные
Первая строка входного файла содержит целое число \(N\) — общее количество изделий на складе. Каждая из следующих \(N\) строк содержит букву \(A\) или \(B,\) определяющую тип заготовки, и целое число — размер этой заготовки. В ответе запишите два целых числа: сначала количество произведённых изделий, затем полученную прибыль.
Решение:
Python
base = ''
det_A = []
det_B = []
fd = open(base + '26.txt')
N = int(fd.readline().strip())
for _ in range(N):
tmp = fd.readline().split()
if tmp[0] == 'A':
det_A.append(int(tmp[1]))
else:
det_B.append(int(tmp[1]))
det_A.sort(reverse=True)
det_B.sort(reverse=True)
pa, pb = 0, 0
profit, goods = 0, 0
while pa < len(det_A) and pb < len(det_B):
if abs(det_A[pa] - det_B[pb]) > 20:
if det_A[pa] > det_B[pb]:
pa += 1
else:
pb += 1
else:
profit += det_A[pa] + det_B[pb]
goods += 1
pa += 1
pb += 1
print(goods, profit)
Ответ: \(5669 \,\, 29011899\)
Задание 26. Информатика. ЕГЭ. Статград. 28.01.2025-1
Просмотры: 1732
Изменено: 2 февраля 2025
При проведении эксперимента заряженные частицы попадают на чувствительный экран, представляющий из себя матрицу размером \(100~000\) на \(100~000\) точек. При попадании каждой частицы на экран в протоколе фиксируются координаты попадания: номер ряда (целое число от \(1\) до \(100~000\)) и номер позиции в ряду (целое число от \(1\) до \(100~000\)). Точка экрана, в которую попала хотя бы одна частица, считается светлой, точка, в которую ни одна частица не попала, – тёмной.
При анализе результатов эксперимента рассматривают изолированные точки. Точка называется изолированной, если эта точка светлая (независимо от того, сколько частиц в неё попало), а другие светлые точки в том же ряду либо отсутствуют, либо находятся на расстоянии более \(500.\) Вам необходимо по заданному протоколу определить наибольшее количество изолированных точек, расположенных в одном ряду, и номер ряда, в котором это количество встречается. Если таких рядов несколько, укажите максимально возможный номер.
Входные данные
Первая строка входного файла содержит целое число \(N\) – общее количество частиц, попавших на экран. Каждая из следующих \(N\) строк содержит \(2\) целых числа: номер ряда и номер позиции в ряду. В ответе запишите два целых числа: сначала максимальное количество изолированных точек в одном ряду, затем – номер ряда, в котором это количество встречается.
Решение:
Python
base = ''
rows = [[] for _ in range(100_001)]
fd = open(base + '26.txt')
N = int(fd.readline())
for line in fd:
row, pos = map(int, line.split())
if pos not in rows[row]:
rows[row].append(pos)
q_max = 0
d_isol = {}
for i in range(1, 100_001):
if rows[i]:
row_work = [-600] + sorted(rows[i]) + [101_000]
q_work = sum(row_work[j] - row_work[j-1] > 500 and \
row_work[j+1] - row_work[j] > 500 \
for j in range(1, len(row_work) - 1))
q_max = max(q_max, q_work)
d_isol[i] = q_work
print(q_max, max(k for k, v in d_isol.items() if v == q_max))
Ответ: \(20 \,\, 58612\)
Задание 26. Информатика. ЕГЭ. Статград. 17.12.2024
Просмотры: 1403
Изменено: 1 февраля 2025
Участники викторины письменно отвечают на \(10\) вопросов различной сложности. За правильный ответ начисляется от \(1\) до \(5\) баллов в зависимости от сложности вопроса. За неверный ответ вычитается от \(1\) до \(5\) баллов. Участник может не отвечать на какой-то вопрос, в таком случае баллы за этот вопрос не начисляются.
По результатам викторины для каждого участника вычисляются три показателя:
сумма – общее количество набранных баллов;
плюсы – сумма баллов без учёта неверных ответов;
ответы – общее количество сданных ответов (верных и неверных).
В таблице результатов участники располагаются по убыванию первого показателя – суммы, при равенстве сумм – по убыванию второго показателя (плюсов), при равенстве сумм и плюсов – по убыванию третьего показателя (ответов). При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров.
Дальнейший отбор проводится среди тех, кто набрал положительную сумму баллов, участники с нулевой и отрицательной суммой исключаются. В следующий тур проходят участники, занявшие места в первой трети полученной таблицы (учитываются только положительные результаты), а также те, у которых все три показателя такие же, как у занявшего последнее место в первой трети таблицы.
Право участия в дополнительном отборочном туре получают \(10\%\) из тех, кто набрал положительную сумму, но не попал сразу в следующий тур, а также те, у которых все три показателя такие же, как у занявшего последнее место среди этих \(10\%.\)
Примечание. Во всех случаях, когда вычисленное количество участников оказывается не целым, учитывается целая часть полученного числа.
Определите ID участника, занимающего в таблице первое место среди тех, кто прошёл в дополнительный отборочный тур, а также общее количество участников дополнительного отборочного тура.
Входные данные
Первая строка входного файла содержит целое число \(N\) (\(N \leqslant 10~000\)) – общее количество участников. Каждая из следующих \(N\) строк соответствует одному участнику и содержит \(11\) целых чисел, разделённых пробелами: сначала ID участника, затем – баллы, полученные им за каждый из \(10\) вопросов. Гарантируется, что ID участников не повторяются. В ответе запишите два целых числа: сначала требуемый ID, затем требуемое количество.
Решение:
Python
base = ''
fd = open(base + '26.txt')
N = int(fd.readline())
p = []
for line in fd:
a = [int(x) for x in line.split()]
if sum(a[1:]) > 0:
p.append([sum(a[1:]), sum(z > 0 for z in a[1:]),
sum(z != 0 for z in a[1:]), -a[0]])
p.sort(reverse=True)
N = len(p) # кол-во участников с положительной суммой
k = N // 3 # последний участник в первой трети таблицы
res = p[k][:3]
while res == p[k][:3]: # двигаем k на первого участника, не прошедшего сразу
k += 1
ID = -p[k][3]
rem = N - k
dop = int(0.1 * rem) # 10% от оставшихся
res = p[k - 1 + dop][:3]
while res == p[k - 1 + dop][:3]:
dop += 1
print(ID, dop - 1)
Ответ: \(35669 \,\, 478\)
Задание 26. Информатика. ЕГЭ. Статград. 24.10.2024-2
Просмотры: 1249
Изменено: 2 февраля 2025
Участники викторины письменно отвечают на \(10\) вопросов различной сложности. За правильный ответ начисляется от \(1\) до \(5\) баллов в зависимости от сложности вопроса. За неверный ответ вычитается от \(1\) до \(5\) баллов. Участник может не отвечать на какой-то вопрос, в таком случае баллы за этот вопрос не начисляются.
По результатам викторины для каждого участника вычисляются три показателя:
сумма – общее количество набранных баллов;
плюсы – сумма баллов без учёта неверных ответов;
ответы – общее количество сданных ответов (верных и неверных).
В таблице результатов участники располагаются по убыванию первого показателя – суммы, при равенстве сумм – по убыванию второго показателя (плюсов), при равенстве сумм и плюсов – по убыванию третьего показателя (ответов). При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров.
В следующий тур проходят участники, занявшие места в первой четверти итоговой таблицы, а также те, у которых все три показателя такие же, как у занявшего последнее место в первой четверти таблицы.
Определите ID участника, занимающего в таблице первое место среди тех, кто не прошёл в следующий тур, а также количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице 1700 место (включая самого этого участника).
Входные данные
Первая строка входного файла содержит целое число \(N\) (\(N \leqslant 10 000\)) – общее количество участников. Каждая из следующих \(N\) строк соответствует одному участнику и содержит \(11\) целых чисел, разделённых пробелами: сначала ID участника, затем – баллы, полученные им за каждый из \(10\) вопросов. Гарантируется, что ID участников не повторяются.
В ответе запишите два целых числа: сначала требуемый ID, затем требуемое количество.
Решение:
Python
base = ''
part = []
fd = open(base + '26.txt')
N = int(fd.readline())
for line in fd:
tmp = [int(x) for x in line.split()]
p = {'ID': -tmp[0],
'sum': sum(tmp[1:]),
'plus': sum(x for x in tmp[1:] if x > 0),
'ans': sum(x != 0 for x in tmp[1:])}
part.append(p)
part.sort(key=lambda x: (x['sum'], x['plus'], x['ans'], x['ID']), reverse=True)
N4 = N//4 - 1
curr = N4 + 1
while part[curr]['sum'] == part[N4]['sum'] \
and part[curr]['plus'] == part[N4]['plus'] \
and part[curr]['ans'] == part[N4]['ans']:
curr += 1
q = 1
t = 1700
while part[t]['sum'] == part[1699]['sum'] \
and part[t]['plus'] == part[1699]['plus'] \
and part[t]['ans'] == part[1699]['ans']:
q += 1
t += 1
print(-part[curr]['ID'], q)
Ответ: \(1525 \,\, 4\)
Задание 26. Информатика. ЕГЭ. Статград. 24.10.2024-1
Просмотры: 1412
Изменено: 1 февраля 2025
Участники викторины письменно отвечают на \(10\) вопросов различной сложности. За правильный ответ начисляется от \(1\) до \(5\) баллов в зависимости от сложности вопроса. За неверный ответ вычитается от \(1\) до \(5\) баллов. Участник может не отвечать на какой-то вопрос, в таком случае баллы за этот вопрос не начисляются.
По результатам викторины для каждого участника вычисляются три показателя:
сумма – общее количество набранных баллов;
плюсы – сумма баллов без учёта неверных ответов;
ответы – общее количество сданных ответов (верных и неверных).
В таблице результатов участники располагаются по убыванию первого показателя – суммы, при равенстве сумм – по убыванию второго показателя (плюсов), при равенстве сумм и плюсов – по убыванию третьего показателя (ответов). При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров.
В следующий тур проходят участники, занявшие места в первой трети итоговой таблицы, а также те, у которых все три показателя такие же, как у занявшего последнее место в первой трети таблицы.
Определите ID участника, занимающего в таблице первое место среди тех, кто не прошёл в следующий тур, а также количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице 1500 место (включая самого этого участника).
Входные данные
Первая строка входного файла содержит целое число \(N\) (\(N \leqslant 10 000\)) – общее количество участников. Каждая из следующих \(N\) строк соответствует одному участнику и содержит \(11\) целых чисел, разделённых пробелами: сначала ID участника, затем – баллы, полученные им за каждый из \(10\) вопросов. Гарантируется, что ID участников не повторяются.
В ответе запишите два целых числа: сначала требуемый ID, затем требуемое количество.
Решение:
Python
base = ''
part = []
fd = open(base + '26.txt')
N = int(fd.readline())
for line in fd:
tmp = [int(x) for x in line.split()]
p = {'ID': -tmp[0],
'sum': sum(tmp[1:]),
'plus': sum(x for x in tmp[1:] if x > 0),
'ans': sum(x != 0 for x in tmp[1:])}
part.append(p)
part.sort(key=lambda x: (x['sum'], x['plus'], x['ans'], x['ID']), reverse=True)
N3 = N//3 - 1
curr = N3 + 1
while part[curr]['sum'] == part[N3]['sum'] \
and part[curr]['plus'] == part[N3]['plus'] \
and part[curr]['ans'] == part[N3]['ans']:
curr += 1
q = 1
t = 1500
while part[t]['sum'] == part[1499]['sum'] \
and part[t]['plus'] == part[1499]['plus'] \
and part[t]['ans'] == part[1499]['ans']:
q += 1
t += 1
print(-part[curr]['ID'], q)
Ответ: \(4229 \,\, 5\)
Задание 26. Информатика. ЕГЭ. Шастин. 9.2.2025
Просмотры: 684
Изменено: 12 февраля 2025
(Д. Бахтиев) В магазине «Бахтилэнд» на Светлую среду одновременно действуют две акции. Каждый товар характеризуется своей стоимостью и принадлежностью к категории, которая задаётся натуральным числом. Для применения акций товары разделяются по категориям следующим образом:
Если номер категории товара чётный, то для товаров этой категории применяется первая акция:
На \(70\%\) самых дешёвых товаров в данной категории устанавливается скидка \(30\%,\) на оставшиеся товары — скидка \(20%;\)
Если номер категории товара нечётный, то для товаров этой категории применяется вторая акция:
На \(25\%\) самых дорогих товаров в данной категории устанавливается скидка \(15\%,\) на оставшиеся товары — скидки нет.
Магазин «Бахтилэнд» очень лоялен к своим посетителям, поэтому если после применения скидки стоимость получилось нецелой, то она округляется до ближайшего целого числа в меньшую сторону. Но если же количество товаров, на которые должна начислиться скидка, оказалось нецелым, то тут лояльность заканчивается и это количество округляется в меньшую сторону.
При условии, что все товары будут проданы, определите общую выручку магазина, а также абсолютное значение разности между суммой недополученной выручки (то есть суммой скидок, предоставленных покупателям) по первой и второй акциям по сравнению с ситуацией, когда все товары продавались бы по их первоначальной цене.
Входные данные.
Первая строка входного файла содержит натуральное число \(N\) — количество товаров (\(500 \leqslant N \leqslant 10~000\)). Далее следует \(N\) строк, каждая из которых содержит два натуральных числа:
первое число — стоимость товара (натуральное число, не превышающее \(10~000\)),
второе число — номер категории товара (натуральное число, не превышающее \(100\)).
Типовой пример организации данных во входном файле
\(7\)
\(80 \, 2\)
\(45 \, 2\)
\(50 \, 1\)
\(40 \, 8\)
\(34 \, 33\)
\(48 \, 7\)
\(100 \, 13\)
При таких исходных данных, при продажи всех товаров по первой акции магазин получит \(123\) рубля, а по второй — \(217\) рублей. Общая выручка — \(340\) рублей. При этом по первой акции недополученной выручкой будет \(42\) рубля \((165 - 123),\) а по второй \(15\) рублей \((232 - 217).\) Разность между недополученной выручкой по первой и второй акциям составила \(|42 - 15| = 27\) рублей. Ответ: \(340 \, 27.\)
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
base = ''
odd = []
even = []
fd = open(base + '26.txt')
N = int(fd.readline().strip())
for line in fd:
price, cat = map(int, line.split())
odd.append(price) if cat % 2 else even.append(price)
odd.sort(reverse=True)
even.sort()
sum_odd = sum(odd)
sum_even = sum(even)
bound_even = int(len(even) * 0.7)
for i in range(len(even)):
even[i] = int(even[i] * 0.7) if i < bound_even else int(even[i] * 0.8)
for i in range(int(len(odd) * 0.25)):
odd[i] = int(odd[i] * 0.85)
so = sum(odd)
se = sum(even)
print(so + se, abs((sum_odd - so) - (sum_even - se)))
Ответ: \(4151885 \,\, 465011\)
Задание 26. Информатика. ЕГЭ. Шастин. 19.01.2025
Просмотры: 666
Изменено: 1 февраля 2025
(Л. Шастин, Д. Бахтиев) В волшебном мире гладиаторов начался крупнейший турнир силы и стратегии. Участие принимают \(n\) гладиаторов, каждый из которых обладает определённым уровнем начальной силы. Каждый гладиатор хочет проявить себя на арене, но при этом стремится укрепить своего союзника и, конечно же, устранить соперников. Каждый гладиатор должен выбрать четыре цели: первая — другой гладиатор, которого он считает своим союзником: его гладиатор будет усилять с помощью волшебного дубликата силы. Вторая, третья и четвёртая цели — враги, с которыми гладиатор хочет сразиться поочерёдно в указанном им порядке. Перед началом турнира гладиаторы тянули карточки с уникальными числами от \(1\) до \(n.\) Эти числа и определяют порядок, в котором гладиаторы будут делать свои ходы.
Порядок хода очередного гладиатора следующий: сначала осуществляется помощь союзнику, в случае, если союзник ещё жив: уровень силы союзника увеличивается на уровень силы гладиатора, делающего ход. Затем идёт фаза сражений: гладиатор бросает вызов своим трём соперникам из списка, по одному за раз. Важно отметить, что если соперник уже мёртв, сражение пропускается. В бою побеждает тот, у кого уровень силы больше: Победитель теряет треть своей силы (оставшаяся сила округляется вверх до ближайшего целого в случае дробного числа), а проигравший погибает. Если же силы сражающихся гладиаторов равны, гладиаторы пронзают друг друга лучами добра и погибают вместе, держась за руки. Погибшие гладиаторы свой ход осуществлять уже не будут. К концу турнира нужно определить: сколько гладиаторов выбыли с арены и какой наибольший уровень силы остался у выживших гладиаторов.
Входные данные
В первой строке подаётся натуральное число \(n\) — количество гладиаторов (не более \(10~000\)). Далее в \(n\) строках записаны шесть чисел: Первое — уникальный номер гладиатора в соответствии с вытянутой карточкой, второе — начальный уровень силы гладиатора, третье — номер гладиатора, который был выбран в качестве союзника, остальные три числа — номера противников, с которыми желает сразиться гладиатор.
Выходные данные
Выведите два числа: общее количество павших гладиаторов, а затем конечный уровень силы, которую имеет сильнейший из оставшихся в живых гладиаторов (или \(0,\) если все выбыли).
Пример входных данных:
\(5\)
\(3 \, 50 \, 2 \, 1 \, 4 \, 5\)
\(5 \, 40 \, 1 \, 2 \, 3 \, 4\)
\(1 \, 37 \, 3 \, 2 \, 4 \, 5\)
\(4 \, 25 \, 5 \, 3 \, 1 \, 2\)
\(2 \, 50 \, 1 \, 5 \, 4 \, 3\)
При таких исходных данных выживет только гладиатор под номером \(3\) и у него останется \(39\) силы на конец турнира.
Ответ: \(4 \,\, 39\)
Решение:
Python
from math import ceil
base = ''
fd = open(base + '26.txt')
N = int(fd.readline())
glad = {}
for line in fd:
m = list(map(int, line.split()))
glad[m[0]] = m[1:]
for i in range(1, N+1):
if glad[i][0]:
glad[glad[i][1]][0] += glad[i][0] if glad[glad[i][1]][0] else 0
for g in glad[i][2:]:
if glad[g][0]:
if glad[g][0] < glad[i][0]:
glad[g][0] = 0
glad[i][0] = ceil(2 * glad[i][0] / 3)
elif glad[g][0] > glad[i][0]:
glad[i][0] = 0
glad[g][0] = ceil(2 * glad[g][0] / 3)
break
else:
glad[i][0] = glad[g][0] = 0
break
q, mx = 0, 0
for i in range(1, N + 1):
if glad[i][0]:
mx = max(mx, glad[i][0])
else:
q += 1
print(q, mx)
Ответ: \(4228 \,\, 5962\)
Задание 26. Информатика. ЕГЭ. Шастин. 18.12.2024
Просмотры: 757
Изменено: 1 февраля 2025
(Д. Бахтиев) Николай устроился работать гардеробщиком в крупнейший кинотеатр города. Всего в гардеробе доступно \(M\) мест. При покупке билетов на какой-либо сеанс, они резервируются на уникальный \(ID\) клиента, причём на один \(ID\) может быть зарегистрировано сразу несколько билетов. Каждый посетитель кинотеатра обязан сдать одежду в гардероб, при этом взаимодействовать с Николаем может только клиент, \(ID\) которого использован для покупки билетов. Если посетитель подходит к гардеробу впервые, он сдаёт одежду за себя и всю свою группу и получает столько номерков, за сколько человек одежда была сдана. При повторном визите посетитель забирает свою одежду и одежду своей группы, и номерки становятся свободными. Считается, что одежда развешивается и выдаётся моментально, то есть, если клиент подошёл в минуту \(t\) для получения одежды, то в минуту \(t\) этой одежды в гардеробе уже нет. Если клиент сдал одежду в минуту \(t,\) то всю минуту \(t\) одежда уже висит в гардеробе. Если несколько посетителей подошли в одно время, то они обслуживаются в порядке возрастания их \(ID.\) Если свободных номерков нет или их меньше, чем количество человек, которые хотят сдать одежду, то им отказывается в обслуживании, на что каждый клиент группы один раз злобно топает ножкой и моментально покидает кинотеатр, второй раз при этом они подходить не будут.
Определите и запишите в ответе сначала сколько клиентов за сутки недовольно топнут ножкой, а затем суммарную продолжительность времени, в течение которого в гардеробе были заняты все места.
Примечание: считается, что в момент открытия кинотеатра все места в гардеробе свободны.
Входные данные:
В первой строке входного файла записаны два числа \(N\) и \(K:\) \(N\) — общее количество мест в гардеробе; \(K\) — количество людей, на чьё имя были куплены билеты в кинотеатр. Далее следуют строки с информацией о посетителях кинотеатра за последние сутки. Каждая строка содержит три числа, разделённых пробелами:\(ID\) — уникальный идентификатор клиента; \(t\) — время подхода клиента к гардеробу в минутах от начала суток; \(M\) — количество билетов, оформленных на текущий \(ID.\) Гарантируется, что каждый идентификатор \(ID\) появляется в данных не более двух раз: первый раз — для сдачи одежды, второй раз — для её получения.
Типовой пример организации данных во входном файле
\(5 \, 3\)
\(20 \, 15 \,4\)
\(4 \, 5 \, 2\)
\(1996 \, 28 \, 3\)
\(1996 \, 34 \, 3\)
\(20 \, 40 \, 4\)
\(4 \, 50 \, 2\)
Пример входного файла приведён для гардероба, имеющего \(5\) мест, и трёх клиентов. При таких исходных данных клиент с \(ID = 4\) получит \(2\) номерка, клиент с \(ID = 20\) не сможет разместить вещи в гардеробе, поэтому \(4\) посетителя топнут ножкой; клиент с \(ID = 1996\) получит \(3\) номерка и все \(5\) номерков гардероба в момент времени \(t = 28\) будут заняты до тех пор, пока этот же клиент при \(t = 34\) не заберёт вещи. Ответ:\(4 \, 6\)
Решение:
Python
base = ''
fd = open(base + '26.txt')
N, K = map(int, fd.readline().split())
clients = []
for line in fd:
ID, t, M = map(int, line.split())
clients.append((t, ID, M))
clients.sort()
q_top = 0 #кол-во клиентов, топнувших ножкой
full_time = 0 #общее время, когда в гардеробе нет свободных номерков
obizh = set() #мн-во ID обиженных клиентов
sdal = set() #мн-во ID клиентов, сдавших вещи в гардероб
ft = 0 #момент времени, когда в гардеробе не стало свободных номерков
for cl in clients:
t, ID, M = cl
if ID in obizh:
continue
if ID not in sdal:
if M <= N:
sdal.add(ID)
N -= M
if N == 0:
ft = t
else:
obizh.add(ID)
q_top += M
else:
if N == 0:
full_time += t - ft
N += M
print(q_top, full_time)
Ответ: \(5190 \,\, 294\)
Задание 26. Информатика. ЕГЭ. Шастин. 30.11.2024
Просмотры: 872
Изменено: 1 февраля 2025
(Д. Бахтиев, Л. Шастин) На железнодорожной станции ведётся учёт прибывающих и отправляющихся поездов (в минутах, прошедших с начала суток). Станция работает круглосуточно и без перерывов, а администрация станции фиксирует время прибытия и отправления станции каждого поезда. Поезд считается находящимся на станции с момента его прибытия до момента отправления, т.е. если поезд прибыл в минуту \(t\), то всю эту минуту он уже находился на платформе; если поезд уехал в минуту \(t\), то в эту минуту на платформе его уже нет.
Инженер станции анализирует данные, чтобы определить пики загруженности — это промежутки времени, когда на платформе находилось наибольшее количество поездов. Такие периоды могут повторяться в течение суток.
Входной файл содержит информацию о времени прибытия и отправления каждого поезда и номера поездов. Найдите количество пиков загруженности за первые \(24\) часа от начала суток, а также определите сумму номеров всех поездов, которые находились на платформе хотя бы одну минуту в период самого длинного пика. Гарантируется, что самый длинный пик представлен в единственном экземпляре.
Входные данные
В первой строке входного файла находится натуральное число \(N\) (\(N < 10~000\)) — количество поездов, прибывших на станцию в течение суток. Следующие \(N\) строк содержат три числа: первое обозначает номер поезда (натуральное число, не превышающее \(100~000\)), второе и третье — время прибытия и время отправления (оба натуральные числа, не превышающие \(1440\)) каждого поезда в минутах от начала суток.
Выходные данные
В ответе укажите сначала количество пиков, а затем сумму номеров поездов, находившихся на платформе во время самого длинного пика.
Пример входных данных
\(5\)
\(12 \,\, 140 \,\, 250\)
\(44 \,\, 200 \,\, 278\)
\(13 \,\, 0 \,\, 41\)
\(84 \,\, 250 \,\, 310\)
\(11 \,\, 13 \,\, 190\)
Для таких входных данных пиковое количество поездов равно \(2\), а количество таких пиков — \(3\) (с \(3\) до \(41\) минуты, с \(140\) до \(190\) и с \(200\) до \(278\)). Самый длинный пик — третий, сумма номеров поездов для него равна \(12 + 44 + 84 = 140.\) Ответ: \(3 \,\, 140.\)
Решение:
Python
base = ''
fd = open(base + '26.txt')
day = {k: 0 for k in range(1441)} #количество поездов на станции в каждую минуту
trains = {k: [] for k in range(1441)} #номера поездов, находящихся на станции в k-ю минуту
N = int(fd.readline())
for line in fd:
train, arrive, leave = map(int, line.split())
for k in range(arrive, leave):
day[k] += 1
trains[k].append(train)
train_peaks = max(day.values()) # максимальное число поездов на станции
p = 0 #находим пики двойными указателями
peaks = []
while day[p] < train_peaks:
p += 1
p1 = p
while p < 1441 or p1 < 1441:
while p1 < 1441 and day[p1] == train_peaks:
p1 += 1
peaks.append((p, p1))
p = p1
while p < 1441 and day[p] < train_peaks:
p += 1
p1 = p
peaks = [(x[1] - x[0], x) for x in peaks] #len(peaks) будет кол-во пиков
max_peak = max(peaks)[1] #самый длинный из пиков
st = set() #забросим в это множество номера поездов, которые были на станции в максимальный пик
#одни могли уехать, другие приехать
for k in range(max_peak[0], max_peak[1]):
st = st.union(set(trains[k]))
print(len(peaks), sum(st))
Ответ: \(11 \,\, 27785627\)
Задание 26. Информатика. ЕГЭ. Шастин. 6.11.2024
Просмотры: 804
Изменено: 1 февраля 2025
(В. Лашин) На престижном турнире по пауэрлифтингу \(M\) тяжелоатлетов соревнуются в силе, поднимая гирю. Спортсмены поочерёдно подходят к стойке и выбирают вес для дальнейшего подъёма. Каждый из них знает свои возможности и, стремясь к победе, выбирает один максимально возможный вес, который способен поднять, из предложенного на мероприятии набора из \(N\) разновесных снарядов.
После проведения турнира для получения статистических данных организаторы вычислили среднее значение весов снарядов, которые были выбраны атлетами, а также вес самого популярного снаряда. Определите, чему равны эти две величины.
Примечание. Гарантируется, что каждый атлет сможет выбрать для себя подходящий вес.
Входные данные:
Первая строка содержит два целых числа: \(N\) — количество доступных снарядов и \(M\) — количество атлетов (\(1 \leqslant N \leqslant 50000, \,\, 1 \leqslant M \leqslant 50000\)). Следующие \(N\) строк содержат по одному целому числу — веса снарядов (от \(1\) до \(100~000\)). Последние \(M\) строк содержат по одному целому числу — максимальные веса, которые могут поднять атлеты (от \(1\) до \(100~000\)).
Выходные данные:
Запишите в ответе два целых числа — сначала целую часть среднего значения весов, которые выбрали атлеты, а затем вес снаряда, который был выбран максимальное количество раз.
Типовой пример организации данных во входном файле:
\(3 \,\, 3\)
\(50\)
\(100\)
\(70\)
\(60\)
\(80\)
\(65\)
При таких исходных данных первый и третий атлеты выберут вес \(50\), так как они не могут поднять \(70\) и \(100\). Второй атлет выберет вес \(70\), так как он не может поднять \(100\). Средний вес: \((50 + 50 + 70) / 3 = 56\). Чаще всего выбирали снаряд с весом \(50\). Ответ: \(56\) \(50\).
Решение:
Python
base = ''
fd = open(base + '26.txt')
N, M = map(int, fd.readline().split())
weights = []
pop = {}
for i in range(N):
weights.append(int(fd.readline().strip()))
weights.sort()
weights.append(weights[-1] * 1000)
for i in range(M):
w = int(fd.readline().strip())
l = 0
r = N
m = (r + l) // 2
while r - l > 1:
if w > weights[m]:
l = m
elif w < weights[m]:
r = m
else:
l = m
break
m = (r + l) // 2
mxw = weights[l]
pop[mxw] = pop.get(mxw, 0) + 1
pop_weight = 0
q = 0
s = 0
for k, v in pop.items():
s += k * v
if v > q:
q = v
pop_weight = k
print(s // M, pop_weight)
Ответ: \(49989 \,\, 65113\)
Задание 26. Информатика. ЕГЭ. Шастин. 19.09.2024
Просмотры: 940
Изменено: 31 января 2025
(Л. Шастин) Для построения магического карточного домика используется набор из \(N\) игральных карт разных мастей, имеющих весовые номера. Сам карточный домик состоит из некоторого количества уровней. Первый уровень состоит из наибольшего количества карт и служит опорой для остальных уровней. Каждый следующий уровень может включать в себя любое количество карт, которое меньше количества карт, из которых состоит предыдущий уровень. При этом сумма номеров карт, из которых состоит любой следующий уровень, должна быть строго меньше суммы номеров карт, из которых состоит текущий уровень. Идеальным считается карточный домик, состоящий из максимального количества уровней. Определите количество уровней в идеальном карточном домике, который можно построить из карт, имеющихся в наборе, а также минимально возможную сумму номеров всех карт, из которых может состоять такой карточный домик.
Входные данные
В первой строке входного файла находится число \(N\) — количество карт в наборе (натуральное число, не превышающее \(10000\)). В следующих \(N\) строках находятся номера карт (все числа натуральные, не превышающие \(100~000\)), каждое — в отдельной строке.
Запишите в ответе два целых числа: сначала количество уровней в идеальном карточном домике, затем минимально возможную сумму номеров всех карт, из которых может состоять такой домик.
Типовой пример организации данных во входном файле
\(8\)
\(2\)
\(9\)
\(8\)
\(4\)
\(12\)
\(2\)
\(10\)
\(3\)
Пример входного файла приведён для набора из восьми игральных карт. При таких исходных данных идеальный карточный домик будет состоять из трёх уровней: \(\{4, \, 8, \, 9\}\), \(\{3, \, 2\}\), \(\{2\}\). Сумма номеров карт, из которых состоит этот домик, равна \(28\).
Решение:
Python
#N = 8
#cards = [2, 9, 8, 4, 12, 2, 10, 3]
fd = open('26.txt')
N = int(fd.readline())
cards = [int(x) for x in fd]
cards.sort()
level, total, p = 0, 0, 0
rem = N
while level + 1 <= rem:
level += 1
total += sum(cards[p:p+level])
p += level
rem -= level
print(level, total)
Ответ: \(140 \,\, 491509192\)
Задание 26. Информатика. ЕГЭ. Поляков-7775
Просмотры: 189
Изменено: 11 мая 2025
Участники викторины отвечают на \(10\) вопросов, сложность которых оценивается числом от \(10\) до \(100.\) При удачном ответе на вопрос стоимостью \(Q\) участник получает \(Q\) баллов, при неправильном ответе на такой вопрос он получает \(Q\) штрафных баллов, которые вычитаются из результата. Участник может не отвечать на какие-то вопросы, при этом его сумма баллов не изменяется. Чтобы определить победителей, для каждого участника вычисляются три показателя:
сумма – сумма набранных баллов;
штрафы – сумма штрафных баллов за неправильные ответы;
пропуски – количество вопросов, на которые участник вообще не отвечал.
В таблице результатов участники располагаются по убыванию суммы, при равенстве сумм – по возрастанию штрафов, при равенстве сумм и штрафов – по возрастанию пропусков. При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров. Победителями считаются \(20\%\) участников, показавших лучшие результаты, а также те, у которых все три показателя такие же, как у занявшего последнее место среди лучших \(20\%\) участников. Среди \(10\%\) лучших участников, не ставших победителями, но получивших положительную сумму, разыгрывается утешительный приз — автомобиль. Определите личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а также общую сумму баллов, набранную теми участниками, среди которых разыгран автомобиль. Если при определении количества участников получается не целое число, оно округляется до ближайшего меньшего целого.
Входные данные представлены в файле следующим образом. В первой строке входного файла записано натуральное число \(N,\) не превышающее \(10~000\) — количество участников викторины. Вторая строка содержит \(10\) чисел, разделённых пробелом: «стоимости вопросов». В каждой из следующих \(N\) строках через пробел записаны через пробел \(11\) чисел: сначала код участника, а затем \(10\) чисел, характеризующих ответы этого участника на вопросы \((1,\) если ответ верный; \(-1,\) если ответ неверный и \(0,\) если участник не отвечал на вопрос).
Запишите в ответе два числа: сначала личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а затем общую сумму баллов, набранную теми участниками, среди которых разыгран автомобиль.
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
points = [0] + [int(x) for x in fd.readline().split()]
part = []
for line in fd:
data = [int(x) for x in line.split()]
s, p, a = 0, 0, 0
for i in range(1, 11):
s += data[i] * points[i]
p += data[i] * points[i] if data[i] < 0 else 0
a += data[i] == 0
part.append((s, p, -a, -data[0]))
part.sort(reverse=True)
N5 = N // 5
t = part[N5 - 1][:3]
while part[N5][:3] == t:
N5 += 1
consol = [p for p in part[N5:] if p[0] > 0]
N10 = len(consol) // 10
print(-part[N5][3], sum(p[0] for p in consol[:N10]))
Ответ: \(2299 \,\, 36950\)
Задание 26. Информатика. ЕГЭ. Поляков-7774
Просмотры: 199
Изменено: 11 мая 2025
Участники викторины отвечают на \(10\) вопросов, сложность которых оценивается числом от \(10\) до \(100.\) При удачном ответе на вопрос стоимостью \(Q\) участник получает \(Q\) баллов, при неправильном ответе на такой вопрос он получает \(Q\) штрафных баллов, которые вычитаются из результата. Участник может не отвечать на какие-то вопросы, при этом его сумма баллов не изменяется. Чтобы определить победителей, для каждого участника вычисляются три показателя:
сумма – сумма набранных баллов;
штрафы – сумма штрафных баллов за неправильные ответы;
пропуски – количество вопросов, на которые участник вообще не отвечал.
В таблице результатов участники располагаются по убыванию суммы, при равенстве сумм – по возрастанию штрафов, при равенстве сумм и штрафов – по возрастанию пропусков. При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров. Победителями считаются участники, занявшие места в первой трети итоговой таблицы, а также те, у которых все три показателя такие же, как у занявшего последнее место в первой трети таблицы. Определите личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а также количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице 1200 место (включая самого этого участника).
Входные данные представлены в файле следующим образом. В первой строке входного файла записано натуральное число \(N,\) не превышающее \(10~000\) — количество участников викторины. Вторая строка содержит \(10\) чисел, разделённых пробелом: «стоимости вопросов». В каждой из следующих \(N\) строках через пробел записаны через пробел \(11\) чисел: сначала код участника, а затем \(10\) чисел, характеризующих ответы этого участника на вопросы \((1,\) если ответ верный; \(-1,\) если ответ неверный и \(0,\) если участник не отвечал на вопрос).
Запишите в ответе два числа: сначала личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а затем количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице \(1200\) место (включая самого этого участника).
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
points = [0] + [int(x) for x in fd.readline().split()]
part = []
for line in fd:
data = [int(x) for x in line.split()]
s, p, a = 0, 0, 0
for i in range(1, 11):
s += data[i] * points[i]
p += data[i] * points[i] if data[i] < 0 else 0
a += data[i] == 0
part.append((s, p, -a, -data[0]))
part.sort(reverse=True)
N3 = N // 3
t = part[N3 - 1][:3]
while part[N3][:3] == t:
N3 += 1
t = part[1199][:3]
arr = [p for p in part if p[:3] == t]
print(-part[N3][3], len(arr))
Ответ: \(1334 \,\, 5\)
Задание 26. Информатика. ЕГЭ. Поляков-7773
Просмотры: 194
Изменено: 11 мая 2025
Участники викторины отвечают на \(10\) вопросов, сложность которых оценивается числом от \(10\) до \(100.\) При удачном ответе на вопрос стоимостью \(Q\) участник получает \(Q\) баллов, при неправильном ответе на такой вопрос он получает \(Q\) штрафных баллов, которые вычитаются из результата. Участник может не отвечать на какие-то вопросы, при этом его сумма баллов не изменяется. Чтобы определить победителей, для каждого участника вычисляются три показателя:
сумма – сумма набранных баллов;
штрафы – сумма штрафных баллов за неправильные ответы;
пропуски – количество вопросов, на которые участник вообще не отвечал.
В таблице результатов участники располагаются по убыванию суммы, при равенстве сумм – по возрастанию штрафов, при равенстве сумм и штрафов – по возрастанию пропусков. При равенстве всех трёх показателей участники располагаются в итоговой таблице в порядке возрастания их личных номеров. Победителями считаются участники, занявшие места в первой четверти итоговой таблицы, а также те, у которых все три показателя такие же, как у занявшего последнее место в первой четверти таблицы. Определите личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а также количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице 1000 место (включая самого этого участника).
Входные данные представлены в файле следующим образом. В первой строке входного файла записано натуральное число \(N,\) не превышающее \(10~000\) — количество участников викторины. Вторая строка содержит \(10\) чисел, разделённых пробелом: «стоимости вопросов». В каждой из следующих \(N\) строках через пробел записаны через пробел \(11\) чисел: сначала код участника, а затем \(10\) чисел, характеризующих ответы этого участника на вопросы \((1,\) если ответ верный; \(-1,\) если ответ неверный и \(0,\) если участник не отвечал на вопрос).
Запишите в ответе два числа: сначала личный код участника, показавшего лучший результат среди тех, кто не стал победителем викторины, а затем количество участников, у которых все три показателя такие же, как у участника, занявшего в итоговой таблице \(1000\) место (включая самого этого участника).
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
points = [0] + [int(x) for x in fd.readline().split()]
part = []
for line in fd:
data = [int(x) for x in line.split()]
s, p, a = 0, 0, 0
for i in range(1, 11):
s += data[i] * points[i]
p += data[i] * points[i] if data[i] < 0 else 0
a += data[i] == 0
part.append((s, p, -a, -data[0]))
part.sort(reverse=True)
N4 = N // 4
t = part[N4 - 1][:3]
while part[N4][:3] == t:
N4 += 1
t = part[999][:3]
arr = [p for p in part if p[:3] == t]
print(-part[N4][3], len(arr))
Ответ: \(4715 \,\, 8\)
Задание 26. Информатика. ЕГЭ. Поляков-7675
Просмотры: 346
Изменено: 11 мая 2025
(В. Ланская, Р. Ягафаров) В некотором городе существует база данных о зарегистрированных автомобильных нарушениях за последние полгода. Марка каждого автомобиля закодирована как целое число, каждый автомобиль отнесен к одному из трёх классов: эконом, средний, премиум. Возможно, что автомобили одной марки имеют разные классы, это указывает на различные варианты комплектации. В таком случае каждую комбинацию «марка – класс» следует рассматривать как отдельную марку. На основе этой статистики необходимо определить водители какой марки автомобилей в сумме заплатили больше всего за все нарушения. Если таких марок несколько, то выбирается марка с наибольшим номером, и если и таких марок несколько, то марка с наивысшим классом.
Входные данные представлены в файле следующим образом. В первой строке входного файла записано натуральное число \(N,\) не превышающее \(10~000\) — количество нарушений, которые занесены в базу. В каждой из следующих \(N\) строках через пробел записаны три числа — код марки автомобиля (от \(1000\) до \(9999),\) сумма штрафа (натуральное число, не превышающее \(5000)\) и код класса \((1\) — эконом, \(2\) — средний, \(3\) — премиум).
Запишите в ответе два числа: код марки с наибольшей суммой штрафов и саму сумму штрафов, которую заплатили водители данной марки автомобиля.
Пример входного файла:
\(4\)
\(6666 \,\, 750 \,\, 1\)
\(2222 \,\, 1050 \,\, 2\)
\(3333 \,\, 550 \,\, 1\)
\(2222 \,\, 1100 \,\, 2\)
При таких исходных данных наибольшую сумму \((1050 + 1100 = 2150)\) заплатили водители марки \(2222\) класса \(2.\) Ответ: \(2222 \,\, 2150.\)
Решение:
Python
fd = open('26.txt')
N = int(fd.readline())
penalties = {}
for line in fd:
m, p, cl = map(int, line.split())
penalties[(m, cl)] = penalties.get((m, cl), 0) + p
arr = list(zip(penalties.values(), penalties.keys()))
arr.sort(reverse=True)
print(arr[0][1][0], arr[0][0])
Ответ: \(2595 \,\, 13429\)
Задание 26. Информатика. ЕГЭ 2024. Резерв. 19.06.2024
Просмотры: 3097
Изменено: 1 февраля 2025
В магазине продаётся \(N\) товаров нескольких артикулов. Товары одного артикула имеют одинаковую цену. Учёт товаров ведётся поштучно, для каждой единицы известен её текущий статус (продана или нет). Товары разделены на две категории: дорогие и дешёвые. Дорогими считаются товары, цена на которые превышает среднюю цену (среднее арифметическое) всех товаров в базе данных магазина без учёта их текущего статуса, остальные товары считаются дешёвыми.
Лидером продаж называется товар с таким артикулом, наибольшее количество единиц которого продано. Лидер продаж выбирается среди дорогих товаров, а если продано одинаковое количество дорогих товаров с разными артикулами, лидером выбирается товар с наибольшей ценой. Если и таких товаров несколько, либо продаж — то из них, которого осталось меньше всего.
Найдите суммарную стоимость оставшихся единиц товара-лидера продаж, а также артикул этого товара.
Описание входных данных
В первой строке входного файла находится число \(N\) — количество товаров в базе данных магазина. (натуральное число, не превышающее \(10~000\)). В каждой из следующих \(N\) строках находятся три числа, разделённых пробелом: артикул товара (натуральное число до \(100~000\)), его цена (натуральное число до \(10~000\)) и статус (\(0\), если товар уже продан, и \(1\), если ещё не продан).
Выходные данные
Два числа: суммарная стоимость оставшихся единиц товара — лидера продаж, а также артикул этого товара.
Типовой пример организации данных в файле:
\(8\)
\(10 \,\, 100 \,\, 1\)
\(3 \,\, 10 \,\, 0\)
\(10 \,\, 100 \,\, 0\)
\(2 \,\, 20 \,\, 1\)
\(10 \,\, 100 \,\, 0\)
\(3 \,\, 10 \,\, 1\)
\(11 \,\, 100 \,\, 0\)
\(1 \,\, 200 \,\, \)
При таких исходных данных дорогими являются товары стоимостью \(100\) и \(200\) рублей. Больше всего продано товара с артикулом \(10\). В продаже остался один такой товар.
Условию задачи удовлетворяет ответ: \(100 \,\, 10\)
Решение:
Python
f = open('26.txt')
N = int(f.readline())
goods = {}
p = 0
for s in f:
art, price, sell = [int(x) for x in s.split()]
p += price
goods[art] = goods.get(art, [price, 0, 0])
if sell == 0:
goods[art][1] += 1
else:
goods[art][2] += 1
avg_price = p / N
exp_goods = {}
for k,v in goods.items():
if v[0] > avg_price:
exp_goods[k] = v
tmp = sorted(exp_goods.items(), key=lambda x: x[1][1], reverse=True)
sold = tmp[0][1][1]
most_sold = {}
max_price = 0
for i in tmp:
if i[1][1] == sold:
most_sold[i[0]] = i[1]
max_price = max(i[1][0], max_price)
most_sold_max_price = {}
for k, v in most_sold.items():
if v[0] == max_price:
most_sold_max_price[k] = v
msmp = sorted(most_sold_max_price.items(), key=lambda x: x[1][2])
print(msmp[0][1][0] * msmp[0][1][2], msmp[0][0])
Ответ: \(36892 \,\, 45510\)
Задание 26. Информатика. ЕГЭ 2024. Лещинер-1
Просмотры: 583
Изменено: 1 февраля 2025
Куриные яйца по весу делятся на \(4\) категории (от мелких к крупным): вторую, первую, отборную и высшую. На птицефабрике автомат производит взвешивание куриных яиц и осуществляет их сортировку и маркировку в соответствии с категорией. Результаты взвешивания записываются в файл. Для контроля процесса производства следует определить, какова доля яиц отборной и высшей категорий в партии, а также максимальный вес одного яйца в партии.
Входные данные
В первой строке входного файла находятся два числа: \(S\) — минимальный вес яйца, попадающего в отборную категорию, и \(N\) — количество взвешенных яиц в партии (натуральное число, не превышающее \(1000\) ). В следующих \(N\) строках находятся значения веса каждого яйца партии (все числа натуральные, не превышающие \(100\) ), каждое в отдельной строке.
Запишите в ответе два числа: сначала количество яиц, имеющих вес, достаточный для попадания в отборную или высшую категорию, затем максимальный вес яйца в партии.
Пример входного файла:
\(65\) \(4\)
\(60\)
\(66\)
\(77\)
\(40\)
При таких исходных данных в отборную и высшую категории попадают два яйца из 4-х, максимальный вес яйца в партии — 77 г.
Ответ для приведённого примера: \(2\) \(77\)
Решение:
Python
fd = open('26v1.txt')
weight, egg_count = [int(s) for s in fd.readline().strip().split()]
eggs = [int(e) for e in fd]
high_quality_eggs = [int(e >= weight) for e in eggs]
print(sum(high_quality_eggs), max(eggs))
Ответ: \(736\) \(81\)
Задание 26. Информатика. Демо 2024
Просмотры: 2986
Изменено: 1 февраля 2025
Входной файл содержит сведения о заявках на проведение мероприятий в конференц-зале. В каждой заявке указаны время начала и время окончания мероприятия (в минутах от начала суток). Если время начала одного мероприятия меньше времени окончания другого, то провести можно только одно из них. Если время окончания одного мероприятия совпадает со временем начала другого, то провести можно оба. Определите, какое максимальное количество мероприятий можно провести в конференц-зале и каков при этом максимально возможный перерым между двумя последними мероприятиями.
Входные данные
В первой строке входного файла находится натуральное число \(N\) (\( N \leqslant 1000\) ) — количество заявок на проведение мероприятий. Следующие \(N\) строк содержат пары чисел, обозначающих время начала и время окончания мероприятия. Каждое из чисел натуральное, не превосходящее \(1440\).
Запишите в ответе два числа: максимальное количество мероприятий и самый длинный перерыв между двумя последними мероприятиями (в минутах).
Типовой пример организации данных во входном файле
\(5\)
\(10 \quad 150 \)
\(100 \quad 120 \)
\(131 \quad 170 \)
\(150 \quad 180 \)
\(120 \quad 130 \)
При таких исходных данных можно провести максимум три мероприятия, например, мероприятия по заявкам \(2\), \(3\) и \(5\). Максимальный перерыв между двумя последними мероприятиями составит \(20\) мин, если состоятся мероприятия по заявкам \(2\), \(4\) и \(5\).
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python (3.8+)
f = open('26_2024.txt')
applications_quantity = int(f.readline()) # количество заявок, в программе нигде не используется. пусть будет
applications = [] # список кортежей (начало заявки, конец заявки)
applications_begin = set() # множество времён начал заявок
while s := f.readline(): # заполняем массив заявок и множество начал заявок
s_app = s.split()
applications.append((int(s_app[0]), int(s_app[1])))
applications_begin.add(int(s_app[0]))
max_events = 0 # здесь будет максимальное кол-во мероприятий
max_break = 0 # здесь будет максимальный перерыв между двумя последними событиями
for curr_begin in applications_begin: # итерируемся по всевозможным началам мероприятий
min_end = min([e[1] for e in filter(lambda v: v[0] == curr_begin, applications)]) # находим событие, заканчивающееся раньше всего
min_end_prev = 0 # здесь будем запоминать время окончания предыдущего события
avail_app = [e for e in filter(lambda v: v[0] >= min_end, applications)] # оставляем только те события, которые начинаются не раньше времени окончания последнего мероприятия
events = 1 # количество мероприятий
while avail_app: # пока всё еще имеются мероприятия, которые можно провести
min_end_prev = min_end # время окончания предыдущего события
min_end = min([e[1] for e in avail_app]) # находим время окончания следующего события
events += 1
avail_app = [e for e in filter(lambda v: v[0] >= min_end, avail_app)] # отфильтровываемся
if events >= max_events:
last_begin_event = max([e[0] for e in filter(lambda v: v[0] >= min_end_prev, applications)]) # максимальное время начала последнего события
last_break = last_begin_event - min_end_prev # максимальный перерыв между предпоследним и последним мероприятием
if events == max_events:
max_break = max(max_break, last_break)
else:
max_events = events
max_break = last_break
print(max_events, max_break)
Ответ: \(32 \quad 15\)
Задание 26. Информатика. ЕГЭ-2022. 1 вариант
Просмотры: 1376
Изменено: 2 февраля 2025
В магазине для упаковки подарков есть \(N\) кубических коробок. Самой интересной считается упаковка подарка по принципу матрёшки - подарок упаковывается в одну из коробок, та в свою очередь в другую коробку и т.д. Одну коробку можно поместить в другую, если длина её стороны хотя бы на \(3\) единицы меньше длины стороны другой коробки. Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, и максимально возможную длину стороны самой маленькой коробки, где будет находиться подарок. Размер подарка позволяет поместить его в самую маленькую коробку.
Входные данные
В первой строке входного файла находится число \(N\) – количество коробок в магазине (натуральное число, не превышающее \(10~000\)). В следующих \(N\) строках находятся значения длин сторон коробок (все числа натуральные, не превышающие \(10~000\)), каждое – в отдельной строке. Запишите в ответе два целых числа: сначала наибольшее количество коробок, которое можно использовать для упаковки одного подарка, затем максимально возможную длину стороны самой маленькой коробки в таком наборе.
Типовой пример организации данных во входном файле
\(5\)
\(43\)
\(40\)
\(32\)
\(40\)
\(30\)
Пример входного файла приведён для пяти коробок и случая, когда минимальная допустимая разница между длинами сторон коробок, подходящих для упаковки «матрёшкой», составляет \(3\) единицы. При таких исходных данных условию задачи удовлетворяют наборы коробок с длинами сторон \(30\), \(40\) и \(43\) или \(32\), \(40\) и \(43\) соответственно, т.е. количество коробок равно \(3\), а длина стороны самой маленькой коробки равна \(32\).
Типовой пример имеет иллюстративный характер. Для выполнения задания используйте данные из прилагаемых файлов.
Решение:
Python
file_name = open('26-1.txt')
nums_count = int(file_name.readline())
nums = list(map(int, file_name.readlines()))
nums.sort(reverse=True)
box_count = 1
last_box = 0
last_size = nums[0]
for idx in range(1, nums_count):
if nums[last_box] - nums[idx] > 2:
last_box = idx
last_size = nums[idx]
box_count += 1
print(box_count, last_size)
Ответ: \(2767\) \(51\)
Задание 26. Информатика. 2022-8
Просмотры: 420
Изменено: 29 января 2025
Илье необходимо перенести файлы с одного компьютера на другой при помощи внешнего жёсткого диска.
Объём диска может быть меньше, чем требуется для переноса файлов за один раз. Свободный объём на диске и размеры файлов известны.
По заданной информации об объёме файлов на компьютере и свободном объёме на диске определите максимальное число файлов, которые могут быть перенесены за один раз на внешний жесткий диск, а также максимальный размер файла, записанного на этот диск, при условии, что перенесено наибольшее возможное число файлов.
Входные данные
В первой строке входного файла находятся два числа: \(S\) — размер свободного места на диске (натуральное число, не превосходящее \(100~000\)) и \(N\) — количество файлов, которые надо перенести (натуральное число, не превышающее \(10~000\)). В следующих \(N\) строках находятся значения объёмов указанных файлов (все числа натуральные, не превышающие \(100\)), каждое в отдельной строке.
Выходные данные
Запишите в ответе два числа: сначала наибольшее число файлов, которые могут быть перенесены на внешний жёсткий диск за один раз, затем максимальный размер перенесённого файла, при условии, что перенесено наибольшее возможное число файлов. Если вариантов переноса несколько, выберите тот, при котором будет перенесён наибольший файл.
Пример входного файла:
\(100\) \(4\)
\(80\)
\(30\)
\(50\)
\(40\)
При таких исходных данных можно сохранить файлы максимум двух пользователей. Возможные объёмы этих двух файлов: \(30\) и \(40\), \(30\) и \(50\) или \(40\) и \(50\). Наибольший объём файла из перечисленных пар — \(50\), поэтому ответ для приведённого примера:
\(2\) \(50\)
Решение:
Python
f = open('input26_08.txt')
S, N = tuple(map(int, f.readline().split()))
file_size = list(map(int, f.readlines()))
file_size.sort()
num_files = 0 # число файлов, которое можно записать на диск
max_size = 0 # максимальный размер файла
used_cap = 0 # использованное место на диске
curr_file = 0 # текущий номер файла
for i in range(N):
if used_cap + file_size[i] <= S: # пока есть место на диске
used_cap += file_size[i] # записываем файл, учитываем это в использованном объеме
max_size = file_size[i] # максимальный размер файла - размер последнего записанного
else: # место на диске закончилось
num_files = i # количество записанных файлов (i=0,1,2,... а кол-во записанных файлов 1,2,3,...)
curr_file = i - 1 # номер элемента массива для последнего записанного файла
break
if used_cap < S: # если на диске осталось свободное место
used_cap -= file_size[curr_file] # удаляем последний записанный файл
for i in range(N-1, curr_file-1, -1): # и пытаемся записать на его место файл большего размера
if used_cap + file_size[i] <= S: # если это удается, обновляем размер использованного объема
used_cap += file_size[i]
max_size = file_size[i] # максимальный размер файла - это размер последнего записанного файла
break
print(num_files, max_size)
Ответ: \(3105\) \(75\)
Задание 26. Информатика. 2022-7
Просмотры: 348
Изменено: 31 января 2025
Илье необходимо перенести файлы с одного компьютера на другой при помощи внешнего жёсткого диска.
Объём диска может быть меньше, чем требуется для переноса файлов за один раз. Свободный объём на диске и размеры файлов известны.
По заданной информации об объёме файлов на компьютере и свободном объёме на диске определите максимальное число файлов, которые могут быть перенесены за один раз на внешний жесткий диск, а также максимальный размер файла, записанного на этот диск, при условии, что перенесено наибольшее возможное число файлов.
Входные данные
В первой строке входного файла находятся два числа: \(S\) — размер свободного места на диске (натуральное число, не превосходящее \(100~000\)) и \(N\) — количество файлов, которые надо перенести (натуральное число, не превышающее \(10~000\)). В следующих \(N\) строках находятся значения объёмов указанных файлов (все числа натуральные, не превышающие \(100\)), каждое в отдельной строке.
Выходные данные
Запишите в ответе два числа: сначала наибольшее число файлов, которые могут быть перенесены на внешний жёсткий диск за один раз, затем максимальный размер перенесённого файла, при условии, что перенесено наибольшее возможное число файлов. Если вариантов переноса несколько, выберите тот, при котором будет перенесён наибольший файл.
Пример входного файла:
\(100\) \(4\)
\(80\)
\(30\)
\(50\)
\(40\)
При таких исходных данных можно сохранить файлы максимум двух пользователей. Возможные объёмы этих двух файлов: \(30\) и \(40\), \(30\) и \(50\) или \(40\) и \(50\). Наибольший объём файла из перечисленных пар — \(50\), поэтому ответ для приведённого примера:
\(2\) \(50\)
Решение:
Python
f = open('input26_07.txt')
S, N = tuple(map(int, f.readline().split()))
file_size = list(map(int, f.readlines()))
file_size.sort()
num_files = 0 # число файлов, которое можно записать на диск
max_size = 0 # максимальный размер файла
used_cap = 0 # использованное место на диске
curr_file = 0 # текущий номер файла
for i in range(N):
if used_cap + file_size[i] <= S: # пока есть место на диске
used_cap += file_size[i] # записываем файл, учитываем это в использованном объеме
max_size = file_size[i] # максимальный размер файла - размер последнего записанного
else: # место на диске закончилось
num_files = i # количество записанных файлов (i=0,1,2,... а кол-во записанных файлов 1,2,3,...)
curr_file = i - 1 # номер элемента массива для последнего записанного файла
break
if used_cap < S: # если на диске осталось свободное место
used_cap -= file_size[curr_file] # удаляем последний записанный файл
for i in range(N-1, curr_file-1, -1): # и пытаемся записать на его место файл большего размера
if used_cap + file_size[i] <= S: # если это удается, обновляем размер использованного объема
used_cap += file_size[i]
max_size = file_size[i] # максимальный размер файла - это размер последнего записанного файла
break
print(num_files, max_size)
Ответ: \(3084\) \(61\)
Задание 26. Информатика. 2022-6
Просмотры: 302
Изменено: 1 февраля 2025
Илье необходимо перенести файлы с одного компьютера на другой при помощи внешнего жёсткого диска.
Объём диска может быть меньше, чем требуется для переноса файлов за один раз. Свободный объём на диске и размеры файлов известны.
По заданной информации об объёме файлов на компьютере и свободном объёме на диске определите максимальное число файлов, которые могут быть перенесены за один раз на внешний жесткий диск, а также максимальный размер файла, записанного на этот диск, при условии, что перенесено наибольшее возможное число файлов.
Входные данные
В первой строке входного файла находятся два числа: \(S\) — размер свободного места на диске (натуральное число, не превосходящее \(100~000\)) и \(N\) — количество файлов, которые надо перенести (натуральное число, не превышающее \(10~000\)). В следующих \(N\) строках находятся значения объёмов указанных файлов (все числа натуральные, не превышающие \(100\)), каждое в отдельной строке.
Выходные данные
Запишите в ответе два числа: сначала наибольшее число файлов, которые могут быть перенесены на внешний жёсткий диск за один раз, затем максимальный размер перенесённого файла, при условии, что перенесено наибольшее возможное число файлов. Если вариантов переноса несколько, выберите тот, при котором будет перенесён наибольший файл.
Пример входного файла:
\(100\) \(4\)
\(80\)
\(30\)
\(50\)
\(40\)
При таких исходных данных можно сохранить файлы максимум двух пользователей. Возможные объёмы этих двух файлов: \(30\) и \(40\), \(30\) и \(50\) или \(40\) и \(50\). Наибольший объём файла из перечисленных пар — \(50\), поэтому ответ для приведённого примера:
\(2\) \(50\)
Решение:
Python
f = open('input26_06.txt')
S, N = tuple(map(int, f.readline().split()))
file_size = list(map(int, f.readlines()))
file_size.sort()
num_files = 0 # число файлов, которое можно записать на диск
max_size = 0 # максимальный размер файла
used_cap = 0 # использованное место на диске
curr_file = 0 # текущий номер файла
for i in range(N):
if used_cap + file_size[i] <= S: # пока есть место на диске
used_cap += file_size[i] # записываем файл, учитываем это в использованном объеме
max_size = file_size[i] # максимальный размер файла - размер последнего записанного
else: # место на диске закончилось
num_files = i # количество записанных файлов (i=0,1,2,... а кол-во записанных файлов 1,2,3,...)
curr_file = i - 1 # номер элемента массива для последнего записанного файла
break
if used_cap < S: # если на диске осталось свободное место
used_cap -= file_size[curr_file] # удаляем последний записанный файл
for i in range(N-1, curr_file-1, -1): # и пытаемся записать на его место файл большего размера
if used_cap + file_size[i] <= S: # если это удается, обновляем размер использованного объема
used_cap += file_size[i]
max_size = file_size[i] # максимальный размер файла - это размер последнего записанного файла
break
print(num_files, max_size)
Ответ: \(3098\) \(80\)
Задание 26. Информатика. 2022-5
Просмотры: 1137
Изменено: 1 февраля 2025
Илье необходимо перенести файлы с одного компьютера на другой при помощи внешнего жёсткого диска.
Объём диска может быть меньше, чем требуется для переноса файлов за один раз. Свободный объём на диске и размеры файлов известны.
По заданной информации об объёме файлов на компьютере и свободном объёме на диске определите максимальное число файлов, которые могут быть перенесены за один раз на внешний жесткий диск, а также максимальный размер файла, записанного на этот диск, при условии, что перенесено наибольшее возможное число файлов.
Входные данные
В первой строке входного файла находятся два числа: \(S\) — размер свободного места на диске (натуральное число, не превосходящее \(100~000\)) и \(N\) — количество файлов, которые надо перенести (натуральное число, не превышающее \(10~000\)). В следующих \(N\) строках находятся значения объёмов указанных файлов (все числа натуральные, не превышающие \(100\)), каждое в отдельной строке.
Выходные данные
Запишите в ответе два числа: сначала наибольшее число файлов, которые могут быть перенесены на внешний жёсткий диск за один раз, затем максимальный размер перенесённого файла, при условии, что перенесено наибольшее возможное число файлов. Если вариантов переноса несколько, выберите тот, при котором будет перенесён наибольший файл.
Пример входного файла:
\(100\) \(4\)
\(80\)
\(30\)
\(50\)
\(40\)
При таких исходных данных можно сохранить файлы максимум двух пользователей. Возможные объёмы этих двух файлов: \(30\) и \(40\), \(30\) и \(50\) или \(40\) и \(50\). Наибольший объём файла из перечисленных пар — \(50\), поэтому ответ для приведённого примера:
\(2\) \(50\)
Решение:
Python
f = open('input26_05.txt')
S, N = tuple(map(int, f.readline().split()))
file_size = list(map(int, f.readlines()))
file_size.sort()
num_files = 0 # число файлов, которое можно записать на диск
max_size = 0 # максимальный размер файла
used_cap = 0 # использованное место на диске
curr_file = 0 # текущий номер файла
for i in range(N):
if used_cap + file_size[i] <= S: # пока есть место на диске
used_cap += file_size[i] # записываем файл, учитываем это в использованном объеме
max_size = file_size[i] # максимальный размер файла - размер последнего записанного
else: # место на диске закончилось
num_files = i # количество записанных файлов (i=0,1,2,... а кол-во записанных файлов 1,2,3,...)
curr_file = i - 1 # номер элемента массива для последнего записанного файла
break
if used_cap < S: # если на диске осталось свободное место
used_cap -= file_size[curr_file] # удаляем последний записанный файл
for i in range(N-1, curr_file-1, -1): # и пытаемся записать на его место файл большего размера
if used_cap + file_size[i] <= S: # если это удается, обновляем размер использованного объема
used_cap += file_size[i]
max_size = file_size[i] # максимальный размер файла - это размер последнего записанного файла
break
print(num_files, max_size)
Ответ: \(3110\) \(64\)
Задание 26. Информатика. 2022-4
Просмотры: 533
Изменено: 1 февраля 2025
Для хранения двумерного цифрового растрового чёрно-белого изображения Петя сохранил в текстовом файле информацию и позициях всех пикселей чёрного цвета на изображении (номера рядов пикселей и номера чёрных пикселей в ряду). Для редактирования изображения Пете нужно изменить цвет с белого на чёрный трём соседним подряд идущим белым пикселям, таким что слева и справа от них в том же ряду пиксели чёрные.
Найдите ряд с наименьшим номером, в котором есть три соседних подряд идущих белых пикселя, удовлетворяющих требованию Пети. Гарантируется, что есть хотя бы один ряд, удовлетворяющий этому условию. В ответе запишите два целых числа: номер ряда и наибольший номер пикселя в ряду из найденных в этом ряду подходящий пар белых пикселей.
Входные данные
В первой строке входного файла находится число \(N\) — количество рядов пикселей (натуральное число, не превышающее \( 10~000\)). Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(100~000\): номер ряда и номер чёрного пикселя в ряду.
Выходные данные
Два целых неотрицательных числа: номер ряда и наибольший номер пикселя в выбранной паре.
Пример входного файла:
\(7\)
\(30 \,\, 45\)
\(40 \,\, 17\)
\(40 \,\, 21\)
\(40 \,\, 30\)
\(40 \,\, 34\)
\(50 \,\, 10\)
\(50 \,\, 14\)
Условию задачи удовлетворяют три пары чисел: \(40\) и \(20\), \(40\) и \(33\), \(50\) и \(13\). Ответ для приведённого примера:
\(40\) \(33\)
Решение:
Python
f = open('input26_04.txt')
length = int(f.readline())
pixels = [tuple(map(int, s.split())) for s in f.readlines()]
pixels.sort()
curr_row = pixels[0][0] # Текущая строка
curr_pix = [pixels[0][1], ] # Список пикселов в строке curr_row
fl = False
for i in range(1, length):
if pixels[i][0] == curr_row:
curr_pix.append(pixels[i][1]) # Собираем все пикселы в строке curr_row
else: # Все пикселы собраны. Обрабатываем их и устанавливаем новый curr_row
curr_pix.sort(reverse=True) # Сортируем. Нужно вывести наибольший пиксел
len_pix = len(curr_pix)
if len_pix > 1: # Если собранных пикселов больше 1
for k in range(1, len_pix):
if curr_pix[k-1] - curr_pix[k] == 4: # Здесь может поместиться три белых символа
print(curr_row, curr_pix[k-1] - 1) # Мы их нашли. Выводим на экран
fl = True # Флаг сбрасываем в True. Нужно прервать внешний цикл
break # Прерываем внутренний for
if fl: # Если нашли нужные пикселы, прерываем внешний for
break
# Сюда попадаем, если нужных пикселов не нашли.
curr_row = pixels[i][0] # Устанавливаем указатель на новую строку и формируем
curr_pix = [pixels[i][1], ] # новый список пикселов для новой строки curr_row
Ответ: 12876 19283
Задание 26. Информатика. 2022-3
Просмотры: 405
Изменено: 30 января 2025
Для хранения двумерного цифрового растрового чёрно-белого изображения Петя сохранил в текстовом файле информацию и позициях всех пикселей чёрного цвета на изображении (номера рядов пикселей и номера чёрных пикселей в ряду). Для редактирования изображения Пете нужно изменить цвет с белого на чёрный всем имеющимся трём соседним подряд идущим белым пикселям, таким что слева и справа от них в том же ряду пиксели чёрные.
Найдите ряд с наибольшим номером, в котором есть три соседних пикселя, удовлетворяющих требованию Пети. Гарантируется, что есть хотя бы один ряд, удовлетворяющий этому условию. В ответе запишите два целых числа: номер ряда и наименьший номер пикселя в ряду из найденных в этом ряду подходящий пар белых пикселей.
Входные данные
В первой строке входного файла находится число \(N\) — количество рядов пикселей (натуральное число, не превышающее \( 10~000\)). Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(100~000\): номер ряда и номер чёрного пикселя в ряду.
Выходные данные
Два целых неотрицательных числа: номер ряда и наименьший номер пикселя в выбранной паре.
Пример входного файла:
\(7\)
\(20 \,\, 10\)
\(20 \,\, 14\)
\(30 \,\, 45\)
\(40 \,\, 17\)
\(40 \,\, 21\)
\(40 \,\, 30\)
\(40 \,\, 34\)
Условию задачи удовлетворяют три пары чисел: \(20\) и \(11\), \(40\) и \(18\), \(40\) и \(31\). Ответ для приведённого примера:
\(40\) \(18\)
Решение:
Python
f = open('input26_03.txt')
length = int(f.readline())
pixels = [tuple(map(int, s.split())) for s in f.readlines()]
pixels.sort(reverse=True)
curr_row = pixels[0][0] # Текущая строка
curr_pix = [pixels[0][1], ] # Список пикселов в строке curr_row
fl = False
for i in range(1, length):
if pixels[i][0] == curr_row:
curr_pix.append(pixels[i][1]) # Собираем все пикселы в строке curr_row
else: # Все пикселы собраны. Обрабатываем их и устанавливаем новый curr_row
curr_pix.sort() # Сортируем. Нужно вывести наименьший пиксел
len_pix = len(curr_pix)
if len_pix > 1: # Если собранных пикселов больше 1
for k in range(1, len_pix):
if curr_pix[k] - curr_pix[k-1] == 4: # Здесь может поместиться три белых символа
print(curr_row, curr_pix[k-1] + 1) # Мы их нашли. Выводим на экран
fl = True # Флаг сбрасываем в True. Нужно прервать внешний цикл
break # Прерываем внутренний for
if fl: # Если нашли нужные пикселы, прерываем внешний for
break
# Сюда попадаем, если нужных пикселов не нашли.
curr_row = pixels[i][0] # Устанавливаем указатель на новую строку и формируем
curr_pix = [pixels[i][1], ] # новый список пикселов для новой строки curr_row
Ответ: 78950 55774
Задание 26. Информатика. 2022-2
Просмотры: 1926
Изменено: 2 февраля 2025
Для хранения двумерного цифрового растрового чёрно-белого изображения Петя сохранил в текстовом файле информацию и позициях всех пикселей чёрного цвета на изображении (номера рядов пикселей и номера чёрных пикселей в ряду). Для редактирования изображения Пете нужно изменить цвет с белого на чёрный всем имеющимся двум соседним белым пикселям, таким что слева и справа от них в том же ряду пиксели чёрные.
Найдите ряд с наименьшим номером, в котором есть два соседних пикселя, удовлетворяющих требованию Пети. Гарантируется, что есть хотя бы один ряд, удовлетворяющий этому условию. В ответе запишите два целых числа: номер ряда и наибольший номер пикселя в ряду из найденных в этом ряду подходящий пар белых пикселей.
Входные данные
В первой строке входного файла находится число \(N\) — количество рядов пикселей (натуральное число, не превышающее \( 10~000\)). Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(100~000\): номер ряда и номер чёрного пикселя в ряду.
Выходные данные
Два целых неотрицательных числа: номер ряда и наибольший номер пикселя в выбранной паре.
Пример входного файла:
\(7\)
\(30 \,\, 45\)
\(40 \,\, 17\)
\(40 \,\, 20\)
\(40 \,\, 30\)
\(40 \,\, 33\)
\(50 \,\, 10\)
\(50 \,\, 13\)
Условию задачи удовлетворяют три пары чисел: \(40\) и \(19\), \(40\) и \(32\), \(50\) и \(12\). Ответ для приведённого примера:
\(40\) \(32\)
Решение:
Python
f = open('input26_02.txt')
length = int(f.readline())
pixels = [tuple(map(int, s.split())) for s in f.readlines()]
pixels.sort()
curr_row = pixels[0][0] # Текущая строка
curr_pix = [pixels[0][1], ] # Список пикселов в строке curr_row
fl = False
for i in range(1, length):
if pixels[i][0] == curr_row:
curr_pix.append(pixels[i][1]) # Собираем все пикселы в строке curr_row
else: # Все пикселы собраны. Обрабатываем их и устанавливаем новый curr_row
curr_pix.sort(reverse=True) # Сортируем. Нужно вывести наибольший пиксел
len_pix = len(curr_pix)
if len_pix > 1: # Если собранных пикселов больше 1
for k in range(1, len_pix):
if curr_pix[k-1] - curr_pix[k] == 3: # Здесь может поместиться два белых символа
print(curr_row, curr_pix[k-1] - 1) # Мы их нашли. Выводим на экран
fl = True # Флаг сбрасываем в True. Нужно прервать внешний цикл
break # Прерываем внутренний for
if fl: # Если нашли нужные пикселы, прерываем внешний for
break
# Сюда попадаем, если нужных пикселов не нашли.
curr_row = pixels[i][0] # Устанавливаем указатель на новую строку и формируем
curr_pix = [pixels[i][1], ] # новый список пикселов для новой строки curr_row
Ответ: 14480 13579
Задание 26. Информатика. 2022-1
Просмотры: 345
Изменено: 29 января 2025
Для хранения двумерного цифрового растрового чёрно-белого изображения Петя сохранил в текстовом файле информацию и позициях всех пикселей чёрного цвета на изображении (номера рядов пикселей и номера чёрных пикселей в ряду). Для редактирования изображения Пете нужно изменить цвет с белого на чёрный всем имеющимся двум соседним белым пикселям, таким что слева и справа от них в том же ряду пиксели чёрные.
Найдите ряд с наибольшим номером, в котором есть два соседних пикселя, удовлетворяющих требованию Пети. Гарантируется, что есть хотя бы один ряд, удовлетворяющий этому условию. В ответе запишите два целых числа: номер ряда и наименьший номер пикселя в ряду из найденных в этом ряду подходящий пар белых пикселей.
Входные данные
В первой строке входного файла находится число \(N\) — количество рядов пикселей (натуральное число, не превышающее \( 10~000\)). Каждая из следующих \(N\) строк содержит два натуральных числа, не превышающих \(100~000\): номер ряда и номер чёрного пикселя в ряду.
Выходные данные
Два целых неотрицательных числа: номер ряда и наименьший номер пикселя в выбранной паре.
Пример входного файла:
\(7\)
\(20 \,\, 10\)
\(20 \,\, 13\)
\(30 \,\, 45\)
\(40 \,\, 17\)
\(40 \,\, 20\)
\(40 \,\, 30\)
\(40 \,\, 33\)
Условию задачи удовлетворяют три пары чисел: \(20\) и \(11\), \(40\) и \(18\), \(40\) и \(31\). Ответ для приведённого примера:
\(40\) \(18\)
Решение:
Python
f = open('input26_01.txt')
length = int(f.readline())
pixels = [tuple(map(int, s.split())) for s in f.readlines()]
pixels.sort(reverse=True)
curr_row = pixels[0][0] # Текущая строка
curr_pix = [pixels[0][1], ] # Список пикселов в строке curr_row
fl = False
for i in range(1, length):
if pixels[i][0] == curr_row:
curr_pix.append(pixels[i][1]) # Собираем все пикселы в строке curr_row
else: # Все пикселы собраны. Обрабатываем их и устанавливаем новый curr_row
curr_pix.sort() # Сортируем. Нужно вывести наименьший пиксел
len_pix = len(curr_pix)
if len_pix > 1: # Если собранных пикселов больше 1
for k in range(1, len_pix):
if curr_pix[k] - curr_pix[k-1] == 3: # Здесь может поместиться два белых символа
print(curr_row, curr_pix[k-1] + 1) # Мы их нашли. Выводим на экран
fl = True # Флаг сбрасываем в True. Нужно прервать внешний цикл
break # Прерывыаем внутренний for
if fl: # Если нашли нужные пикселы, прерываем внешний for
break
# Сюда попадаем, если нужных пикселов не нашли.
curr_row = pixels[i][0] # Устанавливаем указатель на новую строку и формируем
curr_pix = [pixels[i][1], ] # новый список пикселов для новой строки curr_row
Ответ: 67890 98765
