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

Решение (Python)

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

 

Решение (Python)

f = open(’26.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)

f = open(’26__1uvv8.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)

f = open(’26__2y9ji.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__1ux52.txt’)
# считываем количество машин в файле
count_cars = int(file.readline())
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = file.readline().split() # считываем текущую строку
    start,duration = int(start),int(duration) # переводим в число время приезда и длительность парковки
    # используем функцию ord для перевода буквы в число. А станет 0, а В станет 1. Это сделано для удобства дальнейшего обращения со списком
    type = ord(type) % 65
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, 80 мест для легковых, 20 - для микроавтобусов
parking = [[-1 for i in range(80)],[-1 for i in range(20)]]
all_cars_count = 0 # количество припаркованных машин любого вида
count_cars_A = 0 # количество припаркованных легковых машин
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,2):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                all_cars_count += 1 # увеличиваем количество припаркованных машин любого вида
                if category == 0: # если текущая машина - легковая
                    count_cars_A += 1 # то увеличиваем счётчик припаркованных легковых машин
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод количества припаркованных легковых машин и количества не припаркованных машин любого вида
print(count_cars_A,count_cars - all_cars_count)

Решение (Python)

file = open(’26__1ux58.txt’)
# считываем количество машин в файле
count_cars = int(file.readline())
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = file.readline().split() # считываем текущую строку
    start,duration = int(start),int(duration) # переводим в число время приезда и длительность парковки
    # используем функцию ord для перевода буквы в число. А станет 0, а В станет 1. Это сделано для удобства дальнейшего обращения со списком
    type = ord(type) % 65
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, 80 мест для легковых, 20 - для микроавтобусов
parking = [[-1 for i in range(80)],[-1 for i in range(20)]]
all_cars_count = 0 # количество припаркованных машин любого вида
count_cars_A = 0 # количество припаркованных легковых машин
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,2):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                all_cars_count += 1 # увеличиваем количество припаркованных машин любого вида
                if category == 0: # если текущая машина - легковая
                    count_cars_A += 1 # то увеличиваем счётчик припаркованных легковых машин
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод количества припаркованных легковых машин и количества не припаркованных машин любого вида
print(count_cars_A,count_cars - all_cars_count)

Решение (Python)

file = open(’26_1__1vn98.txt’)
# считываем количество машин в файле
count_cars = int(file.readline())
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = file.readline().split() # считываем текущую строку
    start,duration = int(start),int(duration) # переводим в число время приезда и длительность парковки
    # используем функцию ord для перевода буквы в число. А станет 0, а В станет 1. Это сделано для удобства дальнейшего обращения со списком
    type = ord(type) % 65
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, 80 мест для легковых, 20 - для микроавтобусов
parking = [[-1 for i in range(180)],[-1 for i in range(20)]]
all_cars_count = 0 # количество припаркованных машин любого вида
count_cars_B = 0 # количество припаркованных автобусов
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,2):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                all_cars_count += 1 # увеличиваем количество припаркованных машин любого вида
                if category == 1: # если текущая машина - автобус
                    count_cars_B += 1 # то увеличиваем счётчик припаркованных автобусов
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод количества припаркованных автобусов и количества не припаркованных машин любого вида
print(count_cars_B,count_cars - all_cars_count)

Решение (Python)

file = open(’26_2__1vn99.txt’)
# считываем количество машин в файле
count_cars,count_A,count_B = map(int,file.readline().split())
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = file.readline().split() # считываем текущую строку
    start,duration = int(start),int(duration) # переводим в число время приезда и длительность парковки
    # используем функцию ord для перевода буквы в число. А станет 0, а В станет 1. Это сделано для удобства дальнейшего обращения со списком
    type = ord(type) % 65
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, списки парковочных мест для каждой категории
parking = [[-1 for i in range(count_A)],[-1 for i in range(count_B)]]
all_cars_count = 0 # количество припаркованных машин любого вида
count_cars_B = 0 # количество припаркованных автобусов
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,2):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                all_cars_count += 1 # увеличиваем количество припаркованных машин любого вида
                if category == 1: # если текущая машина - автобус
                    count_cars_B += 1 # то увеличиваем счётчик припаркованных автобусов
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод количества припаркованных автобусов и количества не припаркованных машин любого вида
print(count_cars_B,count_cars - all_cars_count)

