There is another aspect of this problem that I think works just by chance, or by dataset design. If two or more pairs’ distances were the same, then the sorting would be indeterminant, and the solution to “last two coords that combine all nodes into one circuit” could also be indeterminant.
rvnash
dompdv
My solution, very late (I couldn’t find time today to work on it before 22:30);
Nothing new/fancy when I look at those already posted: pair distances are pre-computed and sorted, the main data structure is a map %{index of the circuit => MapSet of the box coordinates in the circuit}
defmodule AdventOfCode.Solution.Year2025.Day08 do
# Launch processing for part1 & 2
def part1(input), do: input |> do_connect(1000) |> mul_3_largest()
def part2(input), do: input |> do_connect(:full_connect) |> mul_xs()
# Post processing part 1
def mul_3_largest(circuits) do
circuits
|> Enum.map(fn {_, c} -> MapSet.size(c) end)
|> Enum.sort(:desc)
|> Enum.take(3)
|> Enum.reduce(1, &(&1 * &2))
end
# Post processing part 2
def mul_xs({[x1, _, _], [x2, _, _]}), do: x1 * x2
# The common algorithm : preparing the wiring process
def do_connect(input, stop_at) do
boxes_i = parse(input)
sorted_connects =
for({b1, i1} <- boxes_i, {b2, i2} <- boxes_i, i1 < i2, do: add_distance(b1, b2))
|> Enum.sort_by(&elem(&1, 2))
initial_circuits = for {b, i} <- boxes_i, into: %{}, do: {i, MapSet.new([b])}
wire(sorted_connects, initial_circuits, 0, stop_at, nil)
end
def add_distance(b1, b2),
do: {b1, b2, Enum.zip(b1, b2) |> Enum.map(fn {a, b} -> (a - b) * (a - b) end) |> Enum.sum()}
# Wiring process itself
# Stop if there is one circuit left
def wire(_, circuits, _n, _stop_at, last) when map_size(circuits) == 1, do: last
# Stop if we reach "stop_at" if stop_at is a number
def wire(_, circuits, n, stop_at, _last) when stop_at != :full_connect and n == stop_at,
do: circuits
def wire([{b1, b2, _} | rest], circuits, n, stop_at, _last) do
c_b1 = which_circuit(circuits, b1)
c_b2 = which_circuit(circuits, b2)
if c_b1 == c_b2 do
# They are in the same circuit => do nothing
wire(rest, circuits, n + 1, stop_at, {b1, b2})
else
# Different circuit, merge circuit c_b2 into c_b1
new_circuits =
circuits |> Map.delete(c_b2) |> Map.update(c_b1, nil, &MapSet.union(&1, circuits[c_b2]))
wire(rest, new_circuits, n + 1, stop_at, {b1, b2})
end
end
def which_circuit(circuits, b) do
# returns the index of the circuit containing the box b
Enum.reduce_while(circuits, nil, fn {i, c}, _acc ->
if b in c, do: {:halt, i}, else: {:cont, nil}
end)
end
def parse(input) do
input
|> String.split("\n", trim: true)
|> Enum.map(fn line ->
line |> String.split(",", trim: true) |> Enum.map(&String.to_integer/1)
end)
|> Enum.with_index()
end
end
2
adamu
This one had me going for a long time trying various optimisations, but I eventually went with just keeping it simple.
One thing I struggled with was finding all the pairs - I was computing duplicates because I was adding a, b and b, a. I worked around it by sorting and skipping every other result - but this only worked by chance because they all had unique distances. After seeing @vkryukov’s solution I realised the a < b filter is the trick - I had been only filtering a != b.
def calculate_distances(points) do
for(a <- points, b <- points, a < b, do: {a, b, distance(a, b)})
|> Enum.sort_by(&elem(&1, 2))
end
def part2(points) do
points
|> calculate_distances()
|> Enum.reduce_while([], fn {a, b, _dist}, circuits ->
circuits = connect(a, b, circuits)
if length(circuits) == 1 and MapSet.size(hd(circuits)) == 1000 do
{:halt, hd(a) * hd(b)}
else
{:cont, circuits}
end
end)
end
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2025/day8.exs
1