Day 5

lib/day5.ex

@@ -0,0 +1,84 @@
+defmodule Aoc2023.Day5 do
+  use Aoc2023
+
+  defp numbers(str), do: str |> String.split() |> Enum.map(&String.to_integer/1)
+
+  def parse(input) do
+    [seeds | maps] =
+      input
+      |> String.split("\n\n")
+
+    {
+      seeds |> String.split(": ") |> Enum.at(1) |> numbers,
+      maps
+      |> Enum.map(pipe(
+        String.split("\n")
+        |> tail
+        |> Enum.map(pipe(
+          numbers
+          |> List.to_tuple()
+          |> then(fn {dst, src, len} -> {src .. (src + len - 1), dst - src} end)
+        ))
+      ))
+    }
+  end
+
+  defp split_range_on(r1, r2) do
+    cond do
+      Range.disjoint?(r1, r2) -> {[r1], []}
+      r1.first < r2.first && r1.last < r2.last ->
+        {a, b} = Range.split(r1, r2.first - r1.first)
+        {[a], [b]}
+      r1.first > r2.first && r1.last > r2.last ->
+        {a, b} = Range.split(r1, r1.first - r2.first)
+        {[b], [a]}
+      r1.first >= r2.first && r1.last <= r2.last ->
+        {[], [r1]}
+      r1.first <= r2.first && r1.last >= r2.last ->
+        {pre, rest} = Range.split(r1, r2.first - r1.first)
+        {mid, last} = Range.split(rest, r2.last - rest.first)
+        {[pre, last], [mid]}
+    end
+  end
+
+  defp map(loc, map) do
+    {unmapped, mapped} = for {src, offset} <- map,
+        reduce: {[loc], []} do
+      {unmapped, mapped} ->
+        for range <- unmapped,
+            reduce: {[], mapped} do
+          {unmapped_, mapped_} ->
+            {unmapped, mapped} = split_range_on(range, src)
+            {
+              unmapped_ ++ unmapped,
+              mapped_ ++ Enum.map(mapped, &(Range.shift(&1, offset)))
+            }
+        end
+    end
+    unmapped ++ mapped
+  end
+
+  defp run(seeds, maps) do
+    for seed <- seeds do
+      for map <- maps, reduce: [seed] do
+        loc ->
+          loc
+          |> Enum.flat_map(pipe(map(map)))
+      end
+    end
+    |> Enum.flat_map(&id/1)
+    |> Enum.min_by(&(&1.first))
+    |> then(&(&1.first))
+  end
+
+  def part1({seeds, maps}) do
+    run(seeds |> Enum.map(&(&1..&1)), maps)
+  end
+
+  def part2({seeds, maps}) do
+    run(
+      seeds |> Enum.chunk_every(2) |> Enum.map(fn [s, len] -> s..(s + len - 1) end),
+      maps
+    )
+  end
+end