26.06 Распределение объектов по местам (хранение багажа, парковки, кафе, гостиницы)

with open(’26_1.txt’) as f:
    m,k,n=map(int, f.readline().split())
    s=[list(map(int, f.readline().split())) for _ in range(n)]
s.sort(key=lambda x: (x[0], -x[1]))
per=[[0]*(m+1) for _ in range(k)]
cnt=0
for st,fn in s:
    for i in range(k):
        if per[i][st]==0:
            cnt+=1
            for j in range(st,fn):
                per[i][j]=1
            break
c_per=0
for p in range(1,m+1):
    if all(per[i][p]==1 for i in range(k)):
        c_per+=1
print(cnt, c_per)

Решение (Python)

f = open(’26_3__1vv31.txt’)
k = int(f.readline()) # количество камер хранения
n = int(f.readline()) # количество пассажиров, сдающих багаж
# Создаём список, в котором будут храниться данные о времени,
# когда каждый пассажир собирается сдавать и забирать вещи
a = []
for i in range(n):
    st, end = map(int, f.readline().split())
    a.append([st,end])
# Применяем сортировку, чтобы пассажиры приходили в том порядке, который задан временем их прихода
a.sort()

count = 0 # Кол-во пассажиров, сдавших багаж
last = 0 # Номер камеры, в которую примут вещи у последнего пассажира
# Список с данными о каждой камере
kamera = [[0,0]]*k

# Перебор пассажиров
for i in range(n):
    # Проходимся по каждой камере
    for j in range(k):
        # Если из текущей камеры багаж заберут раньше,
        # чем придёт пассажир, то помещаем багаж пассажира в эту камеру
        if kamera[j][1] < a[i][0]:
            kamera[j] = a[i]
            count += 1
            # Сохраняем номер последней ячейки
            # (прибавляем единицу, так как нумерация мастеров с единицы, а не с нуля)
            last = j+1
            # Прерываем внутренний цикл, чтобы перейти к следующему пассажиру
            break

print(count, last)

Решение (Python)

f = open(’26_4__1vv32.txt’)
k = int(f.readline()) # количество жилых комнат
n = int(f.readline()) # количество групп детей
a = sorted(list(map(int, f.readline().split())) for _ in range(n)) # считываем файл и сортируем данные
numbers = [-1]*k # симулируем номера, в каждой ячейке списка будет записано время освобождения данного номера
# словарь, в котором в качества ключа указана минута, а в качестве значения будет указано сколько номеров занято в данную минуту
free_time = {minute: 0 for minute in range(1,1801)}
count = 0
for start, end, quantity in a: # перебор групп детей
    # если есть такое количество свободных комнат, которое необходимо текущей группе детей
    if len([time for time in numbers if time<start]) >= quantity:
        # то начинается процесс заселения детей в комнаты
        while quantity>0: # пока текущая группа детей не заняла необходимые ей комнаты
            for number in range(k): # перебор комнат
                if numbers[number]<start: # если время приезда текущей группы больше времени освобождения этой комнаты группой, которая заняла эту комнату
                    numbers[number]=end # записываем время освобождения комнаты текущей группой
                    quantity-=1 # уменьшаем количество необходимых комнат для детей, так как только что в одну комнату дети заселились
                    for minute in range(start, end+1): # проход по минутам от времени приезда до минуты уезда
                        free_time[minute]+=1 # отмечаем, что в данные минуты на одну комнату занято будет больше
                    break
        count+=1 # увеличиваем счётчик заселившихся групп детей
# вывод количества заселившихся групп и суммарного времени в течении которого хотя бы одна комната была свободна
print(count, sum(free_time[minute] < k for minute in free_time))

f = open(’26_6__1vv35.txt’)
A = int(f.readline()) # Считываем количество упаковок цветов
B = int(f.readline()) # Считываем количество холодильных камер
C = int(f.readline()) # Считываем вместимость холодильных камер
tovar = sorted(list(map(int, f.readlines())))[::-1] # Считываем объемы цветов и сортируем по убыванию