Решение (Python)

file = open(’26_3__1vn9a.txt’)
# считываем количество машин в файле
count_category,count_cars = map(int,file.readline().split())
# Количество парковочных мест для каждой категории
all_category = list(map(int,file.readline().split()))
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = map(int,file.readline().split())
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, списки парковочных мест для каждой категории
parking = []
for i in range(count_category):
    parking.append([-1 for i in range(all_category[i])]) # добавление парковочных мест для определенной категории
count = [0 for i in range(count_category)]
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,count_category):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                count[categ] += 1 # увеличиваем количество припаркованных машин на парковочном месте определенной категории
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод освобождения парковочных мест категории, в которой припарковалось больше всего машин
print(max(parking[count.index(max(count))]))
# Вывод количества машин, которые не смогли припарковаться
print(count_cars- sum(count))

Решение (Python)

file = open(’26_4__2yzqa.txt’)
# считываем количество машин в файле
count_category,count_cars = map(int,file.readline().split())
# Количество парковочных мест для каждой категории
all_category = list(map(int,file.readline().split()))
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = map(int,file.readline().split())
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, списки парковочных мест для каждой категории
parking = []
for i in range(count_category):
    parking.append([-1 for i in range(all_category[i])]) # добавление парковочных мест для определенной категории
count = [0 for i in range(count_category)]
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,count_category):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                count[categ] += 1 # увеличиваем количество припаркованных машин на парковочном месте определенной категории
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод освобождения парковочных мест категории, в которой припарковалось больше всего машин
print(max(parking[count.index(max(count))]))
# Вывод количества машин, которые припарковались на категории парковочных мест где припарковалось больше всего машин
print(max(count))

file = open(’26_6__3mk0m.txt’)
count_cameras = int(file.readline()) # количество камер хранения
count_client = int(file.readline()) # количество пассажиров
array_client = sorted(list(map(int,i.split())) for i in file)
cameras = [-1]*count_cameras # камеры хранения. каждый элемент списка - это камера хранения.
# в ячейки будем записывать время освобождения определенной камеры хранения
count = 0 # количество человек, которые смогли положить вещи в камеру хранения
# временной промежуток от 0 до 3500 минут. Каждый элемент списка это определенная минута.
# Значение под определенной ячейкой - это количество занятых камер в данную минуту
time = [0 for i in range(3500)]
count_minute = 0 # количество минут, в течении которых были заняты все камеры
for client in array_client: # проход по клиентам
    for i in range(len(cameras)): # проход по камерам хранения
        # если время прихода текущего клиента больше чем время освобождения данной камеры
        if client[0] > cameras[i]:
            cameras[i] = client[0]+client[1] # тогда записываем время освобождения данной камеры текущим клиентом
            count += 1
            # проходимся по минутам от времени прихода до времени ухода текущего клиента
            for minute in range(client[0],client[0]+client[1]):
                time[minute] += 1 # отмечаем под каждой минутой, что на одну камеру стало занято больше
            break # прерываем цикл, так как текущий клиент уже положил свои вещи и переходим к следующему клиенту
for i in time: # проход по отрезку времени
    if i == count_cameras: # если количество занятых камер равно количеству камер в файле
        count_minute += 1 # увеличиваем счётчик минут, в течении которого были заняты все камеры
# количество людей, которые не смогли положить вещи можно посчитать следующим образом:
# общее кол-во людей - кол-во людей положивших вещи в камеру
print(count_client- count,count_minute)

