Решение задачи 26 егэ информатика на питоне

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

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

Но обычно в 26 задании нужно использовать сортирку.

Решать задачи будем преимущественно на языке Python.

Задача (Классическая, Демо 2021)

Системный администратор раз в неделю создаёт архив пользовательских файлов. Однако объём диска, куда он помещает архив, может быть меньше, чем суммарный объём архивируемых файлов.

Известно, какой объём занимает файл каждого пользователя.

По заданной информации об объёме файлов пользователей и свободном объёме на архивном диске определите максимальное число пользователей, чьи файлы можно сохранить в архиве, а также максимальный размер имеющегося файла, который может быть сохранён в архиве, при условии, что сохранены файлы максимально возможного числа пользователей.

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

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

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

Пример входного файла:

При таких исходных данных можно сохранить файлы максимум двух пользователей. Возможные объёмы этих двух файлов 30 и 40, 30 и 50 или 40 и 50. Наибольший объём файла из перечисленных пар – 50, поэтому ответ для приведённого примера:

Решение:

Первый способ (с помощью Excel).

Решим задачу с помощью Excel. Чтобы открыть текстовый файл в программе Excel, выбираем Файл->Открыть, выбираем нужную папку и указываем, чтобы в папке были видны все типы файлов.

И выбираем наш текстовый файл.

Выскочит окно Мастер текстов (импорт). Здесь оставляем выбранный пункт с разделителями и кликаем Далее.

В следующем окне поставим ещё галочку пробел. В итоге Символами-разделителем будут знак табуляции и пробел.

Кликаем ещё раз Далее и Готово.

Наши данные вставятся, как нужно!

Число 8200 (размер свободного места) нужно запомнить или записать на черновике. Число 970 (количество файлов) нам в принципе не нужно при таком подходе решения.

Теперь удаляем первую строчку. Выделяем две ячейки в первой строчке, через контекстное меню мыши нажимаем Удалить…. Выбираем ячейки, со сдвигом вверх.

1. Найдём максимальное количество файлов.

Выделяем весь столбец A и сортируем его по возрастанию.

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

Мы должны выделить максимальное количество ячеек, но чтобы сумма не превышала число 8200.

Получается максимальное количество файлов, которое можно сохранить, равно 568.

2. Найдём максимальный размер файла при максимальном количестве файлов.

Если мы сохраним максимальное количество файлов, то у нас ещё останется свободное место 8200-8176=24, т.к. сумма выделенных ячеек равна 8176.

Мы можем заменить наибольший файл (последняя выделенная ячейка равная 29) ещё большим файлом, размер которого не превышает 24+29=53.

Если покрутим таблицу вниз, то найдём такой файл размером 50. Это и будет наибольший файл при максимальном количестве файлов.

Ответ получается 568 50.

Второй способ (с помощью Python).

f=open('26.txt')
st = f.readline().split()
s=int(st[0])
n=int(st[1])

a=[]

#Записываем данные в список a
for i in range(n):
    x=int(f.readline())
    a.append(x)
    
#Сортируем список
a.sort()

b=[]

for i in range(n):
    if sum(b) + a[i] <= s:
        b.append(a[i])
    else:
        break

b=b[:-1]

for i in range(len(a)-1, -1, -1):
    if sum(b) + a[i] <= s:
        b.append(a[i])
        break

print(len(b), b[-1])

В начале подвязываемся к файлу. С помощью команды readline() считываем первую строчку. С помощью команды split() разбиваем строчку по пробелу на два числа. Переменная st — это список. В st[0] — будет подстрока с первым числом, в st[1] со вторым.

Переменная s — это размер свободного пространства на диске, n — это количество пользователей. Мы должны использоваться функцию int(), чтобы перевести из текстового типа данных в целый числовой.

Заводим пустой список a. В него мы будем помещать все значения объёмов пользователей, которые идут ниже по файлу. Зачитываем последующие числа в список a, превращая их в целый тип данных.

Команда .sort() сортирует (раскладывает по порядку) по возрастанию элементы списка.

Заводим список b. В него будем класть элементы, которые записываем на диск. Т.к. числа отсортированы, то, начиная с самого маленького файла, мы сможем заполнить диск максимальным количеством файлов.