cameras = [C] * B # Создаем B камер по C вместимости каждый
last = 0 # Номер камеры, в которой положили последнюю упаковку

for c in range(len(cameras)): # Проходимся по холодильным камерам
    for t in range(len(tovar)): # Проходимся по упаковкам цветов
        if cameras[c] >= tovar[t]: # Если свободное место позволяет положить текущую упаковку
            cameras[c] -= tovar[t] # То кладем упаковку и записываем оставшееся место в камере
            tovar[t] = 0 # Текущую упаковку обнуляем
            last = c + 1
        else:
            break # Переходим к следующей камере

    for t in range(len(tovar)):
        if cameras[c] >= tovar[len(tovar) - t - 1]: # Проверяем, можем ли дополнить камеру упаковками маленького объема
            cameras[c] -= tovar[len(tovar) - t - 1] # Если да, то перезаписываем оставшееся место
            if tovar[len(tovar) - t - 1] != 0: # Уложенную упаковку обнуляем
                tovar[len(tovar) - t - 1] = 0
                last = c + 1
print(last, cameras[last - 1])

file = open(’26_7__1vv36.txt’)
# Считываем количество людей в файле
count_people = int(file.readline())
peoples = [] # Список, в котором будут записаны люди
for i in range(count_people):
    start,duration,type = file.readline().split() # Считываем текущую строку
    start,duration = int(start),int(duration) # Переводим в число время прихода и длительность обеда
    # Используем функцию ord для перевода буквы в число и проверяем равно ли 0. А станет 1, а В станет 0. Это сделано для удобства дальнейшего обращения со списком
    type = (ord(type) % 65) == 0
    peoples.append([start,duration,type])
# Симулируем столовую. 20 мест для учителей, 250 мест - для детей
places = [[-1 for i in range(20)],[-1 for i in range(250)]]

count = 0
# Перебор людей
for start,duration,category in peoples:
    ok = False # Флаг, который указывает нашли ли место для человека или нет
    # Перебор категории посадочных мест
    for cat in range(category,2):
        # Перебор посадочных мест определенной категории
        for i in range(len(places[cat])):
            # Если время прихода больше времени освобождения человеком, который уже занял данное место
            if start > places[cat][i]:
                places[cat][i] = start + duration # То записываем время освобождения места текущим человеком
                count += 1 # Увеличиваем счётчик
                ok = True # Отмечаем, что нашли место для человека
                break # Сбрасываем цикл
        if ok: # Если для текущего человека нашли место
            break # То сбрасываем цикл и переходим к следующему человеку
print(count,count_people - count)

Решение (Python)

file = open(’26_8__1vv37__34yhg.txt’)
count_people, count_child, count_teacher = map(int,file.readline().split())  # Считываем из файла количество людей,детей и учителей
array_people = []
for people in file:#Проходимся по всему файлу
    start, duration, category = people.split()
    start, duration = int(start), int(duration)
    array_people += [(start,duration,category)]#Добавление в список всех значений из файла
array_people.sort()
count = 0
places_A = [0]*count_teacher # посадочные места учителей
places_B = [0]*count_child # посадочные места детей
places = [places_A,places_B]
# проход по людям
for start,duration,category in array_people:
    ok = False # Переменная-флаг, которая описывает сел ли текущий человек на место или нет. Изначально мы его еще никуда не посадили
    if category == ’B’:# Проверяем, какой категории принадлежит пришедший человек, если это учитель
        for i in range(len(places_B)):#Проход по всевозможным местам для детей
            if start > places_B[i]:#Если время прихода текущего ребенка больше чем время ухода ребенка,который занимает данное место
                places_B[i] = start + duration#То в ячейку записываем время ухода текущего ребенка
                count += 1
                ok = True
                break# Прерываем цикл перебора мест и переходим к следующему человеку
    else:
        ok = False# Переменная-флаг, которая описывает сел ли текущий человек на место или нет. Изначально мы его еще никуда не посадили
        for i in range(len(places_A)):
            if start > places_A[i]:#Если время прихода текущего взрослого больше, чем время ухода того взрослого, который занимает текущее место
                places_A[i] = start + duration# Тогда записываем время ухода текущего взрослого
                count += 1
                ok = True# Посадили человека на место. Значение флага делаем True
                break# Прерываем цикл перебора мест и переходим к следующему человеку
        if not ok:#Если учителя мы не смогли посадить на место для учителей
            for i in range(len(places_B)):# Проход по всевозможным местах для детей
                if start > places_B[i]:
                    places_B[i] = start + duration
                    count += 1
                    ok = True
                    break
