egekit-study 1.0.0__py3-none-any.whl

egekit.py

@@ -0,0 +1,1166 @@
+"""EGEKit: алгоритмические инструменты для подготовки к ЕГЭ по информатике.
+Все пользовательские функции перечислены в GUIDE.html и GUIDE.md.
+Python 3.10+, только стандартная библиотека. Условия задач задаёт пользователь.
+"""
+from __future__ import annotations
+from collections import Counter, defaultdict, deque
+from functools import lru_cache
+from itertools import product, permutations, combinations
+from math import ceil, floor, isqrt, hypot, inf
+from pathlib import Path
+import csv
+import fnmatch
+import heapq
+import ipaddress
+import re
+import sqlite3
+import zipfile
+import xml.etree.ElementTree as ET
+
+__version__ = '1.0.0'
+CATALOG = {}
+
+def _task(*numbers):
+    def register(func):
+        CATALOG[func.__name__] = tuple(numbers)
+        return func
+    return register
+
+@_task(3, 9, 17, 22, 24, 26, 27)
+def read_text(path, encoding='utf-8-sig'):
+    """Прочитать текст, сохраняя переводы строк. Для Windows-файла задайте encoding='cp1251'. Пример: read_text('24.txt')."""
+    return Path(path).read_text(encoding=encoding)
+
+@_task(9, 17, 22, 26, 27)
+def read_rows(path, cast=int, skip=0, delimiter=None, encoding='utf-8-sig'):
+    """Прочитать строки таблицы в список списков. skip — число строк заголовка; delimiter=None — любые пробелы. Пустые строки пропускаются. Пример: read_rows('26.txt', skip=1)."""
+    return [[cast(x) for x in line.split(delimiter)] for line in read_text(path, encoding).splitlines()[skip:] if line.strip()]
+
+@_task(17, 26, 27)
+def read_numbers(path, skip=0, encoding='utf-8-sig'):
+    """Прочитать все целые числа после skip строк заголовка, независимо от числа столбцов. Пример: read_numbers('17.txt')."""
+    return [int(x) for line in read_text(path, encoding).splitlines()[skip:] for x in line.split()]
+
+@_task(3, 9)
+def read_csv(path, delimiter=';', encoding='utf-8-sig'):
+    """Прочитать CSV как список словарей; первая строка — названия полей. Значения остаются строками. Пример: read_csv('table.csv'). XLSX нужно предварительно экспортировать в CSV."""
+    with open(path, newline='', encoding=encoding) as f:
+        return list(csv.DictReader(f, delimiter=delimiter))
+
+@_task(3)
+def join_tables(left, right, left_key, right_key):
+    """Внутреннее соединение списков словарей по ключам; результат — пары (левая_строка, правая_строка). Дубликаты дают все сочетания. Пример: join_tables([{'id':1}], [{'ref':1}], 'id', 'ref')."""
+    index = defaultdict(list)
+    for row in right:
+        index[row[right_key]].append(row)
+    return [(a, b) for a in left for b in index[a[left_key]]]
+
+@_task(3)
+def group_aggregate(rows, key, value, aggregate=sum):
+    """Сгруппировать словари по полю key, применить aggregate к значениям поля value. Строковые числа сначала преобразуйте. Пример: group_aggregate([{'city':'A','n':3}], 'city','n')."""
+    groups = defaultdict(list)
+    for row in rows:
+        groups[row[key]].append(row[value])
+    return {k: aggregate(v) for k, v in groups.items()}
+
+@_task(3)
+def sqlite_select(path, query, parameters=()):
+    """Выполнить запрос к существующей SQLite-базе в режиме только чтения; вернуть кортежи строк. Пример: sqlite_select('data.db', 'SELECT * FROM items WHERE price > ?', (100,)). Не предназначено для XLSX."""
+    uri = Path(path).resolve().as_uri() + '?mode=ro'
+    with sqlite3.connect(uri, uri=True) as con:
+        con.execute('PRAGMA query_only=ON')
+        return con.execute(query, parameters).fetchall()
+
+@_task(2, 15)
+def implies(a, b):
+    """Логическое следование a → b. Пример: implies(True, False) вернёт False. Для эквивалентности используйте a == b."""
+    return not a or bool(b)
+
+@_task(2)
+def truth_table(variables, predicate):
+    """Полная таблица истинности. variables — строка/список имён; predicate получает именованные аргументы. Результат: словари с полем F. Пример: truth_table('xy', lambda x,y: x and not y)."""
+    names = list(variables)
+    if len(set(names)) != len(names) or 'F' in names:
+        raise ValueError('Нужны уникальные имена переменных, отличные от F')
+    return [dict(zip(names, bits), F=int(bool(predicate(**dict(zip(names, bits)))))) for bits in product((0, 1), repeat=len(names))]
+
+@_task(2)
+def match_truth_columns(variables, rows, predicate):
+    """Найти перестановки переменных по неполной таблице. Каждая строка: n столбцов + F; None — неизвестно. Требует разных полных строк, учитывает неоднозначность. Пример: match_truth_columns('xy', [(0,1,0)], lambda x,y:x and y)."""
+    n = len(variables)
+    if any(len(r) != n + 1 or any(v not in (0,1,None) for v in r) for r in rows):
+        raise ValueError('Строка должна содержать n+1 значений 0, 1 или None')
+    answers = []
+    for names in permutations(variables):
+        candidates = []
+        for row in rows:
+            fits = []
+            for bits in product((0,1), repeat=n):
+                f = int(bool(predicate(**dict(zip(names,bits)))))
+                if all(a is None or a == b for a,b in zip(row, (*bits,f))):
+                    fits.append(bits)
+            candidates.append(fits)
+        def assign(i, used):
+            if i == len(candidates): return True
+            return any(assign(i+1, used | {b}) for b in candidates[i] if b not in used)
+        if assign(0, set()): answers.append(names)
+    return answers
+
+@_task(1)
+def match_graphs(graph, numbered, compare_weights=False):
+    """Все соответствия вершин двух графов (списки словарей смежности с весами). Учитывает направление; по умолчанию сопоставляет только наличие рёбер (для №1), compare_weights=True дополнительно требует одинаковых весов. Все вершины, включая изолированные, должны быть ключами обоих словарей. Полный перебор n!, подходит небольшим графам. Пример: match_graphs({'A':{'B':1},'B':{'A':1}}, {1:{2:1},2:{1:1}})."""
+    if len(graph) != len(numbered): return []
+    vertices = list(graph)
+    answers = []
+    for order in permutations(numbered):
+        mapping = dict(zip(vertices, order))
+        if all((graph[a].get(b) == numbered[mapping[a]].get(mapping[b]) if compare_weights else (b in graph[a]) == (mapping[b] in numbered[mapping[a]])) for a in vertices for b in vertices):
+            answers.append(mapping)
+    return answers
+
+@_task(1, 13)
+def shortest_paths(graph, start):
+    """Расстояния от start алгоритмом Дейкстры. graph[u] — словарь сосед:неотрицательный_вес; недостижимые вершины имеют inf. Пример: shortest_paths({'A':{'B':3},'B':{}},'A')."""
+    nodes = set(graph) | {v for edges in graph.values() for v in edges} | {start}
+    if any(w < 0 for edges in graph.values() for w in edges.values()): raise ValueError('Отрицательный вес')
+    dist = dict.fromkeys(nodes, inf); dist[start] = 0
+    serial = 0; heap = [(0,serial,start)]
+    while heap:
+        d,_,u = heapq.heappop(heap)
+        if d != dist[u]: continue
+        for v,w in graph.get(u,{}).items():
+            if d+w < dist[v]:
+                dist[v] = d+w; serial += 1
+                heapq.heappush(heap,(d+w,serial,v))
+    return dist
+
+@_task(1, 13, 23)
+def count_graph_paths(graph, start, finish, forbidden=()):
+    """Число путей в ориентированном ациклическом графе; graph[u] — соседи. forbidden — запрещённые вершины. Достижимый цикл вызывает ValueError. Пример: count_graph_paths({'A':['B','C'],'B':['C']},'A','C')."""
+    forbidden = set(forbidden); active = set()
+    @lru_cache(None)
+    def walk(u):
+        if u in forbidden: return 0
+        if u == finish: return 1
+        if u in active: raise ValueError('Нужен ациклический граф')
+        active.add(u)
+        result = sum(walk(v) for v in graph.get(u,()))
+        active.remove(u)
+        return result
+    return walk(start)
+
+@_task(4, 7, 11)
+def bits_per_symbol(alphabet_size):
+    """Минимум бит на символ равномерного кода: ceil(log2(N)), точно для больших целых. N=1 даёт 0. Пример: bits_per_symbol(33) == 6."""
+    if alphabet_size < 1: raise ValueError('Алфавит должен быть непустым')
+    return (alphabet_size-1).bit_length()
+
+@_task(7, 11)
+def storage_bytes(symbols, alphabet_size, records=1, round_each=True):
+    """Объём равномерного кодирования в байтах. round_each=True округляет каждый объект отдельно, False — весь поток. Пример: storage_bytes(10,33,100) == 800. Служебные поля прибавляйте отдельно."""
+    bits = symbols * bits_per_symbol(alphabet_size)
+    return ((bits+7)//8)*records if round_each else (bits*records+7)//8
+
+@_task(7)
+def image_bits(width, height, colors):
+    """Объём несжатого растра в битах, без заголовка и выравнивания строк. Пример: image_bits(100,100,256) == 80000."""
+    return width * height * bits_per_symbol(colors)
+
+@_task(7)
+def audio_bits(seconds, sample_rate, depth, channels=1):
+    """Объём несжатого звука: секунды × частота Гц × глубина бит × каналы. Возвращает биты. Пример: audio_bits(10,48000,16,2)."""
+    return seconds * sample_rate * depth * channels
+
+@_task(7)
+def transmission_seconds(bits, rate, compression=1.0, overhead_bits=0):
+    """Время передачи при rate бит/с. compression — доля оставшихся данных (0.6 = 60%), служебные биты прибавляются после сжатия. Пример: transmission_seconds(8000,1000) == 8."""
+    if rate <= 0 or compression < 0 or overhead_bits < 0: raise ValueError('Некорректные параметры')
+    return (bits*compression + overhead_bits)/rate
+
+@_task(4)
+def is_prefix_free(codes):
+    """Проверить условие Фано для набора непустых двоичных слов. Дубликаты недопустимы. Пример: is_prefix_free(['0','10','11']) == True."""
+    codes = sorted(codes)
+    return all(c and set(c) <= {'0','1'} for c in codes) and all(not b.startswith(a) for a,b in zip(codes,codes[1:]))
+
+@_task(4)
+def available_codewords(codes, length):
+    """Все двоичные слова заданной length, совместимые с условием Фано для уже известных codes. Экспоненциальный перебор 2**length. Пример: available_codewords(['0'], 2) == ['10','11']."""
+    if length < 1 or not is_prefix_free(codes): raise ValueError('Нужны корректные коды и положительная длина')
+    return [''.join(bits) for bits in product('01', repeat=length) if is_prefix_free([*codes,''.join(bits)])]
+
+@_task(4)
+def encoded_length(text, codebook):
+    """Длина сообщения в битах по словарю символ:код. Пример: encoded_length('ABA', {'A':'0','B':'11'}) == 4."""
+    return sum(len(codebook[ch]) for ch in text)
+
+@_task(4)
+def huffman_codes(frequencies):
+    """Построить оптимальный префиксный код по словарю символ:положительная_частота. Для единственного символа код '0'. Не учитывает дополнительно закреплённые кодовые слова. Пример: huffman_codes({'A':5,'B':2,'C':1})."""
+    heap = []; serial = 0
+    for symbol,freq in frequencies.items():
+        if freq <= 0: raise ValueError('Частоты должны быть положительными')
+        heapq.heappush(heap,(freq,serial,{symbol:''})); serial += 1
+    if not heap: return {}
+    if len(heap) == 1: return {next(iter(heap[0][2])):'0'}
+    while len(heap)>1:
+        fa,_,a=heapq.heappop(heap); fb,_,b=heapq.heappop(heap)
+        merged={**{k:'0'+v for k,v in a.items()}, **{k:'1'+v for k,v in b.items()}}
+        heapq.heappush(heap,(fa+fb,serial,merged)); serial+=1
+    return heap[0][2]
+
+@_task(5, 14)
+def to_base(n, base):
+    """Перевести неотрицательное целое в строку основания 2–36. Пример: to_base(31,16) == '1F'."""
+    if n < 0 or not 2 <= base <= 36: raise ValueError('Нужны n>=0 и основание 2–36')
+    alphabet='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'; result=''
+    while n:
+        n,r=divmod(n,base); result=alphabet[r]+result
+    return result or '0'
+
+@_task(5, 14)
+def from_base(text, base):
+    """Значение записи в основании 2–36; неизвестные цифры сначала замените. Пример: from_base('101',2) == 5."""
+    return int(text,base)
+
+@_task(14)
+def base_digits(n, base):
+    """Цифры неотрицательного числа списком, от старшей к младшей; допускает основания больше 36. Пример: base_digits(10,3) == [1,0,1]."""
+    if n < 0 or base < 2: raise ValueError('Нужны n>=0 и основание>=2')
+    digits=[]
+    while n: n,r=divmod(n,base); digits.append(r)
+    return digits[::-1] or [0]
+
+@_task(5)
+def binary_transform(n, transform):
+    """Передать двоичную запись n без '0b' в transform и прочитать полученную запись как двоичное число. Пример: binary_transform(5, lambda s:s+'0') == 10. Правило дописывания задаётся по условию."""
+    return int(transform(to_base(n,2)),2)
+
+@_task(5, 14, 15, 25)
+def search_values(values, predicate):
+    """Вернуть все элементы конечного values, удовлетворяющие predicate. Пример: search_values(range(100), lambda n:n%7==0). Диапазон нужно обосновать условием."""
+    return [v for v in values if predicate(v)]
+
+@_task(8)
+def words(alphabet, length):
+    """Ленивый перебор слов с повторениями в порядке заданного alphabet. Пример: list(words('АБ',2)) == ['АА','АБ','БА','ББ']."""
+    return (''.join(w) for w in product(alphabet, repeat=length))
+
+@_task(8)
+def count_words(alphabet, length, predicate=lambda w:True):
+    """Количество слов с повторениями, подходящих под predicate. O(|алфавит|**length). Пример: count_words('01',4,lambda w:w.count('1')==2) == 6."""
+    return sum(bool(predicate(w)) for w in words(alphabet,length))
+
+@_task(8)
+def word_rank(word, alphabet):
+    """Номер слова с 1 в полном списке слов той же длины с повторениями. Порядок задаёт alphabet; символы алфавита уникальны. Пример: word_rank('БА','АБ') == 3."""
+    if len(set(alphabet))!=len(alphabet) or not alphabet: raise ValueError('Нужен непустой алфавит без повторений')
+    rank=0
+    for ch in word: rank=rank*len(alphabet)+alphabet.index(ch)
+    return rank+1
+
+@_task(8)
+def word_at(rank, alphabet, length):
+    """Слово по номеру rank с 1; обратная к word_rank. Пример: word_at(3,'АБ',2) == 'БА'."""
+    if not alphabet or len(set(alphabet))!=len(alphabet) or length<0 or not 1<=rank<=len(alphabet)**length: raise ValueError('Некорректный номер/алфавит/длина')
+    rank-=1; result=[]
+    for _ in range(length): rank,r=divmod(rank,len(alphabet)); result.append(alphabet[r])
+    return ''.join(result[::-1])
+
+@_task(8)
+def unique_permutations(text):
+    """Ленивый перебор различных перестановок символов, включая повторяющиеся, без хранения всех перестановок. Пример: list(unique_permutations('ААБ'))."""
+    counts=Counter(text); chars=list(counts); prefix=[]
+    def generate():
+        if len(prefix)==len(text): yield ''.join(prefix); return
+        for ch in chars:
+            if counts[ch]:
+                counts[ch]-=1; prefix.append(ch)
+                yield from generate()
+                prefix.pop(); counts[ch]+=1
+    return generate()
+
+@_task(9)
+def row_profile(row):
+    """Сводка строки: сумма, min/max (None для пустой), частоты, повторённые и одиночные значения с учётом кратности. Пример: row_profile([1,2,2])['repeated'] == [2,2]."""
+    c=Counter(row)
+    return dict(total=sum(row), minimum=min(row,default=None), maximum=max(row,default=None), counts=dict(c), repeated=[x for x in row if c[x]>1], unique=[x for x in row if c[x]==1])
+
+@_task(9)
+def filter_rows(rows, predicate, start=1):
+    """Список (номер_строки, строка) по условию predicate(row). start задаёт первый номер. Пример: filter_rows([[1,2],[3,3]], lambda r:len(set(r))==1)."""
+    return [(i,row) for i,row in enumerate(rows,start) if predicate(row)]
+
+@_task(10)
+def docx_text(path):
+    """Извлечь текст основных абзацев и таблиц DOCX средствами stdlib, без форматирования; колонтитулы/сноски не включены. Пример: docx_text('book.docx'). Для старого DOC сначала сохраните DOCX."""
+    ns={'w':'http://schemas.openxmlformats.org/wordprocessingml/2006/main'}
+    with zipfile.ZipFile(path) as z: root=ET.fromstring(z.read('word/document.xml'))
+    return '\n'.join(''.join(t.text or '' for t in p.findall('.//w:t',ns)) for p in root.findall('.//w:p',ns))
+
+@_task(10, 24)
+def count_occurrences(text, pattern, whole_word=False, ignore_case=False, overlap=False):
+    """Количество вхождений буквальной строки; whole_word использует границы Unicode-слова, ignore_case игнорирует регистр, overlap разрешает пересечения. Пример: count_occurrences('ААА','АА',overlap=True) == 2. Дефисы и апострофы проверяйте по условию."""
+    if not pattern: raise ValueError('Пустой образец')
+    p=re.escape(pattern)
+    if whole_word: p=r'(?<!\w)'+p+r'(?!\w)'
+    if overlap: p='(?='+p+')'
+    return sum(1 for _ in re.finditer(p,text,re.I if ignore_case else 0))
+
+@_task(12)
+def rewrite(text, rules, condition=None, first_only=True, max_steps=100000):
+    """Исполнитель Редактор: rules — упорядоченные пары (что,на_что). first_only=True — за итерацию первое применимое правило (ЕСЛИ/ИНАЧЕ); False — все правила по порядку (несколько ЕСЛИ). Каждая замена меняет первое вхождение. condition(text) проверяет ПОКА. Пример: rewrite('1111',[('11','2')]) == '22'. Лимит вызывает RuntimeError."""
+    if any(not old for old,new in rules): raise ValueError('Пустая левая часть правила')
+    def running(s): return condition(s) if condition is not None else any(a in s for a,b in rules)
+    steps=0
+    while running(text):
+        if steps>=max_steps: raise RuntimeError('Превышен лимит итераций Редактора')
+        changed=False
+        for old,new in rules:
+            if old in text:
+                text=text.replace(old,new,1); changed=True
+                if first_only: break
+        steps+=1
+        if not changed: raise RuntimeError('Условие ПОКА истинно, но ни одно правило не применимо')
+    return text
+
+@_task(12)
+def turing(tape, transitions, state='q0', head=0, blank='_', halt=('halt',), max_steps=1000000):
+    """Симулятор машины Тьюринга. tape — строка или {индекс:символ}; transitions[(состояние,символ)]=(новый_символ,сдвиг,новое_состояние), сдвиг -1/0/1. Возвращает tape/head/state/steps. Пример: turing('1',{('q0','1'):('0',1,'halt')}). Отсутствие перехода — ошибка, не неявная остановка."""
+    cells=dict(enumerate(tape)) if isinstance(tape,str) else dict(tape)
+    steps=0
+    while state not in halt:
+        if steps>=max_steps: raise RuntimeError('Превышен лимит шагов МТ')
+        key=(state,cells.get(head,blank))
+        if key not in transitions: raise ValueError(f'Нет перехода {key!r}')
+        symbol,move,next_state=transitions[key]
+        if move not in (-1,0,1): raise ValueError('Сдвиг должен быть -1, 0 или 1')
+        if symbol==blank: cells.pop(head,None)
+        else: cells[head]=symbol
+        head+=move; state=next_state; steps+=1
+    return dict(tape=cells,head=head,state=state,steps=steps)
+
+@_task(13)
+def network_info(address, mask):
+    """Параметры IPv4-сети по адресу и маске (число бит или строка). hosts_count — обычные адреса без сети/ broadcast; для /31 и /32 соответствует ipaddress.hosts(). Пример: network_info('192.168.1.12',24)."""
+    net=ipaddress.IPv4Network(f'{address}/{mask}',strict=False)
+    return dict(network=str(net.network_address), broadcast=str(net.broadcast_address), mask=str(net.netmask), prefix=net.prefixlen, addresses=net.num_addresses, hosts_count=net.num_addresses-2 if net.prefixlen<31 else net.num_addresses)
+
+@_task(13)
+def count_ip(address, mask, predicate, include_edges=True, max_addresses=1<<20):
+    """Перебрать IPv4-адреса сети и проверить predicate(int_ip). include_edges=True включает сеть и broadcast. Пример: count_ip('192.168.1.0',24,lambda n:n.bit_count()%2==0). Ограничивает размер сети, чтобы случайно не перебирать миллиарды адресов."""
+    net=ipaddress.IPv4Network(f'{address}/{mask}',strict=False)
+    if net.num_addresses>max_addresses: raise ValueError('Сеть слишком большая для перебора; используйте комбинаторику')
+    return sum(bool(predicate(int(ip))) for ip in (net if include_edges else net.hosts()))
+
+@_task(13)
+def common_prefix(addresses):
+    """Максимальная общая длина префикса IPv4 для непустого списка адресов. Пример: common_prefix(['192.168.1.1','192.168.1.2']) == 30."""
+    a=[int(ipaddress.IPv4Address(x)) for x in addresses]
+    if not a: raise ValueError('Пустой список')
+    return 32-(min(a)^max(a)).bit_length()
+
+@_task(13)
+def ip_weight_counts(address, mask):
+    """Число всех адресов сети с каждым количеством единичных битов, без перебора. Сеть и broadcast включены. Пример: sum(ip_weight_counts('10.0.0.0',8).values()) == 2**24."""
+    from math import comb
+    net=ipaddress.IPv4Network(f'{address}/{mask}',strict=False)
+    fixed=int(net.network_address).bit_count(); free=32-net.prefixlen
+    return {fixed+k:comb(free,k) for k in range(free+1)}
+
+@_task(15)
+def valid_parameters(parameters, domain, predicate):
+    """Найти A, для которых predicate(A,x) истинно для ВСЕХ x из конечного domain. Для пары переменных domain задайте product(...), а x распакуйте. Пример: valid_parameters(range(10), range(5), lambda a,x:a>=x). Это проверка конечной области, не доказательство для всех целых/вещественных."""
+    domain=tuple(domain)
+    return [a for a in parameters if all(predicate(a,x) for x in domain)]
+
+@_task(15)
+def interval_contains(x, left, right, closed=True):
+    """Принадлежность закрытому [left,right] или открытому (left,right) интервалу. Пример: interval_contains(3,1,3) == True."""
+    return left<=x<=right if closed else left<x<right
+
+@_task(16)
+def recurrence_values(start, stop, initial, rule):
+    """Вычислить рекуррентную функцию снизу вверх на [start,stop]. initial — словарь базовых значений; rule(n,values) видит уже вычисленные значения. Пример: recurrence_values(2,5,{0:0,1:1},lambda n,f:f[n-1]+f[n-2])[5] == 5. Для обратных зависимостей измените направление в своём цикле."""
+    values=dict(initial)
+    for n in range(start,stop+1):
+        if n not in values: values[n]=rule(n,values)
+    return values
+
+@_task(16)
+def recursive_function(rule):
+    """Создать мемоизированную функцию f(n); rule(f,n) содержит базу и рекурсию. Пример: f=recursive_function(lambda f,n:1 if n<=1 else n*f(n-1)); f(5)==120. Для большой глубины используйте recurrence_values, лимит рекурсии не меняется."""
+    @lru_cache(None)
+    def f(n): return rule(f,n)
+    return f
+
+@_task(17)
+def adjacent_windows(data, width, predicate):
+    """Подходящие последовательные окна: список (индекс_с_0, кортеж_значений). Пример: adjacent_windows([1,2,3],2,lambda w:sum(w)>3). В отличие от всех пар берёт только соседние элементы."""
+    if width<1: raise ValueError('Нужна положительная ширина')
+    return [(i,tuple(data[i:i+width])) for i in range(len(data)-width+1) if predicate(tuple(data[i:i+width]))]
+
+@_task(17)
+def adjacent_summary(data, width, predicate, score=sum):
+    """Количество подходящих соседних окон и минимум/максимум score(window); None при отсутствии. Пример: adjacent_summary([1,2,3],2,lambda w:True) == {'count':2,'min':3,'max':5}."""
+    values=[score(w) for i,w in adjacent_windows(data,width,predicate)]
+    return dict(count=len(values),min=min(values,default=None),max=max(values,default=None))
+
+@_task(18)
+def grid_path_extremes(grid, moves=((1,0),(0,1)), blocked=None):
+    """Минимальная и максимальная сумма пути из верхней левой в нижнюю правую клетку, включая обе. None — стена. moves допускает только сдвиги вниз/вправо без (0,0). Возвращает (None,None), если пути нет. Пример: grid_path_extremes([[1,2],[3,4]]) == (7,8). Стены между клетками моделируйте отдельно графом."""
+    if not grid or not grid[0]: raise ValueError('Пустая таблица')
+    h=len(grid); w=len(grid[0])
+    if any(len(row)!=w for row in grid): raise ValueError('Нужна прямоугольная таблица')
+    if any(dr<0 or dc<0 or dr+dc==0 for dr,dc in moves): raise ValueError('Движения должны вести вниз/вправо')
+    low=[[inf]*w for _ in range(h)]; high=[[-inf]*w for _ in range(h)]
+    for r in range(h):
+        for c in range(w):
+            if grid[r][c]==blocked: continue
+            if r==c==0: low[r][c]=high[r][c]=grid[r][c]; continue
+            for dr,dc in moves:
+                pr,pc=r-dr,c-dc
+                if pr>=0 and pc>=0:
+                    low[r][c]=min(low[r][c],low[pr][pc]+grid[r][c])
+                    high[r][c]=max(high[r][c],high[pr][pc]+grid[r][c])
+    return (None,None) if low[-1][-1]==inf else (low[-1][-1],high[-1][-1])
+
+@_task(19, 20, 21)
+def game_solver(moves, terminal, max_plies):
+    """Функция оценки конечной игры с полной информацией, без ничьих. state — хешируемое состояние; moves(state) — ходы; terminal(state) — уже достигнутая цель. Метки W1/W2 — победа за 1/2 своих хода, L1/L2 — неизбежное поражение, '?' — глубины мало. max_plies — число полуходов; terminal получает 'L0'. Пример: g=game_solver(lambda s:(s+1,s*2),lambda s:s>=10,4); g(9)=='W1'. Для задач 19 с НЕУДАЧНЫМ первым ходом отдельно проверьте существование хода в W1."""
+    if max_plies<0: raise ValueError('Отрицательная глубина')
+    @lru_cache(None)
+    def solve(state,depth):
+        if terminal(state): return ('L',0)
+        if depth==0: return ('?',0)
+        children=[solve(s,depth-1) for s in moves(state)]
+        if not children: return ('L',0)
+        wins=[k+1 for mark,k in children if mark=='L']
+        if wins: return ('W',min(wins))
+        if all(mark=='W' for mark,k in children): return ('L',max(k for mark,k in children))
+        return ('?',0)
+    def result(state):
+        mark,k=solve(state,max_plies)
+        return '?' if mark=='?' else f'{mark}{k}'
+    return result
+
+@_task(22)
+def process_schedule(durations, dependencies, lag=0):
+    """Ранние start/finish процессов при неограниченном числе исполнителей. durations — {ID:длительность}, dependencies — {ID:[предшественники]}; лаг lag добавляется после зависимостей, не к корневым процессам. Возвращает starts, finishes, total. Циклы/неизвестные ID — ошибка. Пример: process_schedule({'A':3,'B':2},{'B':['A']})['total']==5. Для ограниченного числа процессоров нужен отдельный планировщик."""
+    if lag<0 or any(d<0 for d in durations.values()): raise ValueError('Отрицательная длительность/лаг')
+    active=set(); starts={}; finishes={}
+    def finish(u):
+        if u in finishes: return finishes[u]
+        if u not in durations: raise ValueError(f'Неизвестный процесс {u!r}')
+        if u in active: raise ValueError('Цикл зависимостей')
+        active.add(u); parents=dependencies.get(u,())
+        starts[u]=max((finish(p)+lag for p in parents),default=0)
+        finishes[u]=starts[u]+durations[u]; active.remove(u)
+        return finishes[u]
+    for u in durations: finish(u)
+    return dict(starts=starts,finishes=finishes,total=max(finishes.values(),default=0))
+
+@_task(22, 26)
+def peak_overlap(intervals):
+    """Максимум одновременно активных полуоткрытых интервалов [start,end), например процессов или посетителей. В момент окончания ресурс освобождается. Пример: peak_overlap([(0,3),(2,4),(3,5)]) == 2."""
+    events=defaultdict(int)
+    for a,b in intervals:
+        if b<a: raise ValueError('Конец раньше начала')
+        events[a]+=1; events[b]-=1
+    cur=best=0
+    for t in sorted(events): cur+=events[t]; best=max(best,cur)
+    return best
+
+@_task(23)
+def count_programs(start, finish, commands, allowed, max_states=100000):
+    """Число программ в конечном ациклическом пространстве состояний. commands — функции одного хода; allowed(state) ограничивает область и запреты. Разные команды с одинаковым результатом считаются разными программами. Строит граф и считает без глубокой рекурсии, обнаруживает циклы. Пример: count_programs(1,5,[lambda x:x+1,lambda x:x*2],lambda x:1<=x<=5) == 4."""
+    if not allowed(start) or not allowed(finish): return 0
+    graph={}; pending=[start]; seen={start}
+    while pending:
+        u=pending.pop()
+        graph[u]=[] if u==finish else [v for cmd in commands if allowed(v:=cmd(u))]
+        for v in graph[u]:
+            if v not in seen:
+                seen.add(v); pending.append(v)
+                if len(seen)>max_states: raise ValueError('Превышен лимит состояний')
+    indegree=dict.fromkeys(seen,0)
+    for edges in graph.values():
+        for v in edges: indegree[v]+=1
+    q=deque(u for u in seen if indegree[u]==0); count=dict.fromkeys(seen,0); count[start]=1; visited=0
+    while q:
+        u=q.popleft(); visited+=1
+        for v in graph[u]:
+            count[v]+=count[u]; indegree[v]-=1
+            if indegree[v]==0: q.append(v)
+    if visited!=len(seen): raise ValueError('В достижимых состояниях есть цикл')
+    return count.get(finish,0)
+
+@_task(23)
+def count_programs_via(start, finish, checkpoints, commands, allowed):
+    """Число программ с посещением checkpoints по порядку: произведение числа путей между контрольными точками. Применять только при строгой монотонности числовых состояний, чтобы промежуточный сегмент не пересёк будущую точку раньше срока. Пример: count_programs_via(1,5,[3],[lambda x:x+1],lambda x:1<=x<=5)==1."""
+    points=[start,*checkpoints,finish]
+    if not (all(a<b for a,b in zip(points,points[1:])) or all(a>b for a,b in zip(points,points[1:]))): raise ValueError('Нужны строго упорядоченные точки')
+    result=1
+    direction=1 if finish>start else -1
+    def checked(cmd):
+        def apply(x):
+            y=cmd(x)
+            if (y-x)*direction<=0: raise ValueError('Команды должны быть строго монотонны')
+            return y
+        return apply
+    commands=[checked(c) for c in commands]
+    for a,b in zip(points,points[1:]):
+        result*=count_programs(a,b,commands,lambda x,a=a,b=b: min(a,b)<=x<=max(a,b) and allowed(x))
+    return result
+
+@_task(24)
+def longest_run(text, allowed):
+    """Самая длинная непрерывная подстрока из символов allowed (множество или строка). Возвращает длину. Пример: longest_run('ABXAAA','AB') == 3."""
+    cur=best=0
+    for ch in text:
+        cur=cur+1 if ch in allowed else 0; best=max(best,cur)
+    return best
+
+@_task(24)
+def longest_adjacent(text, compatible):
+    """Максимальная длина подстроки, где каждая соседняя пара удовлетворяет compatible(a,b). O(n). Пример: longest_adjacent('AABAB',lambda a,b:a!=b) == 4."""
+    if not text: return 0
+    cur=best=1
+    for a,b in zip(text,text[1:]):
+        cur=cur+1 if compatible(a,b) else 1; best=max(best,cur)
+    return best
+
+@_task(24)
+def longest_at_most(text, predicate, k):
+    """Максимальная длина подстроки, содержащей не более k символов, удовлетворяющих predicate(ch). O(n). Пример: longest_at_most('ABACA',lambda c:c=='A',1)==3."""
+    if k<0: raise ValueError('k>=0')
+    left=count=best=0
+    for right,ch in enumerate(text):
+        count+=bool(predicate(ch))
+        while count>k: count-=bool(predicate(text[left])); left+=1
+        best=max(best,right-left+1)
+    return best
+
+@_task(24)
+def shortest_at_least(text, predicate, k):
+    """Минимальная длина подстроки с минимум k отмеченными символами, None если нет; k=0 даёт 0. O(n). Пример: shortest_at_least('ABACA',lambda c:c=='A',2)==3."""
+    if k<0: raise ValueError('k>=0')
+    if k==0: return 0
+    left=count=0; best=inf
+    for right,ch in enumerate(text):
+        count+=bool(predicate(ch))
+        while count>=k:
+            best=min(best,right-left+1); count-=bool(predicate(text[left])); left+=1
+    return None if best==inf else best
+
+@_task(24)
+def longest_exactly(text, predicate, k):
+    """Максимальная длина непустой подстроки ровно с k отмеченными символами; 0, если подходящей нет. O(n). Пример: longest_exactly('ABACA',lambda c:c=='A',2)==4."""
+    if k<0: raise ValueError('k>=0')
+    left=count=best=0
+    for right,ch in enumerate(text):
+        count+=bool(predicate(ch))
+        while count>k: count-=bool(predicate(text[left])); left+=1
+        if count==k: best=max(best,right-left+1)
+    return best
+
+@_task(24)
+def longest_distinct(text):
+    """Максимальная длина подстроки без повторяющихся символов, O(n). Пример: longest_distinct('ABCADE') == 5."""
+    last={}; left=best=0
+    for right,ch in enumerate(text):
+        left=max(left,last.get(ch,-1)+1); last[ch]=right; best=max(best,right-left+1)
+    return best
+
+@_task(10, 24)
+def regex_matches(text, pattern, overlap=False):
+    """Список (начало, конец_исключая, текст) совпадений регулярного выражения. overlap=True ищет и пересекающиеся совпадения через match в каждой позиции; на длинных строках это может быть O(n²). Пример: regex_matches('12+34 A','[0-9]+(?:[+*][0-9]+)*'). Регулярку и запрет ведущих нулей задавайте по условию."""
+    if overlap:
+        compiled=re.compile(pattern)
+        return [(i,m.end(),m.group()) for i in range(len(text)+1) if (m:=compiled.match(text,i)) is not None]
+    return [(m.start(),m.end(),m.group()) for m in re.finditer(pattern,text)]
+
+@_task(25)
+def is_prime(n):
+    """Проверка простоты целого числа пробными делителями до sqrt(n), O(sqrt(n)); n<2 не простое. Пример: is_prime(97) == True."""
+    if n<2: return False
+    if n%2==0: return n==2
+    return all(n%d for d in range(3,isqrt(n)+1,2))
+
+@_task(25)
+def divisors(n, proper=False):
+    """Все положительные делители положительного n по возрастанию. proper=True исключает 1 и само n (нетривиальные). Пример: divisors(12,True) == [2,3,4,6]."""
+    if n<1: raise ValueError('n должно быть положительным')
+    low=[]; high=[]
+    for d in range(1,isqrt(n)+1):
+        if n%d==0:
+            low.append(d)
+            if d*d!=n: high.append(n//d)
+    result=low+high[::-1]
+    return [d for d in result if d not in (1,n)] if proper else result
+
+@_task(25)
+def prime_factors(n):
+    """Простые множители с кратностями в словаре; n>=1. Пример: prime_factors(72) == {2:3,3:2}."""
+    if n<1: raise ValueError('n>=1')
+    result={}; d=2
+    while d*d<=n:
+        while n%d==0: result[d]=result.get(d,0)+1; n//=d
+        d=3 if d==2 else d+2
+    if n>1: result[n]=result.get(n,0)+1
+    return result
+
+@_task(25)
+def sieve(limit):
+    """Список простых чисел от 2 до limit включительно, решето Эратосфена. Память O(limit). Пример: sieve(10) == [2,3,5,7]."""
+    if limit<2: return []
+    flags=bytearray(b'\1')*(limit+1); flags[:2]=b'\0\0'
+    for d in range(2,isqrt(limit)+1):
+        if flags[d]: flags[d*d:limit+1:d]=b'\0'*((limit-d*d)//d+1)
+    return [i for i,b in enumerate(flags) if b]
+
+@_task(25)
+def mask_matches(n, mask):
+    """Соответствие неотрицательного числа десятичной маске: ? — ровно одна цифра, * — любая последовательность, включая пустую. Другие символы запрещены. Пример: mask_matches(12345,'1?3*') == True."""
+    if any(ch not in '0123456789?*' for ch in mask): raise ValueError('Допустимы только цифры, ? и *')
+    return n>=0 and fnmatch.fnmatchcase(str(n),mask)
+
+@_task(25)
+def masked_multiples(mask, divisor, limit, start=1):
+    """Пары (число,частное) для кратных положительному divisor в включительном [start,limit], подходящих маске. Перебор O(limit/divisor). Пример: masked_multiples('1*',7,100) == [(14,2)]. При малом делителе и огромной границе нужен другой перебор."""
+    if divisor<=0 or start<0: raise ValueError('divisor>0, start>=0')
+    first=((start+divisor-1)//divisor)*divisor
+    return [(n,n//divisor) for n in range(first,limit+1,divisor) if mask_matches(n,mask)]
+
+@_task(6)
+def turtle_vertices(commands, start=(0,0), heading=0):
+    """Математическая Черепаха без окна: commands — ('F',длина), ('L',градусы), ('R',градусы); heading=0 направлен вправо, 90 вверх. Возвращает вершины ломаной, включая старт. Пример: turtle_vertices([('F',3),('L',90),('F',4)]). Повторы заранее разверните умножением списка; перо/дуги не моделируются."""
+    from math import sin,cos,radians
+    x,y=start; points=[(x,y)]
+    for cmd,value in commands:
+        if cmd=='L': heading+=value
+        elif cmd=='R': heading-=value
+        elif cmd=='F':
+            x+=value*cos(radians(heading)); y+=value*sin(radians(heading)); points.append((x,y))
+        else: raise ValueError('Команда должна быть F/L/R')
+    return points
+
+@_task(6)
+def polygon_area(polygon):
+    """Площадь простого многоугольника по формуле Гаусса. Вершины идут по контуру; повтор последней первой необязателен. Для самопересечений вернёт модуль ориентированной площади, а не площадь закраски. Пример: polygon_area([(0,0),(3,0),(3,4)]) == 6."""
+    p=list(polygon)
+    return abs(sum(a[0]*b[1]-b[0]*a[1] for a,b in zip(p,p[1:]+p[:1])))/2
+
+@_task(6)
+def point_in_polygon(point, polygon, boundary=False, eps=1e-9):
+    """Проверить точку в простом многоугольнике методом луча; boundary включает контур. eps — допуск для вещественных координат. Пример: point_in_polygon((1,1),[(0,0),(3,0),(3,3),(0,3)]) == True."""
+    x,y=point; p=list(polygon); inside=False
+    for (ax,ay),(bx,by) in zip(p,p[1:]+p[:1]):
+        cross=(x-ax)*(by-ay)-(y-ay)*(bx-ax)
+        if abs(cross)<=eps and min(ax,bx)-eps<=x<=max(ax,bx)+eps and min(ay,by)-eps<=y<=max(ay,by)+eps: return boundary
+        if (ay>y)!=(by>y) and x<(bx-ax)*(y-ay)/(by-ay)+ax: inside=not inside
+    return inside
+
+@_task(6)
+def lattice_points(polygons, mode='intersection', boundary=False, max_candidates=2000000):
+    """Целочисленные точки внутри пересечения/объединения простых многоугольников, mode='intersection'/'union'. boundary включает границы. Возвращает координаты, не только количество. Перебор ограничен max_candidates. Пример: len(lattice_points([[(0,0),(3,0),(3,3),(0,3)]])) == 4."""
+    if mode not in ('intersection','union'): raise ValueError('Неизвестный mode')
+    if not polygons or any(len(p)<3 for p in polygons): raise ValueError('Нужны многоугольники')
+    vertices=[point for p in polygons for point in p]
+    xmin=ceil(min(x for x,y in vertices)-1e-9); xmax=floor(max(x for x,y in vertices)+1e-9)
+    ymin=ceil(min(y for x,y in vertices)-1e-9); ymax=floor(max(y for x,y in vertices)+1e-9)
+    if (xmax-xmin+1)*(ymax-ymin+1)>max_candidates: raise ValueError('Слишком большой перебор точек')
+    combine=all if mode=='intersection' else any
+    return [(x,y) for x in range(xmin,xmax+1) for y in range(ymin,ymax+1) if combine(point_in_polygon((x,y),p,boundary) for p in polygons)]
+
+@_task(6)
+def pick_interior(polygon):
+    """Количество строго внутренних решётчатых точек простого многоугольника с ЦЕЛЫМИ вершинами по теореме Пика. Быстро, без перебора. Самопересечения/дыры не поддерживаются. Пример: pick_interior([(0,0),(3,0),(3,3),(0,3)]) == 4."""
+    from math import gcd
+    p=list(polygon)
+    if len(p)>1 and p[-1]==p[0]: p.pop()
+    if len(p)<3 or any(int(x)!=x or int(y)!=y for x,y in p): raise ValueError('Нужны целые вершины')
+    edges=list(zip(p,p[1:]+p[:1]))
+    twice=abs(sum(int(a[0])*int(b[1])-int(b[0])*int(a[1]) for a,b in edges))
+    border=sum(gcd(abs(int(a[0]-b[0])),abs(int(a[1]-b[1]))) for a,b in edges)
+    return (twice-border+2)//2
+
+@_task(26)
+def archive_files(sizes, capacity):
+    """Архивирование: максимум файлов, затем максимальный размер одного из выбранных. Возвращает count, max_file, selected. Каждый размер/ёмкость неотрицательны. Пример: archive_files([2,3,8,9],12)['selected'] == [2,9]."""
+    if capacity<0 or any(s<0 for s in sizes): raise ValueError('Отрицательный размер')
+    a=sorted(sizes); total=0; k=0
+    while k<len(a) and total+a[k]<=capacity: total+=a[k]; k+=1
+    if not k: return dict(count=0,max_file=None,selected=[])
+    remaining=capacity-sum(a[:k-1]); largest=max(v for v in a[k-1:] if v<=remaining)
+    return dict(count=k,max_file=largest,selected=a[:k-1]+[largest])
+
+@_task(26)
+def select_intervals(intervals, gap=0):
+    """Максимальное количество непересекающихся интервалов одним исполнителем, жадно по окончанию. gap — пауза между работами. Пример: select_intervals([(0,2),(1,4),(2,3)]) == [(0,2),(2,3)]. Для максимальной прибыли используйте weighted_intervals."""
+    if gap<0 or any(b<a for a,b in intervals): raise ValueError('Некорректные интервалы/пауза')
+    result=[]; end=-inf
+    for a,b in sorted(intervals,key=lambda x:(x[1],x[0])):
+        if a>=end+gap: result.append((a,b)); end=b
+    return result
+
+@_task(26, 27)
+def weighted_intervals(jobs):
+    """Максимальная суммарная прибыль непересекающихся работ (start,end,profit), границы [start,end). Возвращает прибыль; O(n log n). Пример: weighted_intervals([(0,2,5),(1,3,9),(2,4,5)]) == 10."""
+    from bisect import bisect_right
+    a=sorted(jobs,key=lambda x:x[1]); ends=[b for s,b,w in a]; dp=[0]
+    for i,(s,b,w) in enumerate(a):
+        if b<s: raise ValueError('Конец раньше начала')
+        j=bisect_right(ends,s,0,i)
+        dp.append(max(dp[-1],dp[j]+w))
+    return dp[-1]
+
+@_task(26)
+def nested_boxes(sizes, gap):
+    """Максимальная цепочка одномерных коробок: разница соседних размеров >=gap>0. Возвращает размеры по возрастанию. Пример: nested_boxes([1,2,5,8],3)==[1,5,8]. Для многомерных коробок это правило неприменимо."""
+    if gap<=0: raise ValueError('gap>0')
+    chosen=[]
+    for size in sorted(sizes):
+        if not chosen or size-chosen[-1]>=gap: chosen.append(size)
+    return chosen
+
+@_task(26)
+def missing_seats(occupied, free_count=2):
+    """Найти ровно free_count свободных мест между соседними занятыми в одном ряду. occupied — пары (ряд,место); возвращает (ряд,первое_свободное) по убыванию ряда, затем возрастанию места. Пример: missing_seats([(5,2),(5,5)])==[(5,3)]."""
+    if free_count<1: raise ValueError('free_count>=1')
+    rows=defaultdict(set)
+    for row,seat in occupied: rows[row].add(seat)
+    result=[]
+    for row,seats in rows.items():
+        a=sorted(seats)
+        result.extend((row,x+1) for x,y in zip(a,a[1:]) if y-x-1==free_count)
+    return sorted(result,key=lambda x:(-x[0],x[1]))
+
+@_task(26, 27)
+def knapsack(weights, capacity):
+    """Максимальная достижимая сумма весов <=capacity, каждый предмет используется один раз. Битовая динамика, память O(capacity) бит. Пример: knapsack([3,5,8],10) == 8. Не возвращает состав набора."""
+    if capacity<0 or any(w<0 or int(w)!=w for w in weights): raise ValueError('Нужны неотрицательные целые веса и capacity')
+    bits=1; mask=(1<<(capacity+1))-1
+    for w in weights:
+        if w<=capacity: bits=(bits | bits<<w)&mask
+    return bits.bit_length()-1
+
+@_task(26)
+def service_queue(arrivals, servers, max_wait=None):
+    """FCFS-очередь к одинаковым серверам. arrivals — (приход,длительность); servers>=1. При ожидании >max_wait клиент уходит (None). Результат в исходном порядке: (номер_сервера_с_1,начало,конец) либо None. Пример: service_queue([(0,5),(1,2)],1)==[(1,0,5),(1,5,7)]. Для задач с выбором сервера по номеру/без ожидания правила надо изменить."""
+    if servers<1 or (max_wait is not None and max_wait<0): raise ValueError('Некорректные параметры')
+    heap=[(-inf,i+1) for i in range(servers)]; heapq.heapify(heap); result=[None]*len(arrivals)
+    for index,(arrival,duration) in sorted(enumerate(arrivals),key=lambda item:(item[1][0],item[0])):
+        if duration<0: raise ValueError('Отрицательная длительность')
+        available,server=heap[0]; start=max(arrival,available)
+        if max_wait is not None and start-arrival>max_wait: continue
+        heapq.heapreplace(heap,(start+duration,server)); result[index]=(server,start,start+duration)
+    return result
+
+@_task(27)
+def prefix_sums(data):
+    """Префиксные суммы с нулём в начале. Сумма data[l:r] равна p[r]-p[l]. Пример: prefix_sums([2,3,-1]) == [0,2,5,4]."""
+    p=[0]
+    for x in data: p.append(p[-1]+x)
+    return p
+
+@_task(27)
+def count_subarrays_mod(data, modulus, remainder=0):
+    """Количество непустых непрерывных подмассивов с нужным остатком суммы. O(n) времени, O(min(n,modulus)) памяти; отрицательные числа поддерживаются. Пример: count_subarrays_mod([1,2,3],3)==3."""
+    if modulus<1: raise ValueError('modulus>=1')
+    freq=Counter({0:1}); prefix=answer=0
+    for x in data:
+        prefix=(prefix+x)%modulus; answer+=freq[(prefix-remainder)%modulus]; freq[prefix]+=1
+    return answer
+
+@_task(27)
+def max_subarray_sum_mod(data, modulus, remainder=0):
+    """Максимальная сумма непустого подмассива с заданным остатком; None, если нет. O(n), работает с отрицательными. Пример: max_subarray_sum_mod([1,2,3],3)==6."""
+    if modulus<1: raise ValueError('modulus>=1')
+    minimum={0:0}; prefix=0; best=None
+    for x in data:
+        prefix+=x; r=prefix%modulus; previous=minimum.get((r-remainder)%modulus)
+        if previous is not None:
+            value=prefix-previous; best=value if best is None else max(best,value)
+        minimum[r]=min(minimum.get(r,inf),prefix)
+    return best
+
+@_task(27)
+def longest_subarray_sum_mod(data, modulus, remainder=0):
+    """Длина самого длинного подмассива с нужным остатком суммы, O(n). Возвращает 0 при отсутствии. Пример: longest_subarray_sum_mod([1,2,3],3)==3."""
+    if modulus<1: raise ValueError('modulus>=1')
+    first={0:0}; prefix=best=0
+    for i,x in enumerate(data,1):
+        prefix=(prefix+x)%modulus; r=(prefix-remainder)%modulus
+        if r in first: best=max(best,i-first[r])
+        first.setdefault(prefix,i)
+    return best
+
+@_task(17, 27)
+def count_pairs_mod(data, modulus, remainder=0, min_gap=1):
+    """Количество пар индексов i<j, j-i>=min_gap с нужным остатком суммы. min_gap=1 — любые разные элементы. O(n), отрицательные числа допустимы. Пример: count_pairs_mod([1,2,3,4],3)==2."""
+    if modulus<1 or min_gap<1: raise ValueError('modulus,min_gap>=1')
+    freq=Counter(); answer=0
+    for j,x in enumerate(data):
+        if j>=min_gap: freq[data[j-min_gap]%modulus]+=1
+        answer+=freq[(remainder-x)%modulus]
+    return answer
+
+@_task(27)
+def max_pair_sum_mod(data, modulus, remainder=0, min_gap=1):
+    """Максимальная сумма пары с условием на остаток и расстояние индексов; None при отсутствии. O(n), хранит максимумы по остаткам. Пример: max_pair_sum_mod([1,2,3,4],3)==6."""
+    if modulus<1 or min_gap<1: raise ValueError('modulus,min_gap>=1')
+    best_by={}; answer=None
+    for j,x in enumerate(data):
+        if j>=min_gap:
+            y=data[j-min_gap]; r=y%modulus; best_by[r]=max(best_by.get(r,-inf),y)
+        y=best_by.get((remainder-x)%modulus)
+        if y is not None: answer=x+y if answer is None else max(answer,x+y)
+    return answer
+
+@_task(27)
+def count_pairs_product(data, divisor, min_gap=1):
+    """Количество пар i<j с j-i>=min_gap и произведением, кратным divisor. Нули/отрицательные поддерживаются. O(n*tau(divisor)), хранит классы gcd. Пример: count_pairs_product([2,3,4],6)==2."""
+    from math import gcd
+    if divisor<1 or min_gap<1: raise ValueError('divisor,min_gap>=1')
+    counts=Counter(); answer=0
+    for j,x in enumerate(data):
+        if j>=min_gap: counts[gcd(data[j-min_gap],divisor)]+=1
+        g=gcd(x,divisor)
+        answer+=sum(c for d,c in counts.items() if d*g%divisor==0)
+    return answer
+
+@_task(27)
+def best_choice_mod(groups, modulus, remainder=0, maximize=True):
+    """Выбрать ровно одно число из каждой группы, оптимизируя сумму с нужным остатком. Динамика O(число_групп*modulus*размер_группы). Возвращает сумму или None. Пример: best_choice_mod([[1,2],[3,4]],3)==6. Для выбора двух из трёх передайте группы попарных сумм."""
+    if modulus<1: raise ValueError('modulus>=1')
+    dp={0:0}; better=max if maximize else min
+    for group in groups:
+        nxt={}
+        for total in dp.values():
+            for x in group:
+                value=total+x; r=value%modulus
+                nxt[r]=value if r not in nxt else better(nxt[r],value)
+        dp=nxt
+    return dp.get(remainder%modulus)
+
+@_task(27)
+def max_subarray(data):
+    """Максимальная сумма непустого подмассива (Кадане), O(n), O(1) памяти. None для пустого входа. Пример: max_subarray([-5,-2,-7]) == -2."""
+    best=cur=None
+    for x in data:
+        cur=x if cur is None else max(x,cur+x); best=cur if best is None else max(best,cur)
+    return best
+
+@_task(27)
+def min_window_sum_at_least(data, target):
+    """Минимальная длина непустого подмассива с суммой >=target для НЕОТРИЦАТЕЛЬНЫХ чисел. O(n), None если нет. Пример: min_window_sum_at_least([2,1,4,2],6)==2."""
+    if any(x<0 for x in data): raise ValueError('Нужны неотрицательные числа')
+    left=total=0; best=inf
+    for right,x in enumerate(data):
+        total+=x
+        while left<=right and total>=target:
+            best=min(best,right-left+1); total-=data[left]; left+=1
+    return None if best==inf else best
+
+@_task(27)
+def weighted_median(points):
+    """Взвешенная медиана на прямой для (координата,вес). Минимизирует сумму вес*расстояние. Возвращает (координата,стоимость), веса >=0 с положительной общей суммой. Пример: weighted_median([(0,1),(10,3)]) == (10,10)."""
+    a=sorted(points)
+    if not a or any(w<0 for x,w in a) or sum(w for x,w in a)<=0: raise ValueError('Нужны неотрицательные веса с положительной суммой')
+    total=sum(w for x,w in a); accumulated=0
+    for coordinate,weight in a:
+        accumulated+=weight
+        if accumulated*2>=total:
+            return coordinate,sum(w*abs(x-coordinate) for x,w in a)
+
+@_task(27)
+def circular_costs(weights):
+    """Стоимость пункта в каждой позиции равномерно размеченного кольца: sum(weights[j]*min(|i-j|,n-|i-j|)). O(n) через префиксы, n>=1. Пример: circular_costs([1,0,0,0]) == [0,1,2,1]. Умножьте на физический шаг между позициями."""
+    n=len(weights)
+    if not n: return []
+    a=list(weights)*3; p=prefix_sums(a); q=prefix_sums([i*w for i,w in enumerate(a)])
+    answer=[]; half=n//2
+    for i in range(n,2*n):
+        # Для чётного n противоположную точку относим к правой половине.
+        lo=i-(n-1)//2; hi=i+half
+        left=i*(p[i]-p[lo])-(q[i]-q[lo])
+        right=(q[hi+1]-q[i+1])-i*(p[hi+1]-p[i+1])
+        answer.append(left+right)
+    return answer
+
+@_task(27)
+def distance(a,b):
+    """Евклидово расстояние между двумя точками плоскости. Пример: distance((0,0),(3,4)) == 5."""
+    return hypot(a[0]-b[0],a[1]-b[1])
+
+@_task(27)
+def cluster_by_distance(points, threshold):
+    """Компоненты графа близости: точки связаны, если расстояние <=threshold; связь транзитивна. Это не k-means и не полный DBSCAN. Пространственная сетка ускоряет разреженные данные, худший случай O(n²). Возвращает список кластеров (координаты). Пример: cluster_by_distance([(0,0),(1,0),(9,0)],2). Порог выбирайте по условию/визуализации, цепочки могут объединить скопления."""
+    if threshold<=0: raise ValueError('threshold>0')
+    points=[tuple(p) for p in points]; buckets=defaultdict(list)
+    parent=list(range(len(points))); size=[1]*len(points)
+    def root(i):
+        while parent[i]!=i: parent[i]=parent[parent[i]]; i=parent[i]
+        return i
+    for i,(x,y) in enumerate(points):
+        cx,cy=floor(x/threshold),floor(y/threshold)
+        for dx,dy in product((-1,0,1), repeat=2):
+            for j in buckets.get((cx+dx,cy+dy),()):
+                if distance(points[i],points[j])<=threshold:
+                    u,v=root(i),root(j)
+                    if u!=v:
+                        if size[u]<size[v]: u,v=v,u
+                        parent[v]=u; size[u]+=size[v]
+        buckets[cx,cy].append(i)
+    groups=defaultdict(list)
+    for i,p in enumerate(points): groups[root(i)].append(p)
+    return list(groups.values())
+
+@_task(27)
+def kmeans(points, centers, max_steps=100, tolerance=1e-9):
+    """Разделение по ближайшему среднему с заданными начальными centers. Возвращает clusters, centers, converged. Может попасть в локальный минимум; не гарантирует кластеры из условия. Пустой кластер сохраняет свой центр. Пример: kmeans([(0,0),(1,0),(9,0)],[(0,0),(9,0)]). Для финального центра-медоида затем вызовите medoid."""
+    points=[tuple(p) for p in points]; centers=[tuple(c) for c in centers]
+    if not centers or max_steps<1: raise ValueError('Нужны центры и положительный лимит')
+    converged=False
+    for _ in range(max_steps):
+        groups=[[] for c in centers]
+        for p in points: groups[min(range(len(centers)),key=lambda i:distance(p,centers[i]))].append(p)
+        new=[centroid(g) if g else centers[i] for i,g in enumerate(groups)]
+        shift=max(distance(a,b) for a,b in zip(centers,new)); centers=new
+        if shift<=tolerance: converged=True; break
+    groups=[[] for c in centers]
+    for p in points: groups[min(range(len(centers)),key=lambda i:distance(p,centers[i]))].append(p)
+    return dict(clusters=groups,centers=centers,converged=converged)
+
+@_task(27)
+def centroid(points):
+    """Среднее арифметическое координат; обычно не совпадает с точкой исходного набора. Пример: centroid([(0,0),(2,4)]) == (1.0,2.0). Не заменяет медоид."""
+    if not points: raise ValueError('Пустой набор')
+    return sum(p[0] for p in points)/len(points),sum(p[1] for p in points)/len(points)
+
+@_task(27)
+def medoid(points):
+    """Точка набора с минимальной суммой евклидовых расстояний до остальных. Точный O(n²), O(n) памяти; при равенстве первая во входе. Пример: medoid([(0,0),(1,0),(10,0)]) == (1,0). На очень больших кластерах может работать долго."""
+    if not points: raise ValueError('Пустой набор')
+    points=[tuple(p) for p in points]; costs=[0.0]*len(points)
+    for i in range(len(points)):
+        for j in range(i):
+            d=distance(points[i],points[j]); costs[i]+=d; costs[j]+=d
+    return points[min(range(len(points)),key=costs.__getitem__)]
+
+@_task(27)
+def cluster_centers(clusters, method='medoid'):
+    """Центры непустых кластеров: method='medoid' или 'centroid'. Пример: cluster_centers([[(0,0),(1,0),(9,0)]]) == [(1,0)]. Выбирайте определение центра строго по условию."""
+    if method not in ('medoid','centroid'): raise ValueError('Неизвестный метод')
+    return [(medoid if method=='medoid' else centroid)(c) for c in clusters]
+
+@_task(27)
+def scaled_center_mean(centers, scale=10000, rounding='trunc'):
+    """Среднее координат центров, умноженное на scale. rounding='trunc' отбрасывает дробную часть к нулю, 'floor' округляет вниз, 'round' использует Python round. Пример: scaled_center_mean([(1,2),(3,4)]) == (20000,30000). Модуль/порядок координат задавайте по условию отдельно."""
+    x,y=centroid(centers)
+    if rounding not in ('trunc','floor','round'): raise ValueError('Неизвестное округление')
+    fn={'trunc':int,'floor':floor,'round':round}[rounding]
+    return fn(x*scale),fn(y*scale)
+
+@_task(27)
+def read_points(path, skip=1, decimal_comma=True, encoding='utf-8-sig'):
+    """Прочитать двумерные координаты из TXT, разделённые пробелами/табуляцией. skip=1 пропускает заголовок; decimal_comma заменяет десятичные запятые. Пример: read_points('27_A.txt'). При файле без заголовка задайте skip=0."""
+    text=read_text(path,encoding)
+    if decimal_comma: text=text.replace(',','.')
+    points=[tuple(map(float,line.split())) for line in text.splitlines()[skip:] if line.strip()]
+    if any(len(p)!=2 for p in points): raise ValueError('Нужны ровно две координаты в строке')
+    return points
+
+
+@_task(3, 9, 18, 22)
+def read_xlsx(path, sheet=0):
+    """Читать XLSX без внешних зависимостей: выбранный лист по индексу с 0, результат — строки значений. Числа преобразуются в int/float, пропуски в None. Читает сохранённые результаты формул, НЕ пересчитывает их; отсутствующий кеш формулы — ошибка. Пример: read_xlsx('9.xlsx'). Сложные типы/стили/даты не интерпретируются."""
+    ns={'m':'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}
+    relns='{http://schemas.openxmlformats.org/officeDocument/2006/relationships}'
+    with zipfile.ZipFile(path) as z:
+        workbook=ET.fromstring(z.read('xl/workbook.xml'))
+        sheets=workbook.findall('m:sheets/m:sheet',ns)
+        selected=sheets[sheet]; relid=selected.attrib[relns+'id']
+        rels=ET.fromstring(z.read('xl/_rels/workbook.xml.rels'))
+        target=next(r.attrib['Target'] for r in rels if r.attrib['Id']==relid)
+        import posixpath
+        target=target.lstrip('/') if target.startswith('/') else posixpath.normpath('xl/'+target)
+        shared=[]
+        if 'xl/sharedStrings.xml' in z.namelist():
+            shared=[''.join(t.text or '' for t in si.findall('.//m:t',ns)) for si in ET.fromstring(z.read('xl/sharedStrings.xml')).findall('m:si',ns)]
+        root=ET.fromstring(z.read(target)); rows=[]
+        for row in root.findall('m:sheetData/m:row',ns):
+            row_index=int(row.attrib['r'])-1
+            while len(rows)<=row_index: rows.append([])
+            for cell in row.findall('m:c',ns):
+                letters=re.match(r'[A-Z]+',cell.attrib['r']).group(); col=0
+                for ch in letters: col=col*26+ord(ch)-64
+                col-=1
+                while len(rows[row_index])<=col: rows[row_index].append(None)
+                kind=cell.attrib.get('t'); v=cell.find('m:v',ns)
+                if cell.find('m:f',ns) is not None and (v is None or v.text is None): raise ValueError('Формула без сохранённого результата; пересчитайте файл в табличном редакторе')
+                if kind=='inlineStr': value=''.join(t.text or '' for t in cell.findall('.//m:t',ns))
+                elif v is None or v.text is None: value=None
+                elif kind=='s': value=shared[int(v.text)]
+                elif kind=='b': value=bool(int(v.text))
+                elif kind in ('str','e','d'): value=v.text
+                else:
+                    value=float(v.text)
+                    if value.is_integer(): value=int(value)
+                rows[row_index][col]=value
+        return rows
+
+@_task(3, 9, 18, 22)
+def read_ods(path, sheet=0, max_cells=2000000):
+    """Читать непустую область листа ODS в строки значений, включая сохранённые результаты формул. Числа — int/float, пропуски — None. Не пересчитывает формулы; повторения пустых хвостовых строк/ячеек обрезает. Пример: read_ods('demo_22.ods'). Не поддерживает сложное форматирование/объединённые ячейки."""
+    t='{urn:oasis:names:tc:opendocument:xmlns:table:1.0}'
+    o='{urn:oasis:names:tc:opendocument:xmlns:office:1.0}'
+    textns='{urn:oasis:names:tc:opendocument:xmlns:text:1.0}'
+    with zipfile.ZipFile(path) as z: root=ET.fromstring(z.read('content.xml'))
+    tables=root.findall('.//'+o+'spreadsheet/'+t+'table'); table=tables[sheet]
+    result=[]; pending_rows=0; cells_used=0
+    for row in table.iter(t+'table-row'):
+        values=[]; pending_cells=0
+        for cell in row:
+            if cell.tag not in (t+'table-cell',t+'covered-table-cell'): continue
+            repeat=int(cell.get(t+'number-columns-repeated','1')); kind=cell.get(o+'value-type')
+            if kind in ('float','currency','percentage'):
+                value=float(cell.get(o+'value')); value=int(value) if value.is_integer() else value
+            elif kind=='boolean': value=cell.get(o+'boolean-value')=='true'
+            else:
+                value='\n'.join(''.join(p.itertext()) for p in cell.findall(textns+'p')) or None
+            if cell.get(t+'formula') and value is None: raise ValueError('Формула без сохранённого результата')
+            if value is None: pending_cells+=repeat
+            else:
+                if len(values)+pending_cells+repeat>max_cells: raise ValueError('Слишком много ячеек')
+                values.extend([None]*pending_cells); values.extend([value]*repeat); pending_cells=0
+        repeats=int(row.get(t+'number-rows-repeated','1'))
+        if not values: pending_rows+=repeats; continue
+        cells_used+=len(values)*repeats+pending_rows
+        if cells_used>max_cells: raise ValueError('Слишком много ячеек')
+        result.extend([[] for _ in range(pending_rows)]); pending_rows=0
+        result.extend([values.copy() for _ in range(repeats)])
+    return result
+
+@_task(22)
+def processes_from_rows(rows, skip=1):
+    """Преобразовать строки [ID,длительность,'предшественник;предшественник'] в durations/dependencies. '0'/0/None означает отсутствие зависимостей. Возвращает два словаря, ID — строки. Пример: processes_from_rows([['1',3,'0'],['2',4,'1']],skip=0)."""
+    durations={}; dependencies={}
+    for row in rows[skip:]:
+        if len(row)<3: continue
+        identifier=str(row[0]).strip()
+        if identifier in durations: raise ValueError('Повтор ID процесса')
+        durations[identifier]=int(row[1]); raw=str(row[2]).strip()
+        dependencies[identifier]=[] if raw in ('0','None','') else [x.strip() for x in raw.split(';')]
+    return durations,dependencies
+
+@_task(22)
+def active_processes(schedule, millisecond):
+    """ID процессов, исполняющихся на миллисекунде с номером millisecond, нумерация с 1. schedule — результат process_schedule с нулевым началом времени. Пример: active_processes(process_schedule({'A':3},{}),3)==['A']."""
+    if millisecond<1: raise ValueError('Миллисекунды нумеруются с 1')
+    t=millisecond-1
+    return [u for u in schedule['starts'] if schedule['starts'][u]<=t<schedule['finishes'][u]]
+
+@_task(23)
+def read_weighted_graph(path, skip=0, weight=float):
+    """Прочитать ориентированный граф из строк 'u v вес'; ID — int, weight можно заменить на Decimal для точной десятичной арифметики. Результат: {u:{v:вес}}. Пример: read_weighted_graph('23.txt'). Повторное ребро — ошибка."""
+    graph={}
+    for row in read_rows(path,cast=str,skip=skip):
+        if len(row)!=3: raise ValueError('Нужны три поля u v вес')
+        u,v=int(row[0]),int(row[1]); w=weight(row[2].replace(',','.'))
+        if v in graph.setdefault(u,{}): raise ValueError('Повторное ребро')
+        graph[u][v]=w; graph.setdefault(v,{})
+    return graph
+
+@_task(23)
+def dag_analysis(graph, start, finish):
+    """Для взвешенного DAG: число путей и min/max их длины; все вершины упорядочивает топологически, циклы — ошибка. O(V+E), без рекурсии; поддерживает отрицательные веса. Пример: dag_analysis({'A':{'B':2},'B':{}},'A','B') == {'count':1,'min':2,'max':2}."""
+    nodes=set(graph) | {v for edges in graph.values() for v in edges} | {start,finish}
+    indegree=dict.fromkeys(nodes,0)
+    for edges in graph.values():
+        for v in edges: indegree[v]+=1
+    q=deque(u for u in nodes if not indegree[u]); count=dict.fromkeys(nodes,0); count[start]=1
+    low=dict.fromkeys(nodes,inf); high=dict.fromkeys(nodes,-inf); low[start]=high[start]=0; visited=0
+    while q:
+        u=q.popleft(); visited+=1
+        for v,w in graph.get(u,{}).items():
+            if count[u]:
+                count[v]+=count[u]; low[v]=min(low[v],low[u]+w); high[v]=max(high[v],high[u]+w)
+            indegree[v]-=1
+            if indegree[v]==0: q.append(v)
+    if visited!=len(nodes): raise ValueError('Граф содержит цикл')
+    return dict(count=count[finish],min=None if low[finish]==inf else low[finish],max=None if high[finish]==-inf else high[finish])
+
+@_task(26)
+def backup_log(records, capacity, deadline='11:59:59'):
+    """Модель журнала сервера из демо-2027: records — (ЧЧ:ММ:СС,ID,объём). При переполнении до запроса копируется накопленное; финальный остаток не копируется. Возвращает top_client, backups, top_two_sum. Все передачи учитываются при выборе клиента, при равенстве берётся меньший ID. Копии суммируются только не позднее deadline. Пример: backup_log([('01:00:00',1,8),('02:00:00',2,4)],10)['top_two_sum']==8."""
+    if capacity<=0: raise ValueError('capacity>0')
+    totals=Counter(); backups=[]; used=0
+    for time,client,size in sorted(records,key=lambda r:r[0]):
+        if not 0<=size<=capacity: raise ValueError('Размер запроса вне ёмкости')
+        totals[client]+=size
+        if used+size>capacity:
+            backups.append((time,used)); used=0
+        used+=size
+    top=min(totals,key=lambda c:(-totals[c],c)) if totals else None
+    largest=heapq.nlargest(2,(size for time,size in backups if time<=deadline))
+    return dict(top_client=top,backups=backups,top_two_sum=sum(largest))
+
+@_task(27)
+def read_particles(path, skip=0):
+    """Читать частицы из строк x y vx vy mass type, десятичная запятая допустима. Возвращает словари полей, включая energy=mass*(vx²+vy²)/2. Пример: read_particles('27.txt'). Строки заголовка явно пропустите skip."""
+    result=[]
+    for row in read_rows(path,cast=str,skip=skip):
+        if len(row)!=6: raise ValueError('Нужно шесть полей частицы')
+        x,y,vx,vy,mass=(float(s.replace(',','.').replace('–','-').replace('−','-')) for s in row[:5])
+        if mass<0: raise ValueError('Отрицательная масса')
+        result.append(dict(x=x,y=y,vx=vx,vy=vy,mass=mass,type=row[5],energy=mass*(vx*vx+vy*vy)/2))
+    return result
+
+@_task(27)
+def cluster_by_span(items, key, max_span):
+    """Разбить по одномерному признаку key на МИНИМАЛЬНОЕ число кластеров с max(key)-min(key)<=max_span. Сортировка O(n log n), greedy от минимального значения. Это ограничение диаметра, не цепочка соседей. Пример: cluster_by_span([0,1,2,3],lambda x:x,2)==[[0,1,2],[3]]. Если требуется заданное K, проверьте число кластеров; произвольное разбиение на K не ищется."""
+    if max_span<0: raise ValueError('max_span>=0')
+    ordered=sorted(items,key=key); clusters=[]
+    for item in ordered:
+        if not clusters or key(item)-key(clusters[-1][0])>max_span: clusters.append([])
+        clusters[-1].append(item)
+    return clusters
+
+@_task(27)
+def median_item(items, key):
+    """Элемент, минимизирующий сумму абсолютных разностей одномерного признака; сортировка O(n log n). При нескольких оптимальных берёт нижнюю медиану. Пример: median_item([9,1,2],lambda x:x)==2. Для энергий: key=lambda p:p['energy']."""
+    if not items: raise ValueError('Пустой набор')
+    a=sorted(items,key=key)
+    return a[(len(a)-1)//2]
+
+@_task(27)
+def diameter(points):
+    """Наибольшее расстояние между двумя точками; 0 при менее чем двух точках. Точный полный перебор O(n²), подходит отфильтрованным небольшим наборам. Пример: diameter([(0,0),(3,4)])==5."""
+    return max((distance(a,b) for a,b in combinations(points,2)),default=0.0)
+
+# Соответствие номеров: базовая таблица — 2026; альтернативная — проект 2027.
+# Общие алгоритмы графов относятся к №1 и новому №23, а не IPv4 №13.
+CATALOG['shortest_paths']=(1,23)
+CATALOG['count_graph_paths']=(1,23)
+CATALOG_2027={name:tuple(tasks) for name,tasks in CATALOG.items()}
+for _name in ('network_info','count_ip','common_prefix','ip_weight_counts'):
+    CATALOG_2027[_name]=(10,)
+for _name in ('count_programs','count_programs_via'):
+    CATALOG_2027[_name]=(13,)
+for _name in ('docx_text',): CATALOG_2027[_name]=()
+CATALOG_2027['count_occurrences']=(24,)
+CATALOG_2027['regex_matches']=(24,)
+
+# Справочник функций по году экзамена.
+@_task(*range(1,28))
+def functions_for(task, year=2026):
+    """Имена функций для номера task (1–27) и year=2026 либо 2027 (проект ФИПИ). Пример: functions_for(10,2027) покажет функции для IPv4, functions_for(10,2026) — поиск в тексте. Смежные/исторические алгоритмы включены как дополнительные инструменты."""
+    if year not in (2026,2027) or task not in range(1,28): raise ValueError('Нужны task=1..27 и year=2026/2027')
+    catalog=CATALOG if year==2026 else CATALOG_2027
+    return sorted(name for name,tasks in catalog.items() if task in tasks)
+
+CATALOG_2027['functions_for']=tuple(range(1,28))
+
+__all__ = ['CATALOG','CATALOG_2027','__version__',*CATALOG]