С помощью цикла пробегаемся по всем элементам. В начале проверяем, есть ли место для очередного элемента, а потом записываем элемент в список b. Таким образом, сможем найти максимальное количество.

Чтобы найти максимальный элемент при максимальном количестве, удаляем из списка b последний самый большой элемент.

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

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

Ответ:

Задача (Двумерные списки)

В лесничестве саженцы сосны высадили параллельными рядами, которые пронумерованы идущими подряд натуральными числами. Растения в каждом ряду пронумерованы натуральными числами начиная с единицы.

По данным аэрофотосъёмки известно, в каких рядах и на каких местах растения не прижились. Найдите ряд с наибольшим номером, в котором есть ровно 13 идущих подряд свободных мест для посадки новых сосен, таких, что непосредственно слева и справа от них в том же ряду растут сосны. Гарантируется, что есть хотя бы один ряд, удовлетворяющий этому условию. В ответе запишите два целых числа: наибольший номер ряда и наименьший номер места для посадки из числа найденных в этом ряду подходящих последовательностей из 13 свободных мест.

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

В первой строке входного файла находится число N  — количество прижившихся саженцев сосны (натуральное число, не превышающее 20 000). Каждая из следующих N строк содержит два натуральных числа, не превышающих 100 000: номер ряда и номер места в этом ряду, на котором растёт деревце.

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

Два целых неотрицательных числа: наибольший номер ряда и наименьший номер места в выбранной последовательности из 13 мест, подходящих для посадки новых сосен.

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

7
40 3
40 7
60 33
50 125
50 129
50 68
50 72

Для приведённого примера, при условии, что необходимо 3 свободных места, ответом является пара чисел: 50; 69.

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

Решение:

f=open('26_dm.txt')

n=int(f.readline())

a=[0]*100001

for i in range(0, 100001):
    a[i]=[]


#Заполняем списки
for i in range(0, n):
    s=f.readline()
    b=s.split()
    a[int(b[0])].append(int(b[1]))


#Сортируем списки
for i in range(0, len(a)):
    a[i].sort()


flag_stop=0

for i in range(len(a)-1, -1, -1):
    for j in range(0, len(a[i])-1):
        if a[i][j+1]-a[i][j]==14:
            print(i, a[i][j]+1)
            flag_stop=1
            break

    if flag_stop==1:
        break 

Всего у нас может быть сто тысяч рядов. Поэтому мы заводим 100000 списков. Каждый список — это очередной ряд. Но в программе завели 1000001, т.к. нулевой список использоваться не будет.

В каждый ряд добавляются номера деревьев. Это и будут элементы для каждого списка. Если не будет деревьев в ряду, то список останется пустым.

В программе мы сортируем каждый список, чтобы числа все шли в порядке возрастания.

Если в каком-нибудь списке числа имеют разницу в 14 единиц, то значит между ними ровно 13 свободных мест. Например, числа 10 и 24. Между ними 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23. Всего 13 чисел.

Чтобы проанализировать двумерный массив, используем вложенные циклы. Ряды перебираем сверху вниз. Как только найдём нужный ряд, выйдем из цикла, и в переменной i будет наибольший нужный ряд.

Сами же ряды перебираем в порядке возрастания. Как только между числами разница будет в 14 единиц, то значение j+1 наименьший свободный номер из промежутка в 13 деревьев.

Чтобы вовремя выйти из вложенных циклов, используем дополнительный флаг (переменную flag_stop).

Ответ:

Задача (Демо 2023)

В магазине для упаковки подарков есть N кубических коробок. Самой интересной считается упаковка подарка по принципу матрёшки — подарок упаковывается в одну из коробок, та в свою очередь в другую коробоку и т.д. Одну коробку можно поместить в другую, если длина её стороны хотя бы на 3 единицы меньше длины стороны другой коробки. Определите наибольшее количество коробок, которое можно использовать для упаковки одного подарка, и максимально возможную длину стороны самой маленькой коробки, где будет находиться подарок. Размер подарка позволяет поместить его в самую маленькую коробку.

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

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

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

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

5
43
40
32
40
30

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

При таких исходных данных условию задачи удовлетворяют наборы коробок с длинами сторон 30, 40 и 43 или 32, 40 и 43 соответственно, т.е. количество коробок равно 3, а длина стороны самой маленькой коробки равна 32.

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

