Seven games in 21 days: who plays when?

import csv
import glob
from datetime import datetime
from itertools import combinations, product

import numpy as np
from scipy.optimize import Bounds, LinearConstraint, milp

# Made up: seven games in 21 days, each with a weight for how much it matters.
games = ["League", "League", "Cup semi", "League", "Europe", "League v bottom", "League"]
weight = [1.0, 1.0, 2.0, 1.0, 1.5, 0.7, 1.0]
# Made up: a squad by position, with each player's value in goal difference per game; 4-4-2 every game.
squad = {"DEF": [("D1", 0.20), ("D2", 0.15), ("D3", 0.12), ("D4", 0.10), ("D5", 0.06), ("D6", 0.03)],
         "MID": [("M1", 0.25), ("M2", 0.18), ("M3", 0.12), ("M4", 0.08), ("M5", 0.04), ("M6", 0.02)],
         "FWD": [("F1", 0.30), ("F2", 0.15), ("F3", 0.06)]}
needed = {"DEF": 4, "MID": 4, "FWD": 2}
REST = 3   # rest rule: nobody starts all of any 3 games in a row
G = len(games)
players = [(pos, name, v) for pos, group in squad.items() for name, v in group]


def value(plan):
    """Weighted goal difference across the run: each game's weight times the value of the players who start it."""
    return sum(weight[g] * v for g in range(G) for (pos, name, v) in players if name in plan[g])


def rested_ok(starts):
    return all(sum(starts[g:g + REST]) < REST for g in range(G - REST + 1))


# 1. The best team every game, until the rest rule stops someone.
greedy, history = [], {name: [] for _, name, _ in players}
for g in range(G):
    pick = set()
    for pos, group in squad.items():
        free = [n for n, v in group if sum(history[n][-(REST - 1):]) < REST - 1]   # not started the last two
        pick |= set(free[:needed[pos]])
    for _, name, _ in players:
        history[name].append(int(name in pick))
    greedy.append(pick)

# 2. The optimiser: one yes-or-no for each player in each game, solved as an integer program.
n = len(players) * G
idx = lambda p, g: p * G + g
c = np.zeros(n)
for p, (_, _, v) in enumerate(players):
    for g in range(G):
        c[idx(p, g)] = -weight[g] * v                       # milp minimises, so flip the sign
rows, lo, hi = [], [], []
for g in range(G):                                           # each position filled in each game
    for pos in squad:
        row = np.zeros(n)
        for p, (ppos, _, _) in enumerate(players):
            row[idx(p, g)] = ppos == pos
        rows.append(row); lo.append(needed[pos]); hi.append(needed[pos])
for p in range(len(players)):                                # the rest rule, for every player and every window
    for g in range(G - REST + 1):
        row = np.zeros(n)
        row[[idx(p, k) for k in range(g, g + REST)]] = 1
        rows.append(row); lo.append(0); hi.append(REST - 1)
res = milp(c, integrality=np.ones(n), bounds=Bounds(0, 1), constraints=LinearConstraint(np.array(rows), lo, hi))
best = [{name for p, (_, name, _) in enumerate(players) if res.x[idx(p, g)] > 0.5} for g in range(G)]

no_rule = sum(weight[g] for g in range(G)) * sum(sum(v for _, v in group[:needed[pos]]) for pos, group in squad.items())
print(f"Without a rest rule (impossible): {no_rule:.2f}")
print(f"Best team every game until rested: {value(greedy):.2f}")
print(f"Optimiser: {value(best):.2f}")
print("\nWho the optimiser rests (stars = the best player in each position):")
for name in ["D1", "M1", "F1"]:
    print(f"  {name} rested for: {', '.join(games[g] for g in range(G) if name not in best[g])}")
for name in ["D1", "M1", "F1"]:
    print(f"  Greedy rests {name} for: {', '.join(games[g] for g in range(G) if name not in greedy[g])}")

# A check on the strikers alone, where every rota can be tried: 3 ways to pick 2 of 3, for 7 games.
fwd = squad["FWD"]
options = [set(c) for c in combinations([n for n, _ in fwd], 2)]
brute = max((rota for rota in product(options, repeat=G)
             if all(rested_ok([int(name in rota[g]) for g in range(G)]) for name, _ in fwd)),
            key=lambda rota: sum(weight[g] * v for g in range(G) for name, v in fwd if name in rota[g]))
fwd_value = lambda rota: sum(weight[g] * v for g in range(G) for name, v in fwd if name in rota[g])
print(f"\nStrikers only: {3 ** G:,} rotas tried, best {fwd_value(brute):.2f}; "
      f"the optimiser's strikers {fwd_value([b & {'F1', 'F2', 'F3'} for b in best]):.2f}")

# Real: how often a Premiership side's league game came three days or fewer after its last one.
# Needs the SC0 files from football-data.co.uk for 2000/01 to 2025/26 (see above).
when = lambda d: datetime.strptime(d, "%d/%m/%Y" if len(d) == 10 else "%d/%m/%y")
short = gaps = 0
for path in sorted(glob.glob("SC0_*.csv")):
    dates = {}
    with open(path, encoding="latin-1") as f:
        for r in csv.DictReader(f):
            if r.get("FTR") in ("H", "D", "A"):
                for team in (r["HomeTeam"], r["AwayTeam"]):
                    dates.setdefault(team, []).append(when(r["Date"]))
    for ds in dates.values():
        ds.sort()
        gaps += len(ds) - 1
        short += sum((b - a).days <= 3 for a, b in zip(ds, ds[1:]))
print(f"\nLeague games three days or fewer after the last, 2000/01 to 2025/26: {short:,} of {gaps:,} ({short / gaps:.1%})")

Without a rest rule (impossible): 13.53
Best team every game until rested: 9.64
Optimiser: 10.38

Who the optimiser rests (stars = the best player in each position):
  D1 rested for: League, Europe
  M1 rested for: League, Europe
  F1 rested for: League, Europe
  Greedy rests D1 for: Cup semi, League v bottom
  Greedy rests M1 for: Cup semi, League v bottom
  Greedy rests F1 for: Cup semi, League v bottom

Strikers only: 2,187 rotas tried, best 2.85; the optimiser's strikers 2.85

League games three days or fewer after the last, 2000/01 to 2025/26: 1,473 of 11,446 (12.9%)