# Нам нужно вывести количество людей, которые сели за место и количество людей, которые не сели за место
#Количество тех, кто не сел за место можно посчитать так: общее количество людей - количество людей, кто сел за место
print(count,count_people-count)

Решение (Python)

f=open(’26_10__30v17.txt’)
n=int(f.readline())
k=int(f.readline())

clients = [] # список клиентов
for line in f.readlines():
    a,b=map(int, line.split())
    clients.append([a,b])
clients.sort() # сортируем список клиентов
table = [0]*k # список, симулирующий каждое рабочее место, в котором будет записано время, в которое освободится каждое место
ans1=0
ans2=0
# проход по клиентам
for client in clients:
    ok = False # флаг, которые показывает нужно ли человеку ждать или нет
    # проход по всем столикам
    for i in range(k):
        # если время прихода текущего клиента больше чем время освобождения данного места другим клиентом и при этом текущий клиент уйдёт ранее закрытия магазина и придет позже или во время открытия
        if client[0]>table[i] and client[0] >= 420 and client[1] <= 60*21:
            table[i]=client[1]+17 # записываем время ухода текущего клиента с учётом уборки данного места после него
            ok = True # помечаем, что для текущего клиента нашли место
            ans1+=1 # увеличиваем счётчик пришедших клиентов
            ans2=i+1 # запоминаем номер места, куда сел последний клиент
            break # прерываем цикл - переходим к следующему клиенту
    if not ok: # если клиенту нужно подождать
        mt=min(table) # определяем место, которое освободится в ближайшее время
        mintime=mt-client[0]+1 # определяем время, которое человеку нужно подождать прежде чем сесть за него
        if mintime<=30: # если время ожидания не более 30 минут
            ind=table.index(mt) # определяем индекс данного места в списке
            T=client[1]-client[0] # считаем время T
            if table[ind]+1+T<=1260: # если данный клиент уйдёт не позже закрытия
                table[ind]+=2+T+15+1 # то сажаем данного человека за место
                ans1+=1 # увеличиваем счётчик пришедших клиентов
                ans2=ind+1 # запоминаем номер места, куда сел последний клиент
print(ans1,ans2)

Решение (Python)

f = open(’26_11__1vv3b.txt’)
k, n = map(int,f.readline().split())
a = sorted([list(map(int, i.split())) for i in f])

# переменная для подсчета количества человек
count = 0
lt = 0
# переменная которая хранит время запуска определенного атракциона
d_s = [-1]*k
# переменная которая хранит время остановки определенного атракциона
d_e = [-1]*k
# цикл по людям
for x in a:
    start,end = x
    # цикл по аттракционам
    for j in range(k):
        # если время запуска больше времени останова прошлого раза
        # или если время запуска равно, так как 2 (и более) человека могут кататься на одном аттракционе одновременно
        if start > d_e[j] or (start == d_s[j]):
            # прибавляем колчество прокатившихся, обновляем переменные конца и начала
            count+=1
            d_s[j] = start
            d_e[j] = end
            lt = j+1
            # останавливаем цикл, так как для этого человека уже найден аттракцион
            break
print(count,lt)

Решение (Python)

f = open(’26_12__30v1f.txt’)
n = int(f.readline()) # считываем количество пришедших клиентов
k = int(f.readline()) # считываем количество мест в кафе

clients = [] # список клиентов
for line in f.readlines():
    a, b = map(int, line.split())
    clients.append([a, b])