Решение:

f=open('26.txt')
n=int(f.readline())

a=[]

for i in range(n):
    x=int(f.readline())
    a.append(x)


a.sort(reverse=True)

k=1
p=a[0]

for i in range(1, len(a)):
    if p-a[i]>=3:
        k=k+1
        p=a[i]

print(k, p)

В начале считываем все числа в массив (список) a. Сортируем их в порядке убывания.

Приступаем собирать упаковку. Начинаем с самой большой упаковки. Большую упаковку точно можно взять в наш подарок. Переменная p — это размер последний коробки, которую мы взяли. Переменная k — количество коробок в подарке на текущий момент времени.

Если следующая коробка подходит по условию, то мы её берём в наш подарок. Кто-то может подумать, что может выгоднее взять не самую большую коробку, а предпоследнего размера. Но все размеры которые будут подходить для предпоследнего элемента, точно будут подходить и для последнего, и количество упаковок точно не будет меньше, если мы берём самую большую коробку.

Дубликаты не влияют на ответы.

Если мы начинаем с самой большой коробки, то в самом конце в переменной p окажется максимальный размер самой маленькой коробки.

Ответ:

Задача (Разные типы товаров)

На закупку товаров типов A, B, C, D и E выделена определённая сумма денег. Эти товары есть в продаже по различной цене. Необходимо на выделенную сумму закупить как можно больше товаров пяти типов (по общему количеству). Если можно разными способами купить максимальное количество пяти типов товаров, то нужно выбрать способ, при котором будет закуплено как можно больше товаров типа A. Если при этих условиях есть несколько способов закупки, нужно потратить как можно меньше денег.

Определите, сколько будет закуплено товаров типа A и сколько денег останется.

Входные данные представлены в файле следующим образом. Первая строка входного файла содержит два целых числа: N – общее количество товаров и M – сумма выделенных на закупку денег (в рублях). Каждая из следующих N строк содержит целое число (цена товара в рублях) и символ (латинская буква), определяющий тип товара. Все данные в строках входного файла отделены одним пробелом.

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

Пример входного файла:

6 110
40 E
50 A
50 D
30 C
20 B
10 A

В данном случае можно купить не более четырёх товаров, из них не более двух товаров типа A. Минимальная цена такой покупки 110 рублей (покупаем товары 10 A, 20 B, 30 C, 50 A). Останется 0 рублей. Ответ: 2 0.

Решение:

f=open('26-rtt.txt')

s=f.readline().split()
n=int(s[0])
m=int(s[1])

X, Y, Z = [], [], []

for i in range(n):
    s=f.readline().split()
    X.append((int(s[0]), s[1]))

X.sort()

sm=0

for i in range(n):
    if sm+X[i][0]<= m:
        sm=sm+X[i][0]
        Y.append(X[i])
    else:
        if X[i][1]=='A':
            Z.append(X[i])


j=0
for i in range(len(Y)-1, -1, -1):

    if Y[i][1]=='A': continue
    
    if sm - Y[i][0] + Z[j][0] <= m:
        sm = sm - Y[i][0] + Z[j][0]
        Y[i] = Z[j]
    else:
        break

    j=j+1

count = 0
for i in range(len(Y)):
    if Y[i][1]=='A':
        count=count+1

print(count, m-sm)

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

После того, как список X укомплектован, сортируем его по первому значению (по цене). Таким образом, самые дешёвые товары всех типов будут находится в начале, самые в дорогие в конце. Так мы сможем найти максимальное количество, которое можно закупить на указанную сумму.

Список Y — это те товары, которые мы взяли при вычислении предыдущего шага. Переменная sm — это та сумма, которую потратим при нахождении максимального количества товаров в независимости от типа товаров.

Список Z — это те товары, которые мы НЕ взяли в предыдущем шаге, но только с типами A.

Основной секрет данной задачи заключается в том, что мы будем убирать по очереди один элемент из списка уже взятых товаров типа В и добавлять один товар типа A из списка не взятых товаров. Т.к. мы всегда один элемент убираем и один прибавляем, то количество остаётся одинаковым, т.е. максимальным. Тем самым мы стараемся сделать товаров типа A как можно больше.

