| """65 independent domain algorithms used by the evaluator's reference projects.""" |
|
|
| from __future__ import annotations |
|
|
| import calendar |
| import collections |
| import csv |
| import datetime as dt |
| import decimal |
| import fnmatch |
| import hashlib |
| import heapq |
| import io |
| import itertools |
| import json |
| import math |
| import re |
| import statistics |
| import urllib.parse |
|
|
|
|
| def solve(name: str, x: dict): |
| return globals()["solve_" + name](x) |
|
|
|
|
| def solve_word_frequency(x): |
| words = re.findall(r"[a-z0-9]+", x["text"].lower()) |
| counts = collections.Counter(words) |
| return [ |
| {"word": w, "count": n} |
| for w, n in sorted(counts.items(), key=lambda p: (-p[1], p[0])) |
| ] |
|
|
|
|
| def solve_slug_registry(x): |
| used, out = set(), [] |
| for title in x["titles"]: |
| root = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-") or "item" |
| slug, i = root, 2 |
| while slug in used: |
| slug, i = f"{root}-{i}", i + 1 |
| used.add(slug) |
| out.append(slug) |
| return out |
|
|
|
|
| def solve_run_length(x): |
| return [[char, len(list(group))] for char, group in itertools.groupby(x["text"])] |
|
|
|
|
| def solve_bracket_audit(x): |
| stack = [] |
| for i, c in enumerate(x["text"]): |
| if c in "([{": |
| stack.append((c, i)) |
| elif c in ")]}": |
| if not stack or "([{".index(stack[-1][0]) != ")]}".index(c): |
| return {"balanced": False, "position": i} |
| stack.pop() |
| return {"balanced": not stack, "position": stack[-1][1] if stack else None} |
|
|
|
|
| def solve_text_wrap(x): |
| lines, line = [], "" |
| for word in x["text"].split(): |
| if line and len(line) + 1 + len(word) > x["width"]: |
| lines.append(line) |
| line = "" |
| line = line + " " + word if line else word |
| if line: |
| lines.append(line) |
| return lines |
|
|
|
|
| def solve_ngram_index(x): |
| tokens, n = x["tokens"], x["n"] |
| found = collections.defaultdict(list) |
| for i in range(len(tokens) - n + 1): |
| found[tuple(tokens[i : i + n])].append(i) |
| return [{"tokens": list(k), "positions": found[k]} for k in sorted(found)] |
|
|
|
|
| def solve_glob_filter(x): |
| return sorted({p for p in x["paths"] if fnmatch.fnmatchcase(p, x["pattern"])}) |
|
|
|
|
| def solve_edit_distance(x): |
| a, b = x["a"], x["b"] |
| row = list(range(len(b) + 1)) |
| for i, char in enumerate(a, 1): |
| nxt = [i] |
| for j, other in enumerate(b, 1): |
| nxt.append(min(nxt[-1] + 1, row[j] + 1, row[j - 1] + (char != other))) |
| row = nxt |
| return row[-1] |
|
|
|
|
| def solve_roman_codec(x): |
| n, out = x["number"], "" |
| for value, symbol in [ |
| (1000, "M"), |
| (900, "CM"), |
| (500, "D"), |
| (400, "CD"), |
| (100, "C"), |
| (90, "XC"), |
| (50, "L"), |
| (40, "XL"), |
| (10, "X"), |
| (9, "IX"), |
| (5, "V"), |
| (4, "IV"), |
| (1, "I"), |
| ]: |
| q, n = divmod(n, value) |
| out += symbol * q |
| return out |
|
|
|
|
| def solve_caesar_cipher(x): |
| out = "" |
| for c in x["text"]: |
| base = ord("a") if "a" <= c <= "z" else ord("A") if "A" <= c <= "Z" else None |
| out += chr((ord(c) - base + x["shift"]) % 26 + base) if base is not None else c |
| return out |
|
|
|
|
| def solve_csv_records(x): |
| rows = list(csv.reader(io.StringIO(x["csv"]))) |
| return [dict(zip(rows[0], row)) for row in rows[1:]] if rows else [] |
|
|
|
|
| def solve_record_query(x): |
| rows = [ |
| r for r in x["rows"] if all(k in r and r[k] == v for k, v in x["where"].items()) |
| ] |
| return [{k: r.get(k) for k in x["select"]} for r in rows] |
|
|
|
|
| def solve_inner_join(x): |
| return [ |
| {"left": a, "right": b} |
| for a in x["left"] |
| for b in x["right"] |
| if x["key"] in a and x["key"] in b and a[x["key"]] == b[x["key"]] |
| ] |
|
|
|
|
| def solve_group_totals(x): |
| groups = collections.defaultdict(list) |
| for row in x["rows"]: |
| groups[row[x["group"]]].append(row[x["value"]]) |
| return [ |
| {"key": k, "count": len(groups[k]), "sum": sum(groups[k])} |
| for k in sorted(groups) |
| ] |
|
|
|
|
| def solve_json_flatten(x): |
| out = {} |
|
|
| def walk(value, path): |
| if isinstance(value, dict) and value: |
| for k in sorted(value): |
| walk(value[k], path + "/" + k.replace("~", "~0").replace("/", "~1")) |
| elif isinstance(value, list) and value: |
| for i, child in enumerate(value): |
| walk(child, path + "/" + str(i)) |
| else: |
| out[path] = value |
|
|
| walk(x["value"], "") |
| return out |
|
|
|
|
| def solve_merge_patch(x): |
| def merge(target, patch): |
| if not isinstance(patch, dict): |
| return patch |
| out = dict(target) if isinstance(target, dict) else {} |
| for k, v in patch.items(): |
| if v is None: |
| out.pop(k, None) |
| else: |
| out[k] = merge(out.get(k), v) |
| return out |
|
|
| return merge(x["target"], x["patch"]) |
|
|
|
|
| def solve_json_pointer(x): |
| value = x["value"] |
| if x["pointer"] == "": |
| return {"found": True, "value": value} |
| try: |
| for token in x["pointer"][1:].split("/"): |
| token = token.replace("~1", "/").replace("~0", "~") |
| if isinstance(value, list): |
| if not re.fullmatch(r"0|[1-9][0-9]*", token): |
| raise KeyError(token) |
| value = value[int(token)] |
| elif isinstance(value, dict): |
| value = value[token] |
| else: |
| raise KeyError(token) |
| return {"found": True, "value": value} |
| except (KeyError, IndexError): |
| return {"found": False, "value": None} |
|
|
|
|
| def solve_dedupe_records(x): |
| seen, out = set(), [] |
| for row in x["rows"]: |
| key = json.dumps( |
| [row.get(k) for k in x["keys"]], sort_keys=True, separators=(",", ":") |
| ) |
| if key not in seen: |
| out.append(row) |
| seen.add(key) |
| return out |
|
|
|
|
| def solve_pivot_table(x): |
| cells = collections.defaultdict(int) |
| rows, cols = set(), set() |
| for item in x["rows"]: |
| r, c = item[x["row"]], item[x["column"]] |
| rows.add(r) |
| cols.add(c) |
| cells[r, c] += item[x["value"]] |
| rows, cols = sorted(rows), sorted(cols) |
| return { |
| "rows": rows, |
| "columns": cols, |
| "values": [[cells[r, c] for c in cols] for r in rows], |
| } |
|
|
|
|
| def solve_schema_check(x): |
| types = { |
| "string": lambda v: isinstance(v, str), |
| "integer": lambda v: type(v) is int, |
| "number": lambda v: type(v) in (int, float), |
| "boolean": lambda v: type(v) is bool, |
| "array": lambda v: isinstance(v, list), |
| "object": lambda v: isinstance(v, dict), |
| "null": lambda v: v is None, |
| } |
| errors = [] |
| for key in sorted(x["schema"]): |
| rule = x["schema"][key] |
| if key not in x["value"]: |
| if rule["required"]: |
| errors.append({"field": key, "error": "required"}) |
| elif not types[rule["type"]](x["value"][key]): |
| errors.append({"field": key, "error": "type"}) |
| return errors |
|
|
|
|
| def solve_interval_union(x): |
| out = [] |
| for start, end in sorted(x["intervals"]): |
| if out and start <= out[-1][1]: |
| out[-1][1] = max(end, out[-1][1]) |
| else: |
| out.append([start, end]) |
| return out |
|
|
|
|
| def solve_interval_gaps(x): |
| low, high = x["bounds"] |
| out, cursor = [], low |
| for a, b in solve_interval_union(x): |
| a, b = max(low, a), min(high, b) |
| if a > b: |
| continue |
| if a > cursor: |
| out.append([cursor, a]) |
| cursor = max(cursor, b) |
| if cursor < high: |
| out.append([cursor, high]) |
| return out |
|
|
|
|
| def solve_booking_peak(x): |
| events = collections.defaultdict(int) |
| for start, end in x["bookings"]: |
| if start < end: |
| events[start] += 1 |
| events[end] -= 1 |
| current = peak = 0 |
| at = None |
| for t, delta in sorted(events.items()): |
| current += delta |
| if current > peak: |
| peak, at = current, t |
| return {"peak": peak, "at": at} |
|
|
|
|
| def solve_business_days(x): |
| day, end = dt.date.fromisoformat(x["start"]), dt.date.fromisoformat(x["end"]) |
| holidays, out = set(x["holidays"]), [] |
| while day < end: |
| if day.weekday() < 5 and day.isoformat() not in holidays: |
| out.append(day.isoformat()) |
| day += dt.timedelta(days=1) |
| return out |
|
|
|
|
| def solve_calendar_month(x): |
| return calendar.Calendar(firstweekday=0).monthdayscalendar(x["year"], x["month"]) |
|
|
|
|
| def solve_moving_average(x): |
| return [ |
| sum(x["values"][i : i + x["window"]]) / x["window"] |
| for i in range(len(x["values"]) - x["window"] + 1) |
| ] |
|
|
|
|
| def solve_statistics(x): |
| values = x["values"] |
| if not values: |
| return { |
| "count": 0, |
| "min": None, |
| "max": None, |
| "mean": None, |
| "median": None, |
| "variance": None, |
| } |
| return { |
| "count": len(values), |
| "min": min(values), |
| "max": max(values), |
| "mean": statistics.mean(values), |
| "median": statistics.median(values), |
| "variance": statistics.pvariance(values), |
| } |
|
|
|
|
| def solve_histogram(x): |
| edges = x["edges"] |
| bins, under, over = [0] * (len(edges) - 1), 0, 0 |
| for v in x["values"]: |
| if v < edges[0]: |
| under += 1 |
| elif v >= edges[-1]: |
| over += 1 |
| else: |
| for i in range(len(bins)): |
| if edges[i] <= v < edges[i + 1]: |
| bins[i] += 1 |
| break |
| return {"counts": bins, "underflow": under, "overflow": over} |
|
|
|
|
| def solve_matrix_product(x): |
| return [ |
| [sum(a * b for a, b in zip(row, col)) for col in zip(*x["b"])] for row in x["a"] |
| ] |
|
|
|
|
| def solve_polynomial(x): |
| return [ |
| sum(c * value**i for i, c in enumerate(x["coefficients"])) |
| for value in x["points"] |
| ] |
|
|
|
|
| def solve_prime_factors(x): |
| n, out, factor = x["number"], [], 2 |
| while factor * factor <= n: |
| count = 0 |
| while n % factor == 0: |
| n //= factor |
| count += 1 |
| if count: |
| out.append([factor, count]) |
| factor += 1 |
| if n > 1: |
| out.append([n, 1]) |
| return out |
|
|
|
|
| def solve_base_convert(x): |
| chars = "0123456789abcdefghijklmnopqrstuvwxyz" |
| n = int(x["digits"], x["from_base"]) |
| sign, n = ("-" if n < 0 else ""), abs(n) |
| out = "" |
| while n: |
| n, rem = divmod(n, x["to_base"]) |
| out = chars[rem] + out |
| return sign + (out or "0") |
|
|
|
|
| def solve_money_split(x): |
| weights, amount = x["weights"], x["amount"] |
| total = sum(weights) |
| shares = [amount * w // total for w in weights] |
| order = sorted( |
| range(len(weights)), key=lambda i: (-(amount * weights[i] % total), i) |
| ) |
| for i in order[: amount - sum(shares)]: |
| shares[i] += 1 |
| return shares |
|
|
|
|
| def solve_invoice_total(x): |
| D = decimal.Decimal |
| subtotal = sum( |
| (D(item["price"]) * item["quantity"] for item in x["items"]), D(0) |
| ).quantize(D(".01"), rounding=decimal.ROUND_HALF_UP) |
| tax = (subtotal * D(x["tax_rate"])).quantize( |
| D(".01"), rounding=decimal.ROUND_HALF_UP |
| ) |
| return { |
| "subtotal": f"{subtotal:.2f}", |
| "tax": f"{tax:.2f}", |
| "total": f"{subtotal + tax:.2f}", |
| } |
|
|
|
|
| def solve_coin_change(x): |
| amount, coins = x["amount"], sorted(set(x["coins"])) |
| dp = [0] + [amount + 1] * amount |
| for n in range(1, amount + 1): |
| dp[n] = min([dp[n - c] + 1 for c in coins if c <= n] or [amount + 1]) |
| return None if dp[amount] > amount else dp[amount] |
|
|
|
|
| def graph(x, weighted=False, directed=True): |
| adj = {node: [] for node in x["nodes"]} |
| for edge in x["edges"]: |
| a, b = edge[:2] |
| adj[a].append((b, edge[2]) if weighted else b) |
| if not directed: |
| adj[b].append((a, edge[2]) if weighted else a) |
| return adj |
|
|
|
|
| def solve_graph_reach(x): |
| adj, found = graph(x), {x["start"]} |
| todo = [x["start"]] |
| while todo: |
| for node in adj[todo.pop()]: |
| if node not in found: |
| found.add(node) |
| todo.append(node) |
| return sorted(found) |
|
|
|
|
| def solve_shortest_path(x): |
| adj = graph(x, weighted=True) |
| distances = {x["start"]: 0} |
| queue = [(0, x["start"])] |
| while queue: |
| distance, node = heapq.heappop(queue) |
| if distances[node] != distance: |
| continue |
| for other, weight in adj[node]: |
| alt = distance + weight |
| if alt < distances.get(other, math.inf): |
| distances[other] = alt |
| heapq.heappush(queue, (alt, other)) |
| return {node: distances.get(node) for node in sorted(x["nodes"])} |
|
|
|
|
| def solve_topological_order(x): |
| adj, indegree = graph(x), dict.fromkeys(x["nodes"], 0) |
| for edges in adj.values(): |
| for node in edges: |
| indegree[node] += 1 |
| queue = [n for n in indegree if indegree[n] == 0] |
| heapq.heapify(queue) |
| out = [] |
| while queue: |
| node = heapq.heappop(queue) |
| out.append(node) |
| for other in adj[node]: |
| indegree[other] -= 1 |
| if indegree[other] == 0: |
| heapq.heappush(queue, other) |
| return out if len(out) == len(adj) else None |
|
|
|
|
| def solve_connected_components(x): |
| adj, seen, out = graph(x, directed=False), set(), [] |
| for node in sorted(adj): |
| if node in seen: |
| continue |
| group, todo = [], [node] |
| seen.add(node) |
| while todo: |
| n = todo.pop() |
| group.append(n) |
| for other in adj[n]: |
| if other not in seen: |
| seen.add(other) |
| todo.append(other) |
| out.append(sorted(group)) |
| return out |
|
|
|
|
| def solve_grid_route(x): |
| grid, start, end = x["grid"], tuple(x["start"]), tuple(x["end"]) |
| seen, queue = {start}, collections.deque([(start, 0)]) |
| if grid[start[0]][start[1]] == "#" or grid[end[0]][end[1]] == "#": |
| return None |
| while queue: |
| (r, c), distance = queue.popleft() |
| if (r, c) == end: |
| return distance |
| for nr, nc in [(r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)]: |
| if ( |
| 0 <= nr < len(grid) |
| and 0 <= nc < len(grid[0]) |
| and grid[nr][nc] != "#" |
| and (nr, nc) not in seen |
| ): |
| seen.add((nr, nc)) |
| queue.append(((nr, nc), distance + 1)) |
| return None |
|
|
|
|
| def solve_tree_outline(x): |
| children = collections.defaultdict(list) |
| for node in x["nodes"]: |
| children[node["parent"]].append(node["id"]) |
| out = [] |
|
|
| def walk(parent, depth): |
| for node in sorted(children[parent]): |
| out.append({"id": node, "depth": depth}) |
| walk(node, depth + 1) |
|
|
| walk(None, 0) |
| return out |
|
|
|
|
| def solve_dependency_build(x): |
| deps, out, active, done = x["dependencies"], [], set(), set() |
|
|
| def visit(node): |
| if node in active: |
| raise ValueError("cycle") |
| if node in done: |
| return |
| active.add(node) |
| for other in sorted(deps[node]): |
| visit(other) |
| active.remove(node) |
| done.add(node) |
| out.append(node) |
|
|
| try: |
| for target in sorted(set(x["targets"])): |
| visit(target) |
| except ValueError: |
| return None |
| return out |
|
|
|
|
| def solve_path_normalize(x): |
| out = [] |
| for path in x["paths"]: |
| parts = [] |
| for part in path.split("/"): |
| if part in ("", "."): |
| continue |
| if part == "..": |
| if parts: |
| parts.pop() |
| else: |
| parts.append(part) |
| out.append("/" + "/".join(parts)) |
| return out |
|
|
|
|
| def solve_url_query(x): |
| out = collections.defaultdict(list) |
| for k, v in urllib.parse.parse_qsl(x["query"], keep_blank_values=True): |
| out[k].append(v) |
| return dict(out) |
|
|
|
|
| def solve_version_sort(x): |
| def key(v): |
| core, _, pre = v.partition("-") |
| parts = tuple(map(int, core.split("."))) |
| ids = ( |
| tuple((0, int(p)) if p.isdigit() else (1, p) for p in pre.split(".")) |
| if pre |
| else () |
| ) |
| return parts, not bool(pre), ids |
|
|
| return sorted(x["versions"], key=key) |
|
|
|
|
| def solve_lru_trace(x): |
| cache, hits, misses = collections.OrderedDict(), 0, 0 |
| for key in x["accesses"]: |
| if key in cache: |
| hits += 1 |
| cache.move_to_end(key) |
| else: |
| misses += 1 |
| if x["capacity"]: |
| cache[key] = True |
| if len(cache) > x["capacity"]: |
| cache.popitem(last=False) |
| return {"hits": hits, "misses": misses, "keys": list(cache)} |
|
|
|
|
| def solve_rate_limit(x): |
| history, out = collections.defaultdict(collections.deque), [] |
| for event in x["events"]: |
| times = history[event["key"]] |
| while times and times[0] <= event["time"] - x["window"]: |
| times.popleft() |
| allowed = len(times) < x["limit"] |
| if allowed: |
| times.append(event["time"]) |
| out.append(allowed) |
| return out |
|
|
|
|
| def solve_priority_queue(x): |
| queue, out, seq = [], [], 0 |
| for event in x["events"]: |
| if event["op"] == "push": |
| heapq.heappush(queue, (event["priority"], seq, event["value"])) |
| seq += 1 |
| else: |
| out.append(heapq.heappop(queue)[2] if queue else None) |
| return {"popped": out, "remaining": [v for _, _, v in sorted(queue)]} |
|
|
|
|
| def solve_round_robin(x): |
| quantum = x["quantum"] |
| queue = collections.deque((job["id"], job["duration"]) for job in x["jobs"]) |
| clock, slices, completion = 0, [], {} |
| while queue: |
| key, left = queue.popleft() |
| used = min(quantum, left) |
| slices.append({"id": key, "start": clock, "end": clock + used}) |
| clock += used |
| if left > used: |
| queue.append((key, left - used)) |
| else: |
| completion[key] = clock |
| return {"slices": slices, "completion": completion} |
|
|
|
|
| def solve_inventory_ledger(x): |
| stock, rejected = {}, [] |
| for i, event in enumerate(x["events"]): |
| new = stock.get(event["sku"], 0) + event["delta"] |
| if new < 0: |
| rejected.append(i) |
| else: |
| stock[event["sku"]] = new |
| return {"stock": stock, "rejected": rejected} |
|
|
|
|
| def solve_bank_ledger(x): |
| balances, rejected = dict(x["balances"]), [] |
| for i, t in enumerate(x["transfers"]): |
| if ( |
| t["from"] not in balances |
| or t["to"] not in balances |
| or balances[t["from"]] < t["amount"] |
| ): |
| rejected.append(i) |
| else: |
| balances[t["from"]] -= t["amount"] |
| balances[t["to"]] += t["amount"] |
| return {"balances": balances, "rejected": rejected} |
|
|
|
|
| def solve_ballot_count(x): |
| counts = dict.fromkeys(x["candidates"], 0) |
| invalid = 0 |
| for vote in x["votes"]: |
| if vote in counts: |
| counts[vote] += 1 |
| else: |
| invalid += 1 |
| return { |
| "ranking": [ |
| {"candidate": c, "votes": n} |
| for c, n in sorted(counts.items(), key=lambda p: (-p[1], p[0])) |
| ], |
| "invalid": invalid, |
| } |
|
|
|
|
| def solve_search_rank(x): |
| terms = set(re.findall(r"[a-z0-9]+", x["query"].lower())) |
| scored = [] |
| for doc in x["documents"]: |
| counts = collections.Counter(re.findall(r"[a-z0-9]+", doc["text"].lower())) |
| score = sum(counts[t] for t in terms) |
| if score: |
| scored.append({"id": doc["id"], "score": score}) |
| return sorted(scored, key=lambda r: (-r["score"], r["id"])) |
|
|
|
|
| def solve_log_summary(x): |
| counts = collections.Counter(event["level"] for event in x["events"]) |
| errors = [e["message"] for e in x["events"] if e["level"] == "ERROR"] |
| return {"counts": dict(counts), "errors": errors} |
|
|
|
|
| def solve_uptime_report(x): |
| intervals = solve_interval_union( |
| { |
| "intervals": [ |
| [max(a, x["start"]), min(b, x["end"])] |
| for a, b in x["downtime"] |
| if max(a, x["start"]) < min(b, x["end"]) |
| ] |
| } |
| ) |
| down = sum(b - a for a, b in intervals) |
| return {"down": down, "up": x["end"] - x["start"] - down} |
|
|
|
|
| def solve_segment_intersection(x): |
| a, b, c, d = x["a"], x["b"], x["c"], x["d"] |
|
|
| def cross(p, q, r): |
| return (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]) |
|
|
| def on(p, q, r): |
| return ( |
| cross(p, q, r) == 0 |
| and min(p[0], q[0]) <= r[0] <= max(p[0], q[0]) |
| and min(p[1], q[1]) <= r[1] <= max(p[1], q[1]) |
| ) |
|
|
| u, v, w, z = cross(a, b, c), cross(a, b, d), cross(c, d, a), cross(c, d, b) |
| return ( |
| (u * v < 0 and w * z < 0) |
| or on(a, b, c) |
| or on(a, b, d) |
| or on(c, d, a) |
| or on(c, d, b) |
| ) |
|
|
|
|
| def solve_polygon_area(x): |
| pts = x["points"] |
| return ( |
| abs(sum(a[0] * b[1] - a[1] * b[0] for a, b in zip(pts, pts[1:] + pts[:1]))) / 2 |
| if pts |
| else 0 |
| ) |
|
|
|
|
| def solve_skyline(x): |
| buildings = x["buildings"] |
| points, prev = [], 0 |
| for t in sorted({v for a, b, _ in buildings for v in (a, b)}): |
| height = max([h for a, b, h in buildings if a <= t < b] or [0]) |
| if height != prev: |
| points.append([t, height]) |
| prev = height |
| return points |
|
|
|
|
| def solve_knapsack(x): |
| capacity = x["capacity"] |
| dp = [0] * (capacity + 1) |
| for item in x["items"]: |
| for w in range(capacity, item["weight"] - 1, -1): |
| dp[w] = max(dp[w], dp[w - item["weight"]] + item["value"]) |
| return dp[capacity] |
|
|
|
|
| def solve_task_selection(x): |
| end, out = None, [] |
| for job in sorted(x["tasks"], key=lambda j: (j["end"], j["start"], j["id"])): |
| if end is None or job["start"] >= end: |
| out.append(job["id"]) |
| end = job["end"] |
| return out |
|
|
|
|
| def solve_sequence_diff(x): |
| a, b = x["a"], x["b"] |
| dp = [[0] * (len(b) + 1) for _ in range(len(a) + 1)] |
| for i in range(len(a) - 1, -1, -1): |
| for j in range(len(b) - 1, -1, -1): |
| dp[i][j] = ( |
| 1 + dp[i + 1][j + 1] |
| if a[i] == b[j] |
| else max(dp[i + 1][j], dp[i][j + 1]) |
| ) |
| i = j = 0 |
| out = [] |
| while i < len(a) or j < len(b): |
| if i < len(a) and j < len(b) and a[i] == b[j]: |
| out.append(["keep", a[i]]) |
| i, j = i + 1, j + 1 |
| elif i < len(a) and (j == len(b) or dp[i + 1][j] >= dp[i][j + 1]): |
| out.append(["delete", a[i]]) |
| i += 1 |
| else: |
| out.append(["insert", b[j]]) |
| j += 1 |
| return out |
|
|
|
|
| def solve_finite_automaton(x): |
| transitions = {(t["from"], t["symbol"]): t["to"] for t in x["transitions"]} |
| out = [] |
| for word in x["words"]: |
| state = x["start"] |
| for symbol in word: |
| state = transitions.get((state, symbol)) |
| if state is None: |
| break |
| out.append(state in x["accepting"]) |
| return out |
|
|
|
|
| def solve_content_manifest(x): |
| return [ |
| { |
| "path": path, |
| "bytes": len(text.encode("utf-8")), |
| "sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(), |
| } |
| for path, text in sorted(x["files"].items()) |
| ] |
|
|
|
|
| def solve_cellular_automaton(x): |
| cells = {tuple(p) for p in x["live"]} |
| for _ in range(x["steps"]): |
| neighbors = collections.Counter( |
| (r + dr, c + dc) |
| for r, c in cells |
| for dr in (-1, 0, 1) |
| for dc in (-1, 0, 1) |
| if (dr, dc) != (0, 0) |
| ) |
| cells = {p for p, n in neighbors.items() if n == 3 or n == 2 and p in cells} |
| return [list(p) for p in sorted(cells)] |
|
|
|
|
| def solve_expression_eval(x): |
| stack = [] |
| for token in x["tokens"]: |
| if token not in ("+", "-", "*", "/"): |
| stack.append(int(token)) |
| else: |
| b, a = stack.pop(), stack.pop() |
| if token == "+": |
| stack.append(a + b) |
| elif token == "-": |
| stack.append(a - b) |
| elif token == "*": |
| stack.append(a * b) |
| else: |
| stack.append((abs(a) // abs(b)) * (-1 if (a < 0) != (b < 0) else 1)) |
| return stack[0] |
|
|