clients.sort() # сортируем список клиентов
table = [-1] * k # список, симулирующий каждое рабочее место, в котором будет записано время, в которое освободится каждое место
ans1 = 0
ans2 = 0
for client in clients: # проход по каждому клиенту
    ok = False # флаг, которые показывает нужно ли человеку ждать или нет
    for i in range(k):
        # если время прихода текущего клиента больше чем время освобождения данного места другим клиентом
        if client[0] >= table[i]:
            table[i] = client[1] + 22 # записываем время ухода текущего клиента с учётом уборки данного места после него
            ok = True # помечаем, что для текущего клиента нашли место
            ans1 += 1 # увеличиваем счётчик пришедших клиентов
            ans2 = i + 1 # запоминаем номер места, куда сел последний клиент
            break # прерываем цикл - переходим к следующему клиенту
    if not ok: # если клиенту нужно подождать
        mt = min(table) # определяем место, которое освободится в ближайшее время
        if client[0] + 3 >= mt:  # если время ожидания не более 3 минут
            ind = table.index(mt) # определяем индекс данного места в списке
            T = client[1] - client[0] # считаем время T
            if table[ind] + T <= 1200: # если данный клиент уйдёт не позже закрытия
                table[ind] += T + 22 # то сажаем данного человека за место
                ans1 += 1 # увеличиваем счётчик пришедших клиентов
                ans2 = ind + 1 # запоминаем номер места, куда сел последний клиент
print(ans1, ans2)

Решение (Python)

f = open(’26_13__1vv3e.txt’)
# Считываем количество ячеек в камере хранения (K) и количество пассажиров (N)
k = int(f.readline())
n = int(f.readline())
# Создаем список для хранения времени сдачи и выдачи багажа каждого пассажира
# и считываем эти данные из файла, разделяя каждую строку на два числа
a = [list(map(int, i.split())) for i in f]
# Сортируем список пассажиров по времени сдачи багажа
a.sort()
# Создаем список для хранения состояния каждой ячейки (занята/свободна)
s = [-1]*k
# Инициализируем переменные для подсчета количества сданных багажей
# и для хранения номера последней занятой ячей
count = last = 0
# Проходим по каждому пассажиру
for i in range(n):
    # Проходим по каждой ячейке в камере хранения
    for j in range(len(s)):
        # Если время сдачи багажа текущего пассажира больше времени освобождения ячейки
        if a[i][0] > s[j]:
            # Увеличиваем счетчик сданных багажей
            count += 1
            # Занимаем текущую ячейку багажом пассажира
            s[j] = a[i][1] + 10
            # Обновляем номер последней занятой ячейки
            last = j + 1
            # Прерываем внутренний цикл, чтобы перейти к следующему пассажиру
            break
# Выводим количество сданных багажей и номер последней занятой ячейки
print(count, last)

f = open(’26_14__1vv3g.txt’)
A = int(f.readline()) # Считываем количество упаковок цветов
B = int(f.readline()) # Считываем количество холодильных камер
C = int(f.readline()) # Считываем вместимость холодильных камер
tovar = sorted(list(map(int, f.readlines())))[::-1] # Считываем объемы цветов и сортируем по убыванию

cameras = [C] * B # Создаем B камер по C вместимости каждый
last = 0 # Номер камеры, в которой положили последнюю упаковку

for c in range(len(cameras)): # Проходимся по холодильным камерам
    for t in range(len(tovar)): # Проходимся по упаковкам цветов
        if cameras[c] >= tovar[t]: # Если свободное место позволяет положить текущую упаковку
            cameras[c] -= tovar[t] # То кладем упаковку и записываем оставшееся место в камере
            tovar[t] = 0 # Текущую упаковку обнуляем
            last = c + 1
        else:
            break # Переходим к следующей камере

    for t in range(len(tovar)):
        if cameras[c] >= tovar[len(tovar) - t - 1]: # Проверяем, можем ли дополнить камеру упаковками маленького объема
            cameras[c] -= tovar[len(tovar) - t - 1] # Если да, то перезаписываем оставшееся место
            if tovar[len(tovar) - t - 1] != 0: # Уложенную упаковку обнуляем
                tovar[len(tovar) - t - 1] = 0
                last = c + 1