Нужна максимальная экономия при заменах, чтобы можно было сделать как можно больше замен, и при это осталось как можно больше денег. Для этого всегда меняем самый большой элемент из списка Y, на самый маленький элемент из списка Z

При заменах меняем и значение суммы выбранных элементов (переменная sm).

Когда замены больше невозможны, то остаётся только посчитать количество элементов с типом A в списке Y.

Ответ:

Задача (Интересный шаблон)

Предприятие производит оптовую закупку изделий A и C, на которую выделена определённая сумма денег. У поставщика есть в наличии партии этих изделий различных модификаций по различной цене. На выделенные деньги необходимо приобрести как можно больше изделий C (независимо от модификации). Закупать можно любую часть каждой партии. Если у поставщика закончатся изделия C, то на оставшиеся деньги необходимо приобрести как можно больше изделий A. Известна выделенная для закупки сумма, а также количество и цена различных модификаций данных изделий у поставщика. Необходимо определить, сколько будет закуплено изделий A и какая сумма останется неиспользованной. Если возможно несколько вариантов решения (с одинаковым количеством закупленных изделий A), нужно выбрать вариант, при котором оставшаяся сумма максимальна.

Входные данные представлены в файле следующим образом. Первая строка входного файла содержит два целых числа: N – общее количество партий изделий у поставщика и S – сумма выделенных на закупку денег (в рублях). Каждая из следующих N строк описывает одну партию изделия: сначала записана буква A или C (тип изделия), а затем – два целых числа: цена одного изделия в рублях и количество изделий в партии. Все данные в строках входного файла разделены одним пробелом.

В ответе запишите два целых числа: сначала количество закупленных изделий типа A, затем оставшуюся неиспользованной сумму денег.

Пример входного файла:

4 1000
A 14 12
C 30 7
A 40 24
C 50 15

В данном случае сначала нужно купить изделия C: 7 изделий по 30 рублей и 15 изделий по 50 рублей. На это будет потрачено 960 рублей. На оставшиеся 40 рублей можно купить 2 изделия A по 14 рублей. Таким образом, всего будет куплено 2 изделия A и останется 12 рублей. В ответе надо записать числа 2 и 12.

Решение:

Создадим список. Каждый элемент списка будет является тоже списком из трёх элементов: тип изделия, цена изделия и количество изделий данной модификации.

Нам потребуется отсортировать строчки файла сначала по типу изделия, т.к. нужно приобрести как можно больше изделий типа C. После этого нужно сделать сортировку второго уровня, отсортировать строчки по цене. Ведь так мы сможем взять максимальное количество изделий на выделенную сумму.

Рассмотрим интересный шаблон для подобного рода задач.

a=[]
a.append((5, 1, 6))
a.append((7, 7, 3))
a.append((3, 4, 5))
a.append((3, 1, 2))
a.append((3, 3, 2))

a.sort(key=lambda d: (d[0], d[1]))
print(a)

Получается результат:

Видим, что сначала элементы расположились по первому числу, затем уже по второму.

Напишем решение для нашей задачи.

f=open('26_4.txt')
st=f.readline().split()

n=int(st[0])
s=int(st[1])

k=0

a=[]

for i in range(n):
    st=f.readline().split()
    if st[0]=='A': st[0]='D'
    if st[0]=='C': st[0]='B'
    a.append((st[0], int(st[1]), int(st[2])))


a.sort(key=lambda d:(d[0], d[1]))

for i in range(len(a)):
    for j in range(a[i][2]):
        if s-a[i][1]>=0:
            s=s-a[i][1]
            if a[i][0] == 'D':
                k=k+1

print(k, s)

Т.к. нужно в начале набрать изделий типа С как можно больше, то хотелось бы видеть именно в начале этот тип после сортировки. Чтобы добиться желаемого, обозначим букву С за букву B, а букву A за D. Сортировку по цене делаем в возрастающем порядке.

Далее пробегаемся в цикле по отсортированному списку. Во вложенном цикле покупаем один товар конкретной модификации, пока это можно сделать. Посчитываем количество товаров типа A.

Ответ:

Задача (Бинарный поиск)

