This was easier than it seemed at first. Part one I just did a naive thang.
For part 2 I realised I could just implement a sorting function and use Enum.sort_by to fix it 
Part 1
def day_5_1() do
input = File.read!("./day_5_input.txt")
{rules, reports} = rules_reports(input, [])
rules = numbers_in_rules(rules)
Enum.reduce(reports, 0, fn report, mid_number_sum ->
report_good? =
Enum.all?(report, fn number ->
{must_come_before, must_come_after} = Map.fetch!(rules,number)
{comes_after, comes_before} = numbers_before(number, report)
(comes_after == [] || not Enum.any?(comes_after, &(&1 in must_come_before))) &&
(comes_before == [] || not Enum.all?(comes_before, &(&1 in must_come_after)))
end)
if report_good? do
mid = Enum.at(report, div(length(report), 2))
mid_number_sum + mid
else
mid_number_sum
end
end)
end
defp comes_before(number, rules), do: for({^number, rule} <- rules, do: rule)
defp comes_after(number, rules), do: for({rule, ^number} <- rules, do: rule)
defp numbers_in_rules(rules) do
Enum.reduce(rules, %{}, fn {left, right}, acc ->
acc
|> Map.put_new_lazy(left, fn -> {comes_before(left, rules), comes_after(left, rules)} end)
|> Map.put_new_lazy(right, fn -> {comes_before(right, rules), comes_after(right, rules) } end)
end)
end
# May want to raise if we see dupes here.
defp numbers_before(number, numbers) do
{_, before, afterr} =
Enum.reduce(numbers, {false, [], []}, fn n, {spotted?, before, afterr} ->
if spotted? do
{spotted?, before, [n | afterr]}
else
if n == number do
{true, before, afterr}
else
{false, [n | before], afterr}
end
end
end)
{before, afterr}
end
@pipe "|"
def rules_reports(<<@new_line, @new_line, rest::binary>>, rules) do
{Enum.reverse(rules), parse_reports(rest, [], [])}
end
def rules_reports(<<@new_line, rest::binary>>, acc), do: rules_reports(rest, acc)
def rules_reports(<<left::binary-size(2), @pipe, right::binary-size(2), rest::binary>>, rules) do
rules_reports(rest, [{String.to_integer(left), String.to_integer(right)} | rules])
end
def parse_reports(<<>>, _report, reports), do: Enum.reverse(reports)
def parse_reports(<<@new_line, rest::binary>>, report, reports) do
parse_reports(rest, [], [Enum.reverse(report) | reports])
end
def parse_reports(<<@comma, rest::binary>>, report, reports) do
parse_reports(rest, report, reports)
end
def parse_reports(<<numb::binary-size(2), rest::binary>>, report, reports) do
parse_reports(rest, [String.to_integer(numb) | report], reports)
end
Part 2
def day_5_2() do
input = File.read!("./day_5_input.txt")
{rules, reports} = rules_reports(input, [])
rules = numbers_in_rules(rules)
Enum.reduce(reports, 0, fn report, mid_number_sum ->
report_good? =
Enum.all?(report, fn number ->
{must_come_before, must_come_after} = Map.fetch!(rules,number)
{comes_after, comes_before} = numbers_before(number, report)
(comes_after == [] || not Enum.any?(comes_after, &(&1 in must_come_before))) &&
(comes_before == [] || not Enum.all?(comes_before, &(&1 in must_come_after)))
end)
if report_good? do
mid_number_sum
else
# Kinda nasty to do this after? As could do it in the moment. but yea
mid = Enum.at(fix_report(report, rules), div(length(report), 2))
mid_number_sum + mid
end
end)
end
def is_less_than?(number, another, rules) do
{_must_come_before, must_come_after} = Map.fetch!(rules, number)
another in must_come_after
end
# always an odd number of items in report as there is always a mid point.
defp fix_report(report, rules) do
Enum.sort_by(report, & &1, fn left, right -> !is_less_than?(left, right, rules) end)
end
Obligatory meaningless benchmarks:
Name ips average deviation median 99th %
Day 5 1 1.01 K 0.99 ms ±11.12% 0.96 ms 1.18 ms
Day 5 2 0.75 K 1.33 ms ±10.55% 1.31 ms 1.59 ms
Comparison:
Day 5 1 1.01 K
Day 5 2 0.75 K - 1.34x slower +0.34 ms
Memory usage statistics:
Name Memory usage
Day 5 1 1.62 MB
Day 5 2 1.82 MB - 1.12x memory usage +0.199 MB
**All measurements for memory usage were the same**
Reduction count statistics:
Name Reduction count
Day 5 1 545.29 K
Day 5 2 615.17 K - 1.13x reduction count +69.88 K
**All measurements for reduction count were the same**