f=open(’26_7__1vn9f.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] and client[1] <= 1440:
            table[i]=client[1]+10 # записываем время ухода текущего клиента с учётом уборки данного места после него
            ok = True # помечаем, что для текущего клиента нашли место
            ans1+=1 # увеличиваем счётчик пришедших клиентов
            ans2+=i+1 # запоминаем номер места, куда сел последний клиент
            break # прерываем цикл - переходим к следующему клиенту
    if not ok: # если клиенту нужно подождать
        mt=min(table) # определяем место, которое освободится в ближайшее время
        mintime=mt-client[0]+1 # определяем время, которое человеку нужно подождать прежде чем сесть за него
        # если время ожидания не более 20 минут
        if mintime<=20:
            ind=table.index(mt) # определяем индекс данного места в списке
            T=client[1]-client[0] # считаем время T
            if table[ind]+1+T<=1440: # если данный клиент уйдёт не позже закрытия
                table[ind]+=1+T+10 # то сажаем данного человека за место
                ans1+=1 # увеличиваем счётчик пришедших клиентов
                ans2=ind+1 # запоминаем номер места, куда сел последний клиент
print(ans1,ans2)

Решение (Python)

f = open(’26_8__3mjzz.txt’)
k = int(f.readline()) # количество камер хранения
n = int(f.readline()) # количество пассажиров, сдающих багаж

# Создаём список, в котором будут храниться данные о времени,
# когда каждый пассажир собирается сдавать и забирать вещи
a=[list(map(int, i.split())) for i in f]
# Применяем сортировку, чтобы пассажиры приходили в том порядке, который задан временем их прихода
a.sort()

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

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

# k – количество номеров
# n – количество заявок
# data — список со всеми данными

f = open(’C:/26_10.txt’)
k = int(f.readline())
n = int(f.readline())
data = [list(map(int, f.readline().split())) for i in range(n)]
data.sort()

freeTime = [0] * k # время готовности каждого номера
maxWait = 0 # максимальное время ожидания клиента перед заселением
lastRoom = -1 # последний заселенный на планируемой неделе номер
for start, end in data:
    rn = 0 # для номера с макс. простоем
    for i in range(1, k):
        # Если из этого номера выехали раньше, чем из остальных,
        # то сохраняем его
        if freeTime[i] <= freeTime[rn]:
            rn = i
    # Расчёт максимального времени ожидания клиента перед заселением.
    # Если получится так, что к приезду клиента не будет свободного номера,
    # то он может заселиться в номер, который освободится раньше через какое-то время.
    # Здесь мы это время и рассчитываем.
    # Если доступный номер будет,
    # то разность будет отрицательной, значение maxWait так и останется 0
    maxWait = max(freeTime[rn] - start, maxWait)
    # Если в номер можно заселиться и проживание будет на этой неделе,
    # то сохраняем номер. Также сохраняем в списке значение выезда из номера.
    if freeTime[rn] <= end and freeTime[rn] < 7*24*60:
        freeTime[rn] = end + 46
        lastRoom = rn + 1

print(maxWait, lastRoom)

f = open(’26_11__1vn9j.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_15__1vn9n.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] and client[0] >= 420 and client[1] <= 1380:
            table[i]=client[1]+8 # записываем время ухода текущего клиента с учётом уборки данного места после него
            ok = True # помечаем, что для текущего клиента нашли место
            ans1+=1 # увеличиваем счётчик пришедших клиентов
            ans2=i+1 # запоминаем номер места, куда сел последний клиент
            break # прерываем цикл - переходим к следующему клиенту
    if not ok:  # если клиенту нужно подождать
        mt=min(table) # определяем индекс данного места в списке
        mintime=mt-client[0]+1 # считаем время T
        if mintime<=25: # если время ожидания не более 25 минут
            ind=table.index(mt) # определяем индекс данного места в списке
            T=client[1]-client[0] # считаем время T
            if table[ind]+1+T<=1380: # если данный клиент уйдёт не позже закрытия
                table[ind]+=1+T+8 # то сажаем данного человека за место
                ans1+=1 # увеличиваем счётчик пришедших клиентов
                ans2=ind+1 # запоминаем номер места, куда сел последний клиент
print(ans1,ans2)

Решение (Python)