В текстовом файле записан набор натуральных чисел, не превышающих 10⁹. Гарантируется, что все числа различны. Необходимо определить, сколько в наборе таких пар чётных чисел, что их среднее арифметическое тоже присутствует в файле, и чему равно наибольшее из средних арифметических таких пар.

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

Первая строка входного файла содержит целое число N  — общее количество чисел в наборе. Каждая из следующих N строк содержит одно число.

В ответе запишите два целых числа: сначала количество пар, затем наибольшее среднее арифметическое.

Пример входного файла:
6
3
8
14
11
2
17

В данном случае есть две подходящие пары: 8 и 14 (среднее арифметическое 11), 14 и 2 (среднее арифметическое 8). В ответе надо записать числа 2 и 11.

Решение:

f=open('26_6.txt')
n=int(f.readline())

k=0
mx=0
a=[]

for i in range(n):
    x=int(f.readline())
    a.append(x)

a.sort()

for i in range(0, len(a)-1):
    if a[i]%2==0:
        for j in range(i+1, len(a)):
            if a[j]%2==0:

                sr = (a[i] + a[j]) // 2

                # Бинарный поиск
                l=0
                r=len(a)-1
                index=0

                while(l <= r):
                    
                    index = (r + l) // 2

                    if a[index] == sr:
                        k=k+1
                        mx=max(mx, a[index])
                        break
                    if a[index] < sr:
                        l=index+1
                    else:
                        r=index-1

print(k, mx)

В начале записываем все числа в массив. Сортируем все числа, как обычно в 26 задании из ЕГЭ по информатике.

После идут два вложенных цикла — мы перебираем все пары в массиве a. Берём только чётные числа.

Чтобы найти число в отсортированном массиве воспользуемся «бинарным поиском». Об этом приёме подробно рассказано в этой статье.

Ответ:

Надеюсь, Вам повезёт при решении 26 задания на ЕГЭ по информатике.

Скачать материал

Скачать материал

В текстовом файле записан набор натуральных чисел, не превышающих 10⁹. Гарантируется, что все числа различны. Необходимо определить, сколько в наборе таких пар чётных чисел, что их среднее арифметическое тоже присутствует в файле, и чему равно наибольшее из средних арифметических таких пар.

Входные данные Первая строка входного файла содержит целое число ? – общее количество чисел в наборе. Каждая из следующих ? строк содержит одно число.

Пример входного файла

6
3
8
14
11
2
17

В данном случае есть две подходящие пары: 8 и 14 (среднее арифметическое 11), 14 и 2 (среднее арифметическое 8). В ответе надо записать числа 2 и 11. В ответе запишите два целых числа: сначала количество пар, затем наибольшее среднее арифметическое.

# Линейный поиск (работает долго)
data = list(map(int, open(r'./Data/26/ИН2010401.txt').read().splitlines()))[1:]
k, mx = 0, 0
for i in range(len(data)-1):
    if data[i] % 2 == 0:
        for j in range(i + 1, len(data)):
            if data[j] % 2 == 0:
                sr = (data[i] + data[j]) // 2
                if sr in data:
                    k, mx = k + 1, max(mx, sr)
print(k, mx)

# Бинарный поиск
a = list(map(int, open(r'./Data/26/ИН2010401.txt').read().splitlines()))[1:]
a.sort()
lsts = []
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        if a[i] % 2 == 0 and a[j] % 2 == 0:
            s = (a[i] + a[j]) // 2
            L = i
            R = j + 1
            while L < R - 1:
                C = ( R + L) // 2
                if s < a[C]:
                    R = C
                else: 
                    L = C  
            if a[L] == s:
                lsts.append(s)
print(len(lsts), max(lsts))

Продавец предоставляет покупателю, делающему большую закупку, скидку по следующим правилам:
— на каждый второй товар стоимостью больше 50 рублей предоставляется скидка 25%;
— общая стоимость покупки со скидкой округляется вверх до целого числа рублей;
— порядок товаров в списке определяет продавец и делает это так, чтобы общая сумма скидки была наименьшей.
По известной стоимости каждого товара в покупке необходимо определить общую стоимость покупки с учётом скидки и стоимость самого дорогого 
товара, на который будет предоставлена скидка.

f = open('inf_22_10_20_26.txt')
n = int(f.readline())
s=0
m=[]
for i in range (n):
    a=int(f.readline())
    if a<51:
        s=s+a
    else:
        m.append(a)
