I also took the most direct approach, although I did “refactor” slightly in part to to use reduce to avoid excessive iterations over the list. I wish I had thought of File.stream!
tfwright
adolfont
newton-peixoto
hst337
Shortest and the fastest solution I wrote in 15 minutes
defmodule AOC1 do
def traverse(input, number \\ 0, current \\ 0, maximum \\ 0) do
case input do
"" ->
max(maximum, number + current)
"\n\n" <> tail ->
traverse(tail, 0, 0, max(maximum, number + current))
"\n" <> tail ->
traverse(tail, 0, current + number, maximum)
<<char, tail :: binary>> ->
number = number * 10 + char - ?0
traverse(tail, number, current, maximum)
end
end
end
IO.inspect AOC1.traverse IO.read(:eof)
Part 2
defmodule AOC12 do
def traverse(input, number \\ 0, current \\ 0, maximum \\ {0, 0, 0}) do
case input do
"" ->
{first, second, third} = put_max(number + current, maximum)
first + second + third
"\n\n" <> tail ->
traverse(tail, 0, 0, put_max(number + current, maximum))
"\n" <> tail ->
traverse(tail, 0, current + number, maximum)
<<char, tail :: binary>> ->
number = number * 10 + char - ?0
traverse(tail, number, current, maximum)
end
end
defp put_max(new, {_first, second, third}) when new > third, do: {second, third, new}
defp put_max(new, {_first, second, third}) when new > second, do: {second, new, third}
defp put_max(new, {first, second, third}) when new > first, do: {new, second, third}
defp put_max(_, maximum), do: maximum
end
IO.inspect AOC1.traverse IO.read :eof
0
christhekeele
This is pretty identical to my part 1 and part 2 solutions! Seems like it’s the easiest iterate-function-call-by-function-call pipeline approach to develop, though not parallelized.
TL;DR:
Part 1:
input_file
|> File.read!()
|> String.split("\n\n")
|> Enum.map(&String.split(&1, "\n"))
|> Enum.map(fn inputs ->
inputs
|> Enum.map(&String.to_integer/1)
|> Enum.sum
end)
|> Enum.max()
Part 2:
input_file
|> File.read!()
|> String.split("\n\n")
|> Enum.map(&String.split(&1, "\n"))
|> Enum.map(fn inputs ->
inputs
|> Enum.map(&String.to_integer/1)
|> Enum.sum
end)
|> Enum.sort(:desc)
|> Enum.take(3)
|> Enum.sum()
0
deadbeef
bismark
Outside of a hardcoded N with pattern matching tuples.. whats the fastest way to get the top N elements in a list?
Benchee puts this at much faster than Enum.sort(:desc) |> Enum.take(n) (it assumes there are >N elements in the list…):
fn n, list ->
topN = for _ <- 1..n, do: 0
Enum.reduce(list, topN, fn
el, [min | rest] when el > min -> Enum.sort([el|rest])
_, topN -> topN
end)
end
1
Aetherus
If you just want to get the top 3 (not top N with N as a variable), then just
defp get_top3([], top1, top2, top3), do: [top1, top2, top3]
defp get_top3([h|t], top1, top2, _top3) when h > top1, do: get_top3(t, h, top1, top2)
defp get_top3([h|t], top1, top2, _top3) when h > top2, do: get_top3(t, top1, h, top2)
defp get_top3([h|t], top1, top2, top3) when h > top3, do: get_top3(t, top1, top2, h)
defp get_top3([_h|t], top1, top2, top3), do: get_top3(t, top1, top2, top3)
0
hst337
The fastest way is to traverse list and perform binary search in tuple of maximums (if it’s size more than 5), or linear search (for small tuples of maximums). Something like
# All indeces are 1-based, because it is more efficient in BEAM
def put_max(maxs, new) do
if new <= :erlang.element(1, maxs) do
maxs
else
put_max(maxs, new, 1, tuple_size(maxs))
end
end
def put_max(maxs, new, index, index) do
put_truncating(maxs, index, new)
end
def put_max(maxs, new, left, right) do
middle = div(left + right, 2)
case :erlang.element(middle, maxs) do
^new ->
put_truncating(tuple, middle, new)
less when less < new ->
put_max(maxs, new, left, middle)
_ ->
put_max(maxs, new, middle, right)
end
end
defp put_truncating(tuple, index, value) do
tuple = :erlang.insert_element(index, tuple,value)
:erlang.delete_element(1, tuple)
end
1
Aetherus
For top N when N is a variable, then we can also use :gb_sets or build a priority queue to do the job.
2