Чтение файла — три формата

data = list(map(int, open('26.txt').read().split()))

with open('26.txt') as f:
    n = int(f.readline())              # параметр в первой строке
    data = [int(f.readline()) for _ in range(n)]

data = []
with open('26.txt') as f:
    for line in f:
        a, b = map(int, line.split())
        data.append((a, b))

Шаблон решения

with open('26.txt') as f:
    V = int(f.readline())          # вместимость
    n = int(f.readline())          # количество файлов
    sizes = [int(f.readline()) for _ in range(n)]

sizes.sort()                       # по возрастанию

# А. Максимум файлов: жадно набираем самые маленькие
total = 0
count = 0
for s in sizes:
    if total + s <= V:
        total += s
        count += 1
    else:
        break

# Б. Число файлов НЕ меняем, но самый большой из взятых
#    заменяем на как можно больший файл. Оставляем count-1
#    самых маленьких; на последний остаётся свободный бюджет:
budget = V - (total - sizes[count - 1])
best = 0
for s in sizes:
    if s <= budget:                # sizes отсортирован ->
        best = s                   # последний подходящий и есть максимум

print(count)                       # А: сколько файлов
print(best)                        # Б: наибольший возможный размер

Шаблон решения

nums = list(map(int, open('26.txt').read().split()))

top3 = sorted(set(nums), reverse=True)[:3]   # три наибольших РАЗЛИЧНЫХ
threshold = top3[-1]                          # порог: 3-е по величине
qualified = [x for x in nums if x >= threshold]

print(len(qualified))     # А: сколько участников
print(sum(qualified))     # Б: их суммарный результат

Шаблон решения

nums = list(map(int, open('26.txt').read().split()))
L = nums[0]                        # первый — порог суммы пары
nums = nums[1:]

nums.sort()
i, j = 0, len(nums) - 1
pairs = 0
while i < j:
    if nums[i] + nums[j] <= L:     # большой влез к маленькому
        pairs += 1
        i += 1
        j -= 1
    else:
        j -= 1
print(pairs)

Почему сортируем и почему крайние

Шаблон решения

with open('26.txt') as f:
    C = int(f.readline())                       # вместимость контейнера
    weights = list(map(int, f.read().split()))  # порядок из файла — НЕ сортируем

boxes, cur = 1, 0
for w in weights:
    if cur + w <= C:
        cur += w
    else:
        boxes += 1
        cur = w
print(boxes)        # А: сколько контейнеров
print(C - cur)      # Б: свободное место в последнем

Шаблон решения

from bisect import bisect_left

with open('26.txt') as f:
    K = int(f.readline())                    # допустимое число платформ
    logs = list(map(int, f.read().split()))  # в порядке поступления

def feasible(V):                             # хватает ли вместимости V?
    if max(logs) > V:
        return False
    boxes, cur = 1, 0
    for w in logs:
        if cur + w <= V:
            cur += w
        else:
            boxes += 1
            cur = w
    return boxes <= K

candidates = range(max(logs), sum(logs) + 1)
i = bisect_left(candidates, True, key=feasible)
print(candidates[i])                         # минимальная достаточная вместимость

Встроенные функции: модуль bisect

from bisect import bisect_left, bisect_right
data.sort()
cnt = bisect_right(data, hi) - bisect_left(data, lo)   # сколько чисел в [lo, hi]

Шаблон решения

prices = list(map(int, open('26.txt').read().split()))

prices.sort(reverse=True)        # дорогие вперёд
total = 0
for idx, p in enumerate(prices):
    if (idx + 1) % 3 != 0:       # каждый 3-й (3,6,9,...) — бесплатно
        total += p
print(total)                     # А: минимальная сумма к оплате
print(sum(prices) - total)       # Б: суммарная выгода

Шаблон решения

f = open('26.txt')
n, k = map(int, f.readline().split())
plots = []
for _ in range(n):
    plots.append(int(f.readline()))
mowers = []
for _ in range(k):
    power, cost = map(int, f.readline().split())
    mowers.append((power, cost))
f.close()

cache = {}                       # запоминаем ответ для каждого требования r

def best_mower(r):
    if r in cache:               # уже считали — берём готовое
        return cache[r]
    best = None                  # (cost, power) лучшей подходящей косилки
    for power, cost in mowers:
        if power >= r:
            if best is None or cost < best[0] or (cost == best[0] and power > best[1]):
                best = (cost, power)
    cache[r] = best              # запомнили на будущее
    return best

count = {}                       # сколько косилок каждого вида купили
for r in plots:
    cost, power = best_mower(r)
    key = (power, cost)
    count[key] = count.get(key, 0) + 1

max_power = 0
for power, cost in count:
    if power > max_power:
        max_power = power

