More idiomatic elixir

Author: pcorliss

2025/lib/day08/day08.ex

@@ -1,24 +1,22 @@
 defmodule Day08 do
   def input(infile) do
-    File.read!(infile)
-    |> String.trim()
-    |> String.split("\n")
-    |> Enum.map(&String.trim/1)
-    |> Enum.map(&String.split(&1, ","))
-    |> Enum.map(fn str ->
-      Enum.map(str, &String.to_integer/1)
+    infile
+    |> File.read!()
+    |> String.split("\n", trim: true)
+    |> Enum.map(fn line ->
+      line
+      |> String.split(",", trim: true)
+      |> Enum.map(&String.to_integer/1)
+      |> List.to_tuple()
     end)
-    |> Enum.map(&List.to_tuple/1)
   end
 
   # We skip the sqrt here to save CPU cycles, we still compare apples to apples
-  def distance(a, b) do
-    {a_x, a_y, a_z} = a
-    {b_x, b_y, b_z} = b
-    x_d = a_x - b_x
-    y_d = a_y - b_y
-    z_d = a_z - b_z
-    Integer.pow(x_d, 2) + Integer.pow(y_d, 2) + Integer.pow(z_d, 2)
+  def distance({ax, ay, az}, {bx, by, bz}) do
+    dx = ax - bx
+    dy = ay - by
+    dz = az - bz
+    dx * dx + dy * dy + dz * dz
   end
 
   # Hash keyed on edge distance, mapped to a set of two points
@@ -33,12 +31,12 @@ defmodule Day08 do
   end
 
   defp points_to_circuits(points) do
-    MapSet.new(Enum.map(points, fn p -> MapSet.new([p]) end))
+    points
+    |> Enum.map(&MapSet.new([&1]))
+    |> MapSet.new()
   end
 
-  def connect_points(points, edges, connections) do
-    circuits = points_to_circuits(points)
-
+  def connect_points(circuits, edges, connections) do
     Map.keys(edges)
     |> Enum.sort()
     |> Enum.take(connections)
@@ -47,22 +45,22 @@ defmodule Day08 do
     end)
   end
 
-  def connect_points_edges(circuits, edge) do
-    {a, b} = edge
-
-    {edge_groups, remaining_circuits} =
-      MapSet.split_with(circuits, fn circuit ->
-        MapSet.member?(circuit, a) or MapSet.member?(circuit, b)
+  # Connect to circuits and return the resulting circuit set
+  # TODO This would be dramatically faster using a disjoint-set union
+  def connect_points_edges(circuits, {a, b}) do
+    {edge_groups, remaining} =
+      MapSet.split_with(circuits, fn group ->
+        MapSet.member?(group, a) or MapSet.member?(group, b)
       end)
 
-    new_group = Enum.reduce(edge_groups, &MapSet.union(&2, &1))
-    MapSet.put(remaining_circuits, new_group)
+    merged = Enum.reduce(edge_groups, &MapSet.union(&2, &1))
+
+    # Dialyzer complains about remaining but I assure you it's a MapSet and is fine
+    MapSet.put(remaining, merged)
   end
 
   # the last connection which causes all of the junction boxes to form a single circuit
-  def last_connection(points, edges) do
-    circuits = points_to_circuits(points)
-
+  def last_connection(edges, circuits) do
     Map.keys(edges)
     |> Enum.sort()
     |> Enum.reduce_while(circuits, fn edge_d, circ_acc ->
@@ -77,33 +75,37 @@ defmodule Day08 do
     end)
   end
 
-  def part1(infile, connections) do
-    points = input(infile)
-    edges = edges(points)
-    circuits = connect_points(points, edges, connections)
+  def part1(edges, circuits, connections) do
+    connected_circuits = connect_points(circuits, edges, connections)
 
-    Enum.map(circuits, &MapSet.size/1)
-    |> Enum.sort()
-    |> Enum.reverse()
+    Enum.map(connected_circuits, &MapSet.size/1)
+    |> Enum.sort(:desc)
     |> Enum.take(3)
     |> Enum.product()
   end
 
-  def part2(infile) do
+  def part2(edges, circuits) do
+    {{a_x, _, _}, {b_x, _, _}} = last_connection(edges, circuits)
+
+    a_x * b_x
+  end
+
+  def loader(infile) do
     points = input(infile)
     edges = edges(points)
+    circuits = points_to_circuits(points)
 
-    {{a_x, _, _}, {b_x, _, _}} = last_connection(points, edges)
-
-    a_x * b_x
+    {edges, circuits}
   end
 
   def main do
     input_path = "lib/day08/input.txt"
 
-    answer = part1(input_path, 1000)
+    {edges, circuits} = loader(input_path)
+
+    answer = part1(edges, circuits, 1000)
     IO.puts("Part 1: #{answer}")
-    answer = part2(input_path)
+    answer = part2(edges, circuits)
     IO.puts("Part 2: #{answer}")
   end
 end

2025/test/day08/day08_test.exs

@@ -50,24 +50,23 @@ defmodule Day08Test do
   end
 
   test "connect_points", %{temp_file: temp_file} do
-    points = Day08.input(temp_file)
-    edges = Day08.edges(points)
+    {e, c} = Day08.loader(temp_file)
 
     # Connects the closest circuits into one group
-    circuits = Day08.connect_points(points, edges, 1)
+    circuits = Day08.connect_points(c, e, 1)
     assert MapSet.size(circuits) == 19
 
     assert MapSet.member?(circuits, MapSet.new([{162, 817, 812}, {425, 690, 689}])) == true
 
-    circuits = Day08.connect_points(points, edges, 2)
+    circuits = Day08.connect_points(c, e, 2)
     assert MapSet.size(circuits) == 18
 
     assert MapSet.member?(
              circuits,
              MapSet.new([{162, 817, 812}, {425, 690, 689}, {431, 825, 988}])
            ) == true
 
-    circuits = Day08.connect_points(points, edges, 3)
+    circuits = Day08.connect_points(c, e, 3)
     assert MapSet.size(circuits) == 17
 
     assert MapSet.member?(
@@ -76,24 +75,25 @@ defmodule Day08Test do
            ) == true
 
     #  The next two junction boxes are 431,825,988 and 425,690,689. Because these two junction boxes were already in the same circuit, nothing happens!
-    circuits = Day08.connect_points(points, edges, 4)
+    circuits = Day08.connect_points(c, e, 4)
     assert MapSet.size(circuits) == 17
 
-    circuits = Day08.connect_points(points, edges, 10)
+    circuits = Day08.connect_points(c, e, 10)
     assert MapSet.size(circuits) == 11
   end
 
   test "part1", %{temp_file: temp_file} do
-    assert Day08.part1(temp_file, 10) == 40
+    {e, c} = Day08.loader(temp_file)
+    assert Day08.part1(e, c, 10) == 40
   end
 
   test "last_connection", %{temp_file: temp_file} do
-    points = Day08.input(temp_file)
-    edges = Day08.edges(points)
-    assert Day08.last_connection(points, edges) == {{216, 146, 977}, {117, 168, 530}}
+    {e, c} = Day08.loader(temp_file)
+    assert Day08.last_connection(e, c) == {{216, 146, 977}, {117, 168, 530}}
   end
 
   test "part2", %{temp_file: temp_file} do
-    assert Day08.part2(temp_file) == 25272
+    {e, c} = Day08.loader(temp_file)
+    assert Day08.part2(e, c) == 25272
   end
 end