Don’t beat yourself up over it. I came to it after my first attempt became too complex. Lost quite some time on that dead track.
BartOtten
vkryukov
One the plus side, you were solving a harder problem than everyone else (I sense a bunch of folks, me included, were a bit underwhelmed by the simplicity of Day 5’s problem), so you had more fun than the rest of us! 
1
lkuty
#!/usr/bin/env elixir
# Advent of Code 2025. Day 5
Mix.install([
{:nimble_parsec, "~> 1.4.2"},
])
defmodule M do
import NimbleParsec
parse = repeat(
integer(min: 1)
|> ignore(string("-"))
|> integer(min: 1)
|> tag(:range)
|> ignore(string("\n"))
)
|> ignore(string("\n"))
|> repeat(
integer(min: 1)
|> unwrap_and_tag(:id)
|> ignore(string("\n"))
)
defparsec :parse, parse
# don't know if there is a way to get ranges and ids directly from NimbleParsec
# transform() allows us to extract them
def transform([], ranges, ids), do: {ranges, ids}
def transform([{:range, [lo,hi]} | lst], ranges, ids), do: transform(lst, [lo..hi | ranges], ids)
def transform([{:id, id} | lst], ranges, ids), do: transform(lst, ranges, [id | ids])
def union(lo1.._hi1//1 = range1, lo2.._hi2//1 = range2) when lo2 < lo1 do
union(range2, range1)
end
def union(lo1..hi1//1, lo2..hi2//1) when lo2 == hi1+1 do
lo1..hi2
end
def union(_lo1..hi1//1, lo2.._hi2//1) when hi1 < lo2 do
false # cannot union the ranges
end
def union(lo1..hi1//1, lo2..hi2//1) when lo2 >= lo1 and lo2 <= hi1 and hi2 <= hi1 do
lo1..hi1
end
def union(lo1..hi1//1, lo2..hi2//1) when hi1 >= lo2 and hi1 <= hi2 or lo2 >= lo1 and lo2 <= hi1 do
lo1..hi2
end
def add([], range_to_add, disjoint_ranges), do: [range_to_add | disjoint_ranges]
def add([range | ranges], range_to_add, disjoint_ranges) do
# Try to union both ranges
case union(range, range_to_add) do
false -> add(ranges, range_to_add, [range | disjoint_ranges])
range -> add(disjoint_ranges++ranges, range, []) # retry to add the new range
end
end
end
{ranges, ids} = File.read!("../day05.txt")
|> M.parse()
|> then(fn {:ok, lst, "", %{}, _, _} -> lst end)
|> M.transform([], [])
# Part 1
Enum.count(ids, fn id -> Enum.any?(ranges, fn range -> id in range end) end)
|> IO.inspect(label: "Day 5. Part 1")
# Part 2
ranges
|> Enum.reduce([], fn range, ranges -> M.add(ranges, range, []) end)
|> Enum.map(&Range.size/1)
|> Enum.sum()
|> IO.inspect(label: "Day 5. Part 2")
1
KeithFrost
2025 Dec 05
Cafeteria
defmodule Cafeteria do
defp parse_range(line) do
case Regex.run(~r"(\d+)-(\d+)", line) do
[_match, min_str, max_str] ->
{String.to_integer(min_str), String.to_integer(max_str)}
end
end
defp parse_ids(id_lines, acc \\ []) do
case id_lines do
[] ->
acc
["" | _] ->
acc
[line | rest] ->
acc = [String.to_integer(String.trim(line)) | acc]
parse_ids(rest, acc)
end
end
def parse(lines) do
{range_lines, id_lines} = Enum.split_while(lines, fn line -> String.trim(line) != "" end)
ranges = Enum.map(range_lines, &parse_range/1)
|> Enum.sort()
ids = parse_ids(tl(id_lines))
{ranges, Enum.reverse(ids)}
end
def id_covered?(id, ranges) do
case ranges do
[{minr, maxr} | rest] ->
cond do
minr > id ->
false
maxr >= id ->
true
true ->
id_covered?(id, rest)
end
[] ->
false
end
end
end
{test_ranges, test_ids} = """
3-5
10-14
16-20
12-18
1
5
8
11
17
32
""" |> String.split("\n")
|> Cafeteria.parse()
|> IO.inspect()
Enum.filter(test_ids, fn id -> Cafeteria.id_covered?(id, test_ranges) end)
{input_ranges, input_ids} = File.stream!(__DIR__ <> "/dec-05-input.txt")
|> Cafeteria.parse()
Enum.filter(input_ids, fn id -> Cafeteria.id_covered?(id, input_ranges) end)
|> Enum.count()
Part 2
defmodule Cafeteria2 do
def merge_ranges(ranges, merged_ranges \\ []) do
case ranges do
[] ->
Enum.reverse(merged_ranges)
[{minr, maxr} | rest] ->
case merged_ranges do
[] ->
merge_ranges(rest, [{minr, maxr}])
[{min_mr, max_mr} | rest_merged] ->
if max_mr < minr do
merge_ranges(rest, [{minr, maxr}, {min_mr, max_mr} | rest_merged])
else # merge ranges
merge_ranges(rest, [{min_mr, max(maxr, max_mr)} | rest_merged])
end
end
end
end
def sum_ranges(ranges) do
merge_ranges(ranges)
|> Enum.reduce(0, fn {minr, maxr}, sum ->
sum + maxr - minr + 1
end)
end
end
Cafeteria2.sum_ranges(input_ranges)
1
aloisdg
Part 1
[one, two] =
File.read!("ids.txt")
|> String.split("\n\n")
ranges = one
|> String.split("\n")
|> Enum.map(fn x -> x |> String.split("-") |> Enum.map(&String.to_integer/1) end)
two
|> String.split("\n")
|> Enum.map(&String.to_integer/1)
|> Enum.count(&(Enum.any?(ranges, fn [a, b] -> a <= &1 and &1 <= b end)))
|> IO.inspect
Part 2
[one, _] =
File.read!("ids.txt")
|> String.split("\n\n")
ranges = one
|> String.split("\n")
|> Enum.map(fn x -> x |> String.split("-") |> Enum.map(&String.to_integer/1) end)
defmodule Aoc do
def touch?([x1, x2], [y1, y2]), do: max(x1, y1) - min(x2, y2) <= 1
def merge([x1, x2], [y1, y2]), do: [Enum.min([x1, x2, y1, y2]), Enum.max([x1, x2, y1, y2])]
def loop(ranges, previous) when ranges == previous, do: ranges
def loop(ranges, _) do
Enum.map(ranges, fn range ->
ranges
|> Enum.filter(&(touch?(range, &1)))
|> Enum.reduce(range, &(merge(&1, &2)))
end)
|> Enum.uniq
|> loop(ranges)
end
end
Aoc.loop(ranges, [])
|> Enum.map(fn [a, b]-> b - a + 1 end)
|> Enum.sum
|> IO.inspect
1
adamu
Just throwing mine in the pot - part 2 completes in 0.1ms on an old i5.
def part2(ranges) do
ranges
|> Enum.sort_by(& &1.first)
|> Enum.reduce([hd(ranges)], fn b, [a | rest] = disjoint ->
if Range.disjoint?(a, b) do
[b | disjoint]
else
[min(a.first, b.first)..max(a.last, b.last) | rest]
end
end)
|> Enum.sum_by(&Range.size/1)
end
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2025/day5.exs
1
al2o3cr
Stream.transform is slightly too general for this, but it’s fun to use:
[ranges_string, _ingredients_string] =
File.read!("input.txt")
|> String.split("\n\n")
ranges_string
|> String.split("\n")
|> Enum.map(&Regex.run(~r/(\d+)-(\d+)/, &1, capture: :all_but_first))
|> Enum.map(fn [a, b] -> Range.new(String.to_integer(a), String.to_integer(b)) end)
|> Enum.sort()
|> Stream.transform(
fn -> nil end,
fn r, last_r ->
cond do
is_nil(last_r) ->
{[], r}
Range.disjoint?(r, last_r) ->
{[last_r], r}
true ->
{[], Range.new(min(r.first, last_r.first), max(r.last, last_r.last))}
end
end,
fn last_r ->
{[last_r], nil}
end,
fn _ -> nil end
)
|> Stream.map(&Range.size/1)
|> Enum.sum()
|> IO.inspect()
1
billylanchantin
For part 2, I flatten a list of range firsts and lasts and keep a running total of how many ranges overlap our place in the list.
defmodule Day05 do
def part1(file) do
{ranges, ids} = parse(file)
Enum.count(ids, fn id -> Enum.any?(ranges, &(id in &1)) end)
end
def part2(file) do
{ranges, _} = parse(file)
firsts = Enum.frequencies_by(ranges, & &1.first)
lasts = Enum.frequencies_by(ranges, &(&1.last + 1))
Enum.sort(Map.keys(firsts) ++ Map.keys(lasts))
|> Enum.scan({0, 0}, fn x, {_, c} -> {x, c + (firsts[x] || 0) - (lasts[x] || 0)} end)
|> Enum.chunk_every(2, 1, :discard)
|> Enum.sum_by(fn [{a, count}, {b, _}] -> if count > 0, do: b - a, else: 0 end)
end
def parse(file) do
[rngs, ids] = file |> File.read!() |> split("\n\n") |> Enum.map(&split(&1, "\n"))
{Enum.map(rngs, &to_rng/1), Enum.map(ids, &to_int/1)}
end
def split(str, on), do: String.split(str, on, trim: true)
def to_int(str), do: str |> Integer.parse() |> elem(0)
def to_rng(str), do: str |> split("-") |> Enum.map(&to_int/1) |> then(&apply(Range, :new, &1))
end
1