f = open(’1__1vrj4.txt’)
# Считываем количество ячеек номеров (K) и количество клиентов (N)
n = int(f.readline())
k = 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][0] + a[i][1]
            # Обновляем номер последней занятого номера
            last = j + 1
            # Прерываем внутренний цикл, чтобы перейти к следующему клиента
            break
# Выводим количество сданных номеров и номер последней занятого номера
print(count, last)

Решение (Python)

file = open(’Задание_26__1vrju.txt’)

count_client = int(file.readline())
count_rooms = int(file.readline())

clients = [list(map(int, i.split())) for i in file]
# Сортируем список клиентов
clients.sort()

# Создаем список для хранения состояния каждого номера (занята/свободна)
hotel = [[-1 for i in range(count_rooms)] for j in range(5)]
count = 0
last = 0
# перебор клиентов
for start,duration,cnt in clients:
    # перебор комнат необходимого этажа для клиента
    for i in range(len(hotel[cnt-1])):
        # если время приезда текущего клиента больше времени освобождения номера другим клиентом
        if start > hotel[cnt-1][i]:
            hotel[cnt - 1][i] = start + duration # записываем в этот номер время освобождения текущего клиента
            count += 1 # увеличиваем счётчик
            last = ((cnt-1)*10) + (i+1) # определяем номер, в который заселился последний клиент
            break # прерываем цикл для того чтобы перейти к следующему клиенту
print(count,last)

with open(’26.txt’) as F:
  K, N = map( int, F.readline().split() )
  data = [ tuple(map(int, F.readline().split())) for i in range(N) ]

data.sort()
freeTime = [0]*K # время готовности
maxWait = 0
lastRoom = -1
for tStart, tEnd in data:
  k = 0
  for i in range(1, K):
    if freeTime[i] <= freeTime[k]: k = i
  maxWait = max( freeTime[k] - tStart, maxWait )
  if freeTime[k] <= tEnd and freeTime[k] < 7*24*60:
    print( tStart, tEnd, ’->’, k+1, max(0,freeTime[k] - tStart) )
    freeTime[k] = max( freeTime[k], tEnd ) + 31
    lastRoom = k + 1

print( maxWait, lastRoom )

Решение (Python)

file = open(’Задание_27__1vtrl.txt’)
# считываем количество машин в файле
count_category,count_cars = map(int,file.readline().split())
# Количество парковочных мест для каждой категории
all_category = list(map(int,file.readline().split()))
cars = [] # список, в котором будут записаны машины
for i in range(count_cars):
    start,duration,type = map(int,file.readline().split())
    cars.append([start,duration,type]) # добавляем запись о машине в список
cars.sort() # сортируем список
# симулируем парковку, списки парковочных мест для каждой категории
parking = []
for i in range(count_category):
    parking.append([-1 for i in range(all_category[i])]) # добавление парковочных мест для определенной категории
count = [0 for i in range(count_category)]
for start,duration,category in cars: # перебор машин в списке
    # флаг, который показывает нашли мы ли место для парковки для текущей машины или нет.
    # Это сделано, с той целью, чтобы позже сбросить циклы перебора категории и перебор парковочных мест определенной категории.
    ok = False
    # перебираем категорию для парковочного места
    for categ in range(category,count_category):
        # перебираем парковочные места определенной категории
        for i in range(len(parking[categ])):
            # если время приезда текущей машины совпадает или больше времени уезда той, что уже припаркована на данном парковочном месте
            if start >= parking[categ][i]:
                parking[categ][i] = start + duration # то припарковываем текущую машину на это парковочное место
                count[categ] += 1 # увеличиваем количество припаркованных машин на парковочном месте определенной категории
                ok = True # отмечаем, что машину припарковали
                break # сбрасываем цикл, переходим к следующей категории
        if ok: # если текущую машину припарковали
            break # то сбрасываем цикл, чтобы перейти к следующей машине
# Вывод освобождения парковочных мест категории, в которой припарковалось больше всего машин
print(max(parking[count.index(max(count))]))
# Вывод количества машин, которые припарковались на категории парковочных мест где припарковалось больше всего машин
print(max(count))