total = 0
for (power, cost), amount in count.items():
    if power == max_power:
        total += cost * amount

print(total, len(count))         # сумма за самые мощные; число видов

Почему кеширование ускоряет

Шаблон решения

events = []
with open('26.txt') as f:
    n = int(f.readline())
    for _ in range(n):
        start, end = map(int, f.readline().split())
        events.append((start, end))

events.sort(key=lambda e: e[1])       # по правому концу (времени окончания)

count = 0
last_end = -1                          # конец последнего выбранного
for start, end in events:
    if start >= last_end:              # касание разрешено -> '>='
        count += 1
        last_end = end
print(count, last_end)                 # сколько событий; конец последнего

Левый конец: сколько нужно залов

starts = sorted(s for s, e in events)
ends   = sorted(e for s, e in events)
i = j = 0
cur = best = 0
while i < len(starts):
    if starts[i] < ends[j]:   # новое началось раньше, чем освободилось -> +1 зал
        cur += 1
        best = max(best, cur)
        i += 1
    else:
        cur -= 1
        j += 1
print(best)                   # минимум залов = максимум одновременных

Камеры хранения: фиксированное число ячеек

with open('26.txt') as f:
    K = int(f.readline())                 # число ячеек
    n = int(f.readline())                 # число пассажиров
    people = []
    for _ in range(n):
        a, d = map(int, f.readline().split())   # время сдачи и выдачи
        people.append((a, d))

people.sort()                             # по времени сдачи (прибытия)

free_until = [0] * (K + 1)                # ячейки 1..K заняты по это время
count = 0
last_cell = 0
for a, d in people:
    for cell in range(1, K + 1):          # свободная ячейка с min номером
        if a > free_until[cell]:          # доступна со следующей минуты
            free_until[cell] = d
            count += 1
            last_cell = cell
            break
print(count, last_cell)                   # принято багажей; ячейка последнего

Шаблон решения

intervals = []
with open('26.txt') as f:
    n = int(f.readline())
    for _ in range(n):
        s, e = map(int, f.readline().split())
        intervals.append((s, e))

intervals.sort()                   # по левому концу (началу)

total = 0                          # суммарная длина покрытия
segments = 0                       # число непрерывных участков
cur_s, cur_e = intervals[0]
for s, e in intervals[1:]:
    if s <= cur_e:                 # пересекаются или касаются -> раздвигаем
        if e > cur_e:
            cur_e = e
    else:                          # разрыв -> закрываем участок
        total += cur_e - cur_s
        segments += 1
        cur_s, cur_e = s, e
total += cur_e - cur_s             # последний участок
segments += 1
print(total, segments)

Самый длинный участок и самый длинный разрыв

longest_seg = 0
for s, e in merged:
    if e - s > longest_seg:
        longest_seg = e - s

longest_gap = 0
for k in range(1, len(merged)):
    gap = merged[k][0] - merged[k - 1][1]
    if gap > longest_gap:
        longest_gap = gap

Шаблон решения

with open('26.txt') as f:
    n, D = map(int, f.readline().split())   # D — минимальная разница сторон
    sides = []
    for _ in range(n):
        sides.append(int(f.readline()))

sides.sort(reverse=True)           # по убыванию: снаружи внутрь

count = 0
last = None                        # сторона последней вложенной коробки
for s in sides:
    if last is None or s <= last - D:   # помещается с запасом не меньше D
        count += 1
        last = s
print(count, last)                 # число коробок; сторона самой маленькой

Настоящий двумерный случай

boxes.sort(key=lambda b: (b[0], -b[1]))   # по ширине; при равной — высота убыв.
best = 0
longest = [1] * n
for i in range(n):
    for j in range(i):
        if boxes[j][0] < boxes[i][0] and boxes[j][1] < boxes[i][1]:
            if longest[j] + 1 > longest[i]:
                longest[i] = longest[j] + 1
    if longest[i] > best:
        best = longest[i]
print(best)

Шаблон решения

data = []
with open('26.txt') as f:
    n = int(f.readline())
    for num in range(1, n + 1):          # num — порядковый номер (с 1)
        score = int(f.readline())
        data.append((score, num))        # храним результат ВМЕСТЕ с номером

# сортировка по двум ключам:
# по убыванию результата (минус), при равенстве — по возрастанию номера
data.sort(key=lambda t: (-t[0], t[1]))

K = 5
score_k, num_k = data[K - 1]             # место K — это индекс K-1 (с нуля)
print(num_k, score_k)                    # номер участника на K-м месте; его результат

Как задать несколько ключей сразу

data.sort(key=lambda t: (-t[0], -t[2], t[1]))
# по убыв. 1-го показателя; 
# при равенстве по убыв. 2-го; 
# затем по возр. номера