print(last, cameras[last - 1])

Решение (Python)

f = open(’26_15__1vv3h.txt’)
# Считали первую строку
a, c, b = map(int, f.readline().split())

# Считали данные о пассажирах
data = []
for i in range(b):
    x, y = map(int, f.readline().split())
    data.append([x, y])
data.sort(key=lambda x: (x[0], -x[1]))  # Отсортировали по возрастанию первого элемента и убыванию второго

# Создали список для каждого из мест. places[i][point] отвечает за i-ое место и будет хранить 0 или 1, в зависимости
# от того, занято ли оно в населенном пункте point.
places = [[0] * (a + 1) for i in range(c)]

counter = 0  # Количество пассажиров, которые смогут добраться до нужной им станции
cnt_areas = 0  # Количество участков между соседними городами, в которых места будут полностью заняты

# Перебираем для каждого пассажира места и ищем свободные
for st, fin in data:
    for i in range(c):
        # Если место свободно на данном населённом пункте, то сажаем сюда пассажира
        if places[i][st] == 0:
            counter += 1
            # Резервируем данное место на все населённые пункты с st по fin не включительно. То есть место будет свободно
            # в населённом пункте с индексом fin, так как пассажир на нём сойдёт.
            for j in range(st, fin):
                places[i][j] = 1
            break

# Перебираем для каждого населённого пункта все места и смотрим, чтобы все эти места были заполнены
for p in range(1, a + 1):
    if all(places[i][p] == 1 for i in range(c)):
        cnt_areas += 1
print(cnt_areas, counter)

Решение (Python)

f = open(’26__1w6n4.txt’)
# Считываем количество ячеек в камере хранения (K) и количество пассажиров (N)
k = int(f.readline())
n = int(f.readline())
# Создаем список для хранения времени сдачи и выдачи багажа каждого пассажира
# и считываем эти данные из файла, разделяя каждую строку на два числа
a = [list(map(int, i.split())) for i in f]
# Сортируем список пассажиров по времени сдачи багажа
a.sort()
# Создаем список для хранения состояния каждой ячейки (занята/свободна)
s = [-1]*k
# Инициализируем переменные для подсчета количества сданных багажей
# и для хранения номера последней занятой ячей
count = last = 0
# Проходим по каждому пассажиру
for i in range(n):
    # Проходим по каждой ячейке в камере хранения
    for j in range(len(s)):
        # Если время сдачи багажа текущего пассажира больше времени освобождения ячейки
        if a[i][0] > s[j]:
            # Увеличиваем счетчик сданных багажей
            count += 1
            # Занимаем текущую ячейку багажом пассажира
            s[j] = a[i][1]
            # Обновляем номер последней занятой ячейки
            last = j + 1
            # Прерываем внутренний цикл, чтобы перейти к следующему пассажиру
            break
# Выводим количество сданных багажей и номер последней занятой ячейки
print(count, last)

Решение (Python)

file = open(’26_1.txt’)
count_tables = int(file.readline()) #количество столиков в тайм-кафе
count_client = int(file.readline()) #количество клиентов

#считываем и сортируем время прибытия и ухода для каждого клиента
array_client = sorted(list(map(int,i.split())) for i in file)

count = 0 #количество клиентов, занявших столик
cost = 0 #сумма заработанных денег

#инициализируем список, в котором будем хранить  у соответствующего столика время ухода клиента
tables = [-1]*count_tables

for start,end in array_client: #проходимся циклом по каждому клиенту
    for i in range(len(tables)): #проходимся по списку столиков
        if start > tables[i]: #если время прибытия клиента больше, чем значение у столика
            tables[i] = end #тогда записываем за столик время ухода клиента
            count += 1
            cost += 5 * (end - start + 1)# 1 минута = 5 рублей. Учитываем также минуту ухода
            break
print(count,cost)

Решение (Python)

file = open(’26_1__3cjum.txt’)
count_tables = int(file.readline())  # количество столиков в тайм-кафе
count_client = int(file.readline())  # количество клиентов

