# part 1
File.stream!("input.txt")
|> Enum.reduce({[], []}, fn line, {lst1, lst2} ->
String.split(line)
|> Enum.map(&String.to_integer/1)
|> then(fn [n1, n2] -> {[n1 | lst1], [n2 | lst2]} end)
end)
|> then(fn {lst1, lst2} -> Stream.zip_with(Enum.sort(lst1), Enum.sort(lst2), fn a, b -> abs(a-b) end) end)
|> Enum.sum()
|> IO.inspect(label: "part 1")
# part 2
File.stream!("input.txt")
|> Enum.reduce({[], %{}}, fn line, {lst, map} ->
String.split(line)
|> Enum.map(&String.to_integer/1)
|> then(fn [n1, n2] -> {[n1 | lst], Map.update(map, n2, 1, fn n -> n+1 end)} end)
end)
|> then(fn {lst, map} -> Enum.reduce(lst, 0, fn n, acc -> acc + n * Map.get(map, n, 0) end) end)
|> IO.inspect(label: "part 2")
lkuty
0
al2o3cr
I liked this solution for part 1 because of the unzip / process / zip pattern:
File.stream!("example.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&String.split/1)
|> Stream.map(fn [a, b] -> {String.to_integer(a), String.to_integer(b)} end)
|> Enum.unzip()
|> then(fn {l, r} -> [Enum.sort(l), Enum.sort(r)] end)
|> Stream.zip()
|> Stream.map(fn {a, b} -> abs(b-a) end)
|> Enum.sum()
|> IO.inspect()
Part 2 wasn’t quite as symmetrical:
{left, right} =
File.stream!("input.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&String.split/1)
|> Stream.map(fn [a, b] -> {String.to_integer(a), String.to_integer(b)} end)
|> Enum.unzip()
f_right = Enum.frequencies(right)
left
|> Stream.map(fn l -> {l, Map.get(f_right, l, 0)} end)
|> Stream.map(fn {l, n} -> l * n end)
|> Enum.sum()
|> IO.inspect()
Technically it would be faster to fuse successive Stream.maps into a single one with a more-complicated function, but writing in this style keeps each line focused on a specific transformation.
4
ntalfer
Our solutions are quite similar 
Personally I like to write unit tests and save input as a file in the test folder.
Pretty useful when you want to do a bit of refactor while doing part 2 to ensure you don’t break part 1.
defmodule D1 do
def p1(file) do
file
|> build_lists()
|> Enum.map(&Enum.sort/1)
|> Enum.zip_reduce(0, fn [a, b], acc -> acc + abs(b - a) end)
end
def p2(file) do
[l1, l2] = build_lists(file)
freq = Enum.frequencies(l2)
Enum.reduce(l1, 0, fn a, acc -> acc + a * Map.get(freq, a, 0) end)
end
defp build_lists(file) do
file
|> File.stream!(:line)
|> Enum.reduce([[], []], fn line, [l1, l2] ->
[a, b] =
line
|> String.split()
|> Enum.map(&String.to_integer/1)
[[a | l1], [b | l2]]
end)
end
end
unit tests:
defmodule D1Test do
use ExUnit.Case
test "p1" do
assert D1.p1("test/d1.txt") == 2_970_687
end
test "p2" do
assert D1.p2("test/d1.txt") == 23_963_899
end
end
It could also be useful when things are getting harder to write a unit test with the given examples.
0
code-shoily
dimitarvp
I wish. I am currently jobless. 
I was referring to being thorough always though.
That being said, I am ashamed to have forgotten about Enum.zip_with and Enum.zip_reduce.
0
davewil
I was looking for a way to read file from web so this is very handy, also the left right into tuple if something I haven’t worked out in elixir yet, so again useful.
Part 1 you could
!> Enum.reduce(0, fn {a, b}, acc → acc + abs(a - b) end)
and remove the sum step I believe
0
davewil
context: I’m new to Elixir and not a massive user of FP in general outside of LINQ in C#, I’m very interested in the Elixir ecosystem.
What I love about this challenge is that it shows how many ways there are to solve the same problem, in the same language. I hoping to use this AoC to find some idiomatic Elixir (and functional) ways to do things I just haven’t thought of.
I’ve solved Day 1, using Livebook so no fancy modules or anything, but already I’m noticing some patterns. For instance, I see a lot of |> Enum.map |> Enum.sum being used when a |> Enum.reduce would do the step in a single line. Although both are correct, I’m wondering what the mental leap is to merge those map/sum steps to a reduce is. It wasn’t until a colleague said I realised it too. I solved the problem and didn’t go back to use reduce until after.I’m curious as to when reduce becomes ‘normal’ thinking in FP.
My pre ‘reduce’ solution is here [aoc-2024/day1.livemd at main · davewil/aoc-2024 · GitHub] very happy for constructive feedback.
My post ‘reduce’ solution generally merges the final map/sum into a reduce accumulate with 0 initial value
1
clayscode
Signed up just to say thank you for this comment! Didn’t know about the then function. Subsequently have learned about the tap function as well thanks to this article: Useful Elixir Functions You May Not Know: tap() & then()
I guess it’s not that different from |> fn x -> x end.(), but it at least feels a bit nicer.
4
davewil
input
|> Enum.Map()
|> Enum.Sum()
can usually be replaced with a
input
|> Enum.reduce()
if you want to
0
Aetherus
By the way, you can also achieve similar memory footprint with stream.
input
|> Stream.map(...)
|> Enum.sum()
0