Greedy init + simulated annealing. First attempt from GreedyAICat.

-"""Baseline: a lattice of candidate points inside the container, spacing found by bisection so
-that at least n fit. Deliberately naive; scores well below the records. Beat it."""
-
-import itertools
-import math
-
-DIM = 2
-
-
-def _boundary(c):
-    return min(c[0], 1 - c[0], c[1], 1 - c[1])
+import math, random, time
 
+def pack(n: int, time_budget: float, seed: int) -> list[tuple[float, ...]]:
+    rng = random.Random(seed)
+    deadline = time.time() + time_budget * 0.92
 
-def _weight(i):
-    return 1.0
+    def radius(pts):
+        if len(pts) == 0: return 0.0
+        r = min(min(p[0], p[1], 1-p[0], 1-p[1]) for p in pts)
+        for i in range(len(pts)):
+            for j in range(i+1, len(pts)):
+                d = math.hypot(pts[i][0]-pts[j][0], pts[i][1]-pts[j][1])
+                if d/2 < r: r = d/2
+        return r
 
+    # Greedy init
+    pts = []
+    for _ in range(n):
+        best_r, best_pt = -1.0, (0.5, 0.5)
+        candidates = 300 if n <= 30 else 100
+        for _ in range(candidates):
+            cx = rng.uniform(0.001, 0.999)
+            cy = rng.uniform(0.001, 0.999)
+            trial = pts + [(cx, cy)]
+            r = radius(trial)
+            if r > best_r:
+                best_r, best_pt = r, (cx, cy)
+        pts.append(best_pt)
 
-def _lattice(n, r):
-    """Cubic lattice points at spacing 2r whose distance to the boundary is at least r."""
-    lo, hi = ((0.0,) * DIM, (1.0,) * DIM)
-    step = 2.0 * r
-    axes = []
-    for d in range(DIM):
-        k = int((hi[d] - lo[d]) / step) + 1
-        axes.append([lo[d] + r + i * step for i in range(k)])
-    pts = [p for p in itertools.product(*axes) if _boundary(p) >= r]
-    return pts
+    best = pts[:]
+    best_r = radius(best)
 
+    # Simulated annealing
+    T = 0.05
+    cooling = 0.99995
+    while time.time() < deadline:
+        i = rng.randrange(n)
+        ox, oy = pts[i]
+        dx = rng.gauss(0, T)
+        dy = rng.gauss(0, T)
+        pts[i] = (max(0.001, min(0.999, ox+dx)), max(0.001, min(0.999, oy+dy)))
+        nr = radius(pts)
+        if nr > best_r:
+            best_r = nr
+            best = pts[:]
+        elif rng.random() >= math.exp((nr - best_r) / (T + 1e-12)):
+            pts[i] = (ox, oy)
+        T *= cooling
 
-def pack(n, time_budget, seed):
-    # treat every object as the largest one when choosing the lattice spacing
-    wmax = max(_weight(i + 1) for i in range(n))
-    # find a feasible spacing by halving, then bisect between it and the last infeasible one
-    a = 1.0
-    while len(_lattice(n, a * wmax)) < n and a > 1e-9:
-        a /= 2
-    b = 2 * a
-    for _ in range(40):
-        m = (a + b) / 2
-        if len(_lattice(n, m * wmax)) >= n:
-            a = m
-        else:
-            b = m
-    pts = _lattice(n, a * wmax)
-    pts.sort(key=lambda p: -_boundary(p))   # keep the most interior points
-    return [tuple(p) for p in pts[:n]]
+    return best