Из четырёх героев нужно собрать пары для испытания. Сколько их и какие? Писать вложенные циклы с проверкой «чтобы не повторялись» долго и легко ошибиться. Запусти:
from itertools import combinations
heroes = ["Эмбер", "Лиза", "Кли", "Барбара"]
for pair in combinations(heroes, 2):
print(pair)
print(len(list(combinations(heroes, 2))))
('Эмбер', 'Лиза')
('Эмбер', 'Кли')
('Эмбер', 'Барбара')
('Лиза', 'Кли')
('Лиза', 'Барбара')
('Кли', 'Барбара')
6
Шесть пар, и ни одна не повторяется в обратном порядке: пара «Эмбер, Лиза» — то же самое, что «Лиза, Эмбер». Замени 2 на 3 и посмотри, сколько получится команд из трёх героев.
from itertools import product, permutations, combinations
import math
elements = ["Пиро", "Гидро"]
print(list(product(elements, repeat=2)))
# → [('Пиро', 'Пиро'), ('Пиро', 'Гидро'), ('Гидро', 'Пиро'), ('Гидро', 'Гидро')]
print(list(permutations("АБВ", 2)))
# → [('А', 'Б'), ('А', 'В'), ('Б', 'А'), ('Б', 'В'), ('В', 'А'), ('В', 'Б')]
print(len(list(combinations(range(8), 4))), math.comb(8, 4)) # → 70 70
product — все пары (тройки…) с повторами и учётом порядка;permutations — порядок важен, повторов нет («кто за кем идёт»);combinations — порядок не важен, повторов нет («кто в команде»).Количество вариантов растёт быстро: четвёрок из 8 героев 70, а из 50 — уже около 230 тысяч. Если нужно только число, считай формулой: math.comb(n, k) и math.perm(n, k) дают ответ мгновенно, ничего не перебирая.
from itertools import chain, islice, accumulate, zip_longest
print(list(chain([1, 2], [3], [4, 5]))) # → [1, 2, 3, 4, 5]
print(list(islice(range(100), 3, 8))) # → [3, 4, 5, 6, 7]
print(list(accumulate([40, 20, 40]))) # → [40, 60, 100]
print(list(zip_longest("АБВ", [1, 2], fillvalue=0))) # → [('А', 1), ('Б', 2), ('В', 0)]
chain склеивает несколько наборов в один без копирования. islice — срез для чего угодно, включая генераторы. accumulate считает накопленные суммы: сколько смолы потрачено после каждого шага. zip_longest работает как zip, но не обрывается на коротком наборе, а добирает значением по умолчанию.
from itertools import groupby
from collections import defaultdict
team = [("Эмбер", "Пиро"), ("Лиза", "Электро"), ("Бэй Доу", "Электро"), ("Кли", "Пиро")]
team.sort(key=lambda hero: hero[1]) # без сортировки groupby ломается
for element, group in groupby(team, key=lambda hero: hero[1]):
print(element, [name for name, _ in group])
by_element = defaultdict(list)
for name, element in team:
by_element[element].append(name)
print(dict(by_element))
Пиро ['Эмбер', 'Кли']
Электро ['Лиза', 'Бэй Доу']
{'Пиро': ['Эмбер', 'Кли'], 'Электро': ['Лиза', 'Бэй Доу']}
groupby склеивает соседние элементы с одним ключом, поэтому данные надо предварительно отсортировать по этому же ключу; иначе одна группа распадётся на несколько. Чаще проще defaultdict(list) из collections: он сам создаёт пустой список при первом обращении к новому ключу, и сортировка не нужна.
from functools import lru_cache
import time
@lru_cache(maxsize=None)
def ways(n):
"""Сколькими способами можно набрать n шагов по 1 или по 2."""
if n <= 1:
return 1
return ways(n - 1) + ways(n - 2)
start = time.perf_counter()
print(ways(80)) # → 37889062373143906
print(time.perf_counter() - start < 0.1) # → True
print(ways.cache_info()) # → CacheInfo(hits=78, misses=81, maxsize=None, currsize=81)
Без кэша такая рекурсия вычисляла бы одни и те же значения миллионы раз и для 80 не закончила бы ни за час. @lru_cache запоминает результат каждого вызова: второй раз с теми же аргументами функция даже не запускается. Условие одно: аргументы должны быть неизменяемыми (числа, строки, кортежи), как ключи словаря, и функция должна всегда давать одинаковый результат на одинаковый вход. В Python 3.9+ есть и короткая запись @cache.
from functools import partial
def damage(attack, multiplier, crit=1.0):
return int(attack * multiplier * crit)
skill = partial(damage, multiplier=2.5)
print(skill(100)) # → 250
print(skill(100, crit=1.5)) # → 375
partial создаёт новую функцию с уже подставленными аргументами. Пригождается, когда куда-то надо передать функцию, а аргументов у неё больше, чем ждёт принимающая сторона (map, sorted(key=…)).
math.perm(3, 3)?ways без @lru_cache сначала для 25, потом для 32. Как растёт время?list(accumulate([20, 20, 40, 20])) и сравни со смолой, которая остаётся после каждой траты из 160.Для испытания нужно собрать команду из k героев так, чтобы стихии у всех были разные. Первая строка ввода — герои через пробел в формате Имя:Стихия, вторая — размер команды k.
Выведи все подходящие команды (имена через запятую и пробел, в том порядке, в каком герои стоят во вводе; сами команды идут в порядке, который выдаёт combinations), по одной на строку, а в конце — Всего: <сколько>.
Пример. Ввод:
Эмбер:Пиро Лиза:Электро Кли:Пиро Барбара:Гидро
2
Вывод:
Эмбер, Лиза
Эмбер, Барбара
Лиза, Кли
Лиза, Барбара
Кли, Барбара
Всего: 5Заготовка (кнопка у блока отправит её в песочницу):
from itertools import combinations
# 1. Прочитай героев (имя и стихия) и размер команды
# 2. Переберём все команды нужного размера
# 3. Оставь только те, где стихии разные; выведи команды и «Всего: …»
У тебя ровно n единиц смолы. Каждый заход стоит либо 20 (подземелье), либо 40 (босс). Сколькими способами можно потратить ровно n смолы? Порядок заходов важен: «подземелье, потом босс» и «босс, потом подземелье» — разные способы. Потратить 0 смолы можно одним способом (ничего не делать). Если потратить ровно n нельзя, ответ 0.
Введи n (от 0 до 2000), выведи количество способов одним числом. Числа получаются огромными, но Python их не боится.
Пример. Ввод 100, вывод 8. Ввод 40, вывод 2: два подземелья или один босс.
Простая рекурсия на больших n не уложится в время: она раз за разом считает одно и то же.
Заготовка (кнопка у блока отправит её в песочницу):
n = int(input())
# 1. Опиши ответ для n через ответы для меньших n (какой был последний заход?)
# 2. Сделай так, чтобы одно и то же значение не считалось дважды
# 3. Выведи число способов
itertools даёт готовые перебиралки: product, permutations, combinations (а число вариантов считает math.comb), chain, islice, accumulate и groupby (только по отсортированным данным; чаще удобнее defaultdict). В functools лежат lru_cache, который запоминает результаты функции, и partial, который фиксирует часть аргументов.
Теперь самое полезное для хранения данных: настоящая база в одном файле.