Re: Jour 8

J'aurai bien traine aussi ce soir pour plier le bouzin, en partie pour cause de boulettes a traquer, puis pour polish ensuite et reiterer sur la partie boulette.
Au final, rien de bien original (mais promis, j'ai pas copie):

from __future__ import annotations
from functools import reduce
from itertools import combinations, count
from operator import mul
from typing import NamedTuple
class SpaceCoord(NamedTuple):
 x: int
 y: int
 z: int
 def square_distance(self, other: SpaceCoord) -> int:
 return pow(other.x - self.x, 2) + pow(other.y - self.y, 2) + pow(other.z - self.z, 2)
 @classmethod
 def from_data(cls, data: str) -> SpaceCoord:
 return cls(*map(int, data.split(',')))
class Junction:
 def __init__(self, data: list[str]) -> None:
 self.boxes = [SpaceCoord.from_data(line) for line in data]
 self.ordered_pairs = sorted(combinations(self.boxes, 2), key=lambda t: t[0].square_distance(t[1]))
 def _join(self, steps: int|None = None) -> tuple[list[int],tuple[SpaceCoord,SpaceCoord]]:
 groups: list[list[SpaceCoord]] = []
 length = len(self.boxes)
 def in_group(box: SpaceCoord) -> int|None:
 for i, g in enumerate(groups):
 if box in g:
 return i
 return None
 for i in count():
 b1, b2 = self.ordered_pairs[i]
 g1 = in_group(b1)
 g2 = in_group(b2)
 match g1, g2:
 case None, None:
 groups.append([b1, b2])
 case None, int():
 groups[g2].append(b1)
 case int(), None:
 groups[g1].append(b2)
 case _:
 if g2 != g1:
 groups[g1] += groups[g2]
 groups.remove(groups[g2])
 if steps and i == steps -1:
 break
 elif len(groups) == 1 and len(groups[0]) == length:
 break
 return ([len(g) for g in groups], (b1, b2)) # pyright: ignore[reportPossiblyUnboundVariable]
 def join_steps(self, steps: int) -> list[int]:
 return sorted(self._join(steps)[0], reverse=True)
 def join_all(self) -> tuple[SpaceCoord,SpaceCoord]:
 return self._join()[1]
def exo1(data: list[str], steps: int) -> int:
 lengths = Junction(data).join_steps(steps)
 return reduce(mul, lengths[:3])
def exo2(data: list[str]) -> int:
 b1, b2 = Junction(data).join_all()
 return b1.x * b2.x

++
Gi)