# считываем и сортируем время прибытия и ухода для каждого клиента
array_client = sorted(list(map(int, i.split())) for i in file)

count = 0  # количество клиентов, занявших столик
cost = 0  # сумма заработанных денег

# инициализируем список, в котором будем хранить  у соответствующего столика время ухода клиента
tables = [-1] * count_tables

for start, end in array_client:  # проходимся циклом по каждому клиенту
    ok = False  # флаг, сел клиент за столик или нет
    for i in range(len(tables)):  # проходимся по списку столиков
        if start >= tables[i] + 1:  # если время прибытия клиента больше, чем значение у столика
            tables[i] = end  # тогда записываем за столик время ухода клиента
            count += 1
            cost += 7 * (end - start)  # 1 минута = 7 рублей.
            ok = True
            break

    if not ok:  # если флаг равен False
        min_table = min(tables)  # ищем ближайшее время ухода другого клиента
        wait = min_table - start + 1  # Высчитываем время ожидания клиента,
        # количество минут, которое клиенту нужно подождать чтобы занять место за столиком
        if wait <= 10:  # если ожидание меньше 10 минут
            ind = tables.index(min_table)
            T = end - start
            # Увеличиваем время освобождения найденного столика на:
            # 1 - так как нужно учесть, что сесть можно со следующей минуты
            # Т - так как клиент ждал столика Т минут
            # wait - так как ему добавили бесплатные минуты за ожидание
            tables[ind] += 1 + T + wait
            count += 1
            cost += 7 * T
            ok = True

print(count, cost)

Решение (Python)

file = open(’26_2.txt’)
count_client = int(file.readline()) #количество клиентов
count_cameras = int(file.readline()) #количество камер хранения
#сортируем клиентов по времени прибытия и ухода
array_clients = sorted(list(map(int,i.split())) for i in file)
count = 0
last = 0
cameras = [-1]*count_cameras #инициализируем список камер
for start,end in array_clients: #проходимся циклом по каждому клиенту
    for i in range(len(cameras)):  #проходимся по списку камер
        if start > cameras[i]: #если есть камера, которая освободится ко времени прихода клиента
            cameras[i] = end #присваиваем камере время выдачи вещи клиенту
            count += 1
            last = i + 1
            break
print(count,last)

Решение (Python)

file = open(’26_2__3cjv5.txt’)
count_client = int(file.readline()) #количество клиентов
count_cameras = int(file.readline()) #количество камер хранения
#сортируем клиентов по времени прибытия и ухода
array_clients = sorted(list(map(int,i.split())) for i in file)
count = 0
last = 0
cameras = [-1]*count_cameras #инициализируем список камер

for start,end in array_clients:  #проходимся циклом по каждому клиенту
    for i in range(len(cameras)): #проходимся по списку камер
        if start > cameras[i]: #если есть камера, которая освободится ко времени прихода клиента
            cameras[i] = end+3 #присваиваем камере время выдачи вещи клиенту + 3 минуты освобождения камеры
            count += 1
            last = i + 1
            break
print(count,last)

Решение (Python)

file = open(’26_3__3cjvn.txt’)
count_client = int(file.readline()) #количество клиентов
count_cameras = int(file.readline()) #количество камер хранения
array_clients = []
#заполняем список клиентов: время их прибытия, их ухода и категория вещи (A -- 0, B -- 1, C -- 2)
for i in file:
    temp = i.split()
    # используем функцию ord для того чтобы буквы перевести в числа для дальнейшего удобного использования адресации к элементам в списках
    start,end,cat = int(temp[0]),int(temp[1]),ord(temp[2]) % 65
    array_clients += [[start,end,cat]]
array_clients = sorted(array_clients) #сортируем по возрастанию
count = 0
last = 0
#инициализуруем камеры для каждой категории
cameras = [[-1 for i in range(count_cameras)] for j in range(3)]