m.sort()
for i in range(len(m)//2):
    m[i] = m[i] * 0.75

print(round(s+sum(m)),round(m[i]/0.75))

point=list(list(map.int,string.split())) for string in map(str, open('26.txt').read().splitlines())
n=point[0]
point.pop(0)
point=sorted(point)
maxpoint=0
minpow=0
countpoint=1
for i in range(1,len(point)):
    if point[i] == pont[i-1]:
        continue
    if point[i][o]==point[i-1][0] and point[i-1][1]:
        countpoint+=1
        if countpoint>maxpoint:
            maxpoint=countpoint
            minrow=point[i][0]
        else:
            countpoint=1
print(maxpoint,minrow)

# Предприятие производит оптовую закупку некоторых изделий A и B, на которую выделена определённая сумма денег. У поставщика есть в наличии партии
 этих изделий различных модификаций по различной цене. На выделенные деньги необходимо приобрести как можно больше изделий A независимо от модификации.
 Если у поставщика закончатся изделия A, то на оставшиеся деньги необходимо приобрести как можно больше изделий B. Известны выделенная для закупки сумма,
 а также количество и цена различных модификаций данных изделий у поставщика. Необходимо определить, сколько будет закуплено изделий B и какая сумма 
останется неиспользованной.

f = open('26 (3).txt')
n,m = map(int, f.readline().split())
a=[]
for i in range (n):
    x,y,z = f.readline().split()  #  x -  цена y - количество   z- тип товара
    a.append((z,int(x),int(y)))
a.sort(key = lambda x: (x[0],x[1]))

xsum, countb = 0,0
for x in a:
    if xsum +x[1] >m: break
    for i in range(1,x[2] +1):
        if xsum +x[1] <= m:
            xsum = xsum + x[1]
            if x[0] =='B': countb=countb+1
print(countb,m - xsum)

В текстовом файле записан набор натуральных чисел, не превышающих 109.
 Гарантируется, что все числа различны. Необходимо определить, сколько в наборе таких пар чётных чисел, что их среднее арифметическое тоже присутствует в файле,
 и чему равно наибольшее из средних арифметических таких пар.

Входные данные
Первая строка входного файла содержит целое число N – общее количество чисел в наборе. Каждая из следующих N строк содержит одно число.

f = open(‘stat17032021.txt’)
n = int(f.readline())
e = []
o = set()
for i in range(n):
    x = int(f.readline())
    if x % 2 == 0:
        e.append(x)
    else:
        o.add(x)
k = 0
m = 0
ee = set(e)
for i in range(len(e)-1):
    for j in range(i+1, len(e)):
        sr = (e[i] + e[j]) // 2
        if sr in ee or sr in o:
            k += 1
            if sr > m:
                 m = sr
print(k, m)

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

По заданной информации об объёме файлов пользователей и свободном объёме на архивном диске определите максимальное число пользователей, чьи файлы можно сохранить в архиве, а также максимальный размер имеющегося файла, который может быть сохранён в архиве, при условии, что сохранены файлы максимально возможного числа пользователей.

f=open(‘27883.txt’)
s,n=map(int,f.readline().split())
sv=sorted(map(int,f))
sumn,c=0,0

for i in range(len(sv)):
   if sumn + sv[i]<=s:
       sumn= sumn+sv[i]
       c=c+1
nf=s-sumn+sv[c-1:][0]
while nf not in sv:
    nf=nf+1

print(c,nf)

# Во многих компьютерных системах текущее время хранится в формате «UNIX-время» — количестве секунд от начала суток 1 января 1970 года.
# В одной компьютерной системе проводили исследование загруженности. Для этого в течение месяца с момента UNIX-времени 1633046400 фиксировали и
 заносили в базу данных моменты
 старта и финиша всех процессов, действовавших в этой системе.
# Вам необходимо определить, какое наибольшее количество процессов выполнялось в системе одновременно на неделе, начавшейся в момент UNIX-времени 
1633305600, и в течение какого
 суммарного времени (в секундах) выполнялось такое наибольшее количество процессов.

input= open('26 (1).txt').readline
n=int(input())
L=[]
for i in range(n):
    st,en = map(int,input().split())
    L.append((st,1))
    if en==0: en = 2000000000
    L.append((en,-1))
L.sort()
mxk=dt=k=0
w0=1633305600; w1=w0+7*24*3600
for t,dk in L:
    k += dk
    if w0<k<w1:
        if k>mxk: mxk,dt = k,0
        if k-dk==mxk: dt +=t-t0
    t0=t
print(mxk,dt)

Системный администратор раз в неделю создаёт архив пользовательских файлов. Однако объём диска, куда он помещает архив, может быть меньше, чем суммарный 
объём архивируемых файлов.
Известно, какой объём занимает файл каждого пользователя.
По заданной информации об объёме файлов пользователей и свободном объёме на архивном диске определите максимальное число пользователей, чьи файлы можно
 сохранить в архиве,
 а также максимальный размер имеющегося файла, который может быть сохранён в архиве, при условии, что сохранены файлы максимально возможного числа пользователей.
f = open('26 (2).txt')
data = f.readlines() # массив строк , readlines
 
s = data[0].split() # ['8200', '970']
s = int(s[0]) # 8200 - объем св места на диске
del(data[0]) # первая строка больше не нужна, удаляем ее
for i in range(0, len(data)): # цикл для преобразования в int
    data[i]=int(data[i])
data=sorted(data) # сортируем полученный массив для удобства работы
summa = 0
for count in range (0,len(data)):
    if summa + data[count] > s: break # если сумма больше - прерываем цикл
    summa += data[count] # формируем сумму, добавляя отсортированные элементы 
# как только сумма превысила s, произойдёт выход из цикла по оператору break, 
# а в переменной count останется количество добавленных значений
print (count) # макс число файлов в архиве
# вычисляем запас, который мы можем уменьшить с помощью замены одного выбранного значения на другое:
zapas = s - summa
# теперь выбираем из массива данных те значения, которые могут быть выбраны: 
# разность между таким значением и наибольшим выбранным элементом data[count-1] должна быть не больше, чем  zapas:
for i in range (0,len(data)):
    if data[i] - data[count-1] <= zapas:
        itog = data[i]
print(itog)  # максимальный размер файла

В магазине электроники раз в месяц проводится распродажа. Из всех товаров выбирают K товаров с самой большой ценой и делают на них скидку в 20%. По 
заданной информации 
о цене каждого из товаров и количестве товаров, на которые будет скидка, определите цену самого дорогого товара, не участвующего в распродаже, а также
 целую часть от суммы всех скидок.
f = open('26-k1.txt')
data = f.readlines()
s = data[0].split()
nPrice=int(s[0]) # количество цен
k = int(s[1]) # количество товаров с самой большой ценой
del(data[0])
 
for i in range (0, len(data)): # переводим в целые числа
    data[i] = int(data[i])
print(data)
data = sorted(data,reverse=True) # или data.sort(reverse = True)
summa = 0
 
for i in range(0,k):
    summa+=data[i]*0.2 # 10000 10000 10000
print(data[k],int(summa)) # data[k] - самый дорогой товар, так как k уже не входит в счетчик цикла

# Предприятие производит оптовую закупку некоторых изделий A и B, на которую выделена определённая сумма денег. У поставщика есть в наличии партии этих
# изделий различных модификаций по различной цене. На выделенные деньги необходимо приобрести как можно больше изделий B независимо от модификации.
# Если у поставщика закончатся изделия B, то на оставшиеся деньги необходимо приобрести как можно больше изделий A. Известны выделенная для закупки сумма,
# а также количество и цена различных модификаций данных изделий у поставщика.
# Необходимо определить, сколько будет закуплено изделий A и какая сумма останется неиспользованной.

f = open('26 (4).txt')
n,m = map(int, f.readline().split())
a=[]
for i in range (n):
    x,y,z = f.readline().split()  #  x -  цена y - количество   z- тип товара
    a.append((z,int(x),int(y)))
a.sort(key = lambda x: (x[0]=='A',x[1]))

xsum, counta = 0,0
for x in a:
    if xsum +x[1] >m: break
    for i in range(1,x[2] +1):
        if xsum +x[1] <= m:
            xsum = xsum + x[1]
            if x[0] =='A': counta=counta+1
print(counta,m - xsum)