for start,end,cat in array_clients: #проходимся по списку клиентов
    for category in range(cat,len(cameras)): #проходимся по категории cоответствующей размеру вещи клиента и по категориям большего размера
        ok = False #флаг, отдали ли вещь в камеру хранения
        for i in range(len(cameras[category])): #цикл для прохождения всех камер в данной категории
            if start > cameras[category][i]: #если встречаем камеру,которая освободится к приходу клиента
                cameras[category][i] = end #присваиваем ей время ухода клиента
                count += 1
                last = chr(category + 65) # используем функцию chr для того чтобы узнать букву категории камеры
                ok = True # отмечаем, что нашли для человека камеру
                break # прерываем цикл для того чтобы перейти к перебору категорий
        if ok: # если для текущего человека была найдена камера
            break # прерываем цикл - переходим к следующему человеку
print(count,last)

Решение (Python)

file = open(’26_3.txt’)
count_client = int(file.readline()) #количество клиентов
count_cameras = int(file.readline()) #количество камер хранения
array_clients = []

#заполняем список клиентов: время их прибытия, их ухода и категория вещи (A -- 0, B -- 1, C -- 2)
for i in file:
     temp = i.split()
     # используем функцию ord для того чтобы буквы перевести в числа для дальнейшего удобного использования адресации к элементам в списках
     start,end,cat = int(temp[0]),int(temp[1]),ord(temp[2]) % 65
     array_clients += [[start,end,cat]]

array_clients = sorted(array_clients) #сортируем по возрастанию
count = 0
last = 0
#инициализуруем камеры для каждой категории
cameras = [[-1 for i in range(count_cameras)] for j in range(3)]

for start,end,cat in array_clients: #проходимся по списку клиентов
    for i in range(len(cameras[cat])):  #проходимся по категории cоответствующей размера вещи клиента и по категориям большего размера
        if start > cameras[cat][i]: #если встречаем камеру, которая освободится к приходу клиента
            cameras[cat][i] = end #присваиваем ей время ухода клиента
            count += 1
            last = chr(cat+65) # используем функцию chr для того чтобы узнать букву категории камеры
            break # прерываем цикл - переходим к следующему человеку
print(count,last)

Решение (Python)

file = open(’26_4__3cjwn.txt’)
count_client = int(file.readline()) #количество клиентов
cat_A, cat_B , cat_C = map(int,file.readline().split()) #считываем количество камер  каждой категории
cameras_A = [-1]*cat_A #инициализируем список камер типа А
cameras_B = [-1]*cat_B #инициализируем список камер типа B
cameras_C = [-1]*cat_C #инициализируем список камер типа C
cameras = [cameras_A,cameras_B,cameras_C] #составляем список
count_cameras = [0,0,0]
count = 0
array_client = []

#заполняем список клиентов: время их прибытия, их ухода и категория вещи (A -- 0, B -- 1, C -- 2)
for i in file:
    temp = i.split()
    # используем функцию ord для того чтобы буквы перевести в числа для дальнейшего удобного использования адресации к элементам в списках
    start,end,category = int(temp[0]),int(temp[1]),ord(temp[2]) % 65
    array_client += [[start,end,category]]
array_client = sorted(array_client)  #сортируем по возрастанию

for start,end,category in array_client:  #проходимся по списку клиентов
    ok = False  #флаг, отдали ли вещь в камеру хранения
    for cat in range(category,len(cameras)): #проходимся по категории и по категориям большего размера
        for i in range(len(cameras[cat])): #цикл для прохождения всех камер в данной категории
            if start > cameras[cat][i]: #если встречаем камеру, которая освободится к приходу клиента
                cameras[cat][i] = end #присваиваем ей время ухода клиента
                count += 1
                count_cameras[cat] += 1 #прибавляем единицу к нужной категории
                ok = True # отмечаем, что нашли для человека камеру
                break
        if ok: #если вещь в камере, то прерываем цикл - переходим к следующему человеку, иначе проверяем камеры для более габаритных вещей
            break
print(count)
# используем функцию chr для того чтобы получить букву категории, в которую положили больше всего вещей
print(chr(count_cameras.index(max(count_cameras)) + 65))