Thanks! I made a thing in case anyone else wants to use it:
https://github.com/mcrumm/req_aoc
Mix.install([
{:req_aoc, github: "mcrumm/req_aoc", ref: "28e3813"}
])
ReqAOC.fetch!({2022, 03, System.fetch_env!("LB_AOC_SESSION")})
# ==> "..."
mcrumm
Phoenix Core Team
4
stevensonmt
That’s a fantastic tool! Thanks for sharing. I’m definitely using that to speed up my setup for each day.
0
ajur58
I just want to add that for someone being new to Elixir, it’s so cool to do the Advent Of Code riddles, then compare my implementation with yours. Had some funny “AHA!” moments when I’ve discovered stuff like :binary.bin_to_list.
So keep sharing your solutions, even if they seem trivial. I surely appreciate them 
3
tfwright
Didn’t reach for MapSet until the second part. Everyone’s use of codepoints to handle priorities is impressive!
0
mcrumm
Phoenix Core Team
TIL :binary.bin_to_list - There is a ton of cool stuff in the Erlang stdlib it feels like I’m always discovering something new!
I usually don’t do AoC because I convince myself that writing code for work is more important or something, but so far it’s been a nice exercise, I am only optimizing for fun, and I am learning new things!
3
deadbeef
Same idea as others: MapSets and intersections. I ended up transforming part 1 into the same problem as part 2, just with a different group size. So they shared the same solving function
https://github.com/ed-flanagan/advent-of-code-solutions-elixir/blob/main/lib/advent/y2022/d03.ex
0
lkuty
Some ideas from @Aetherus solution.
part 1
start = System.monotonic_time(:microsecond)
File.stream!("input.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&:binary.bin_to_list/1)
|> Stream.map(&Enum.split(&1, div(length(&1), 2)))
|> Stream.map(fn {f, r} -> hd(f -- f -- r) end)
|> Stream.map(fn
x when x >= ?a and x <= ?z -> x - ?a + 1
x when x >= ?A and x <= ?Z -> x - ?A + 27
end)
|> Enum.sum()
|> tap(fn sum -> IO.puts "Sum of priorities: #{sum}" end)
elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"
part 2
start = System.monotonic_time(:microsecond)
File.stream!("input.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&:binary.bin_to_list/1)
|> Stream.chunk_every(3)
|> Stream.map(fn [r1, r2, r3] ->
r = r1 -- (r1 -- r2)
hd(r3 -- (r3 -- r))
end)
|> Stream.map(fn
x when x >= ?a and x <= ?z -> x - ?a + 1
x when x >= ?A and x <= ?Z -> x - ?A + 27
end)
|> Enum.sum()
|> tap(fn sum -> IO.puts "Sum of priorities: #{sum}" end)
elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"
I then decided to benchmark it with benchee. I guess that reading the file many times puts it in some sort of cache and thus the execution times are well below the one with a single execution dominated by I/O. Part 1 without benchee gives ± 7 ms but with benchee an average of 0.86 ms 
Mix.install([
{:benchee, "~> 1.1.0"},
])
Benchee.run(%{"run" => fn ->
File.stream!("input.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&:binary.bin_to_list/1)
|> Stream.map(&Enum.split(&1, div(length(&1), 2)))
|> Stream.map(fn {f, r} -> hd(f -- f -- r) end)
|> Stream.map(fn
x when x >= ?a and x <= ?z -> x - ?a + 1
x when x >= ?A and x <= ?Z -> x - ?A + 27
end)
|> Enum.sum()
end})
1
marcelfahle
marcelfahle
Yea ok there are some elegant solutions in here, wow 
Made me almost not post mine 
Regardless, I had some fun with and learned about String.myers_difference and Enum.frequencies 
defmodule ExAOC2022.Day3 do
@input "./lib/day3_input.txt"
def puzzle1() do
prio = priority_map([?a..?z, ?A..?Z])
@input
|> file_by_line()
|> Enum.map(&by_compartment/1)
|> Enum.map(&eq/1)
|> Enum.map(&Keyword.get(prio, String.to_atom(&1)))
|> Enum.sum()
end
def puzzle2() do
prio = priority_map([?a..?z, ?A..?Z])
@input
|> file_by_line()
|> Enum.chunk_every(3)
|> Enum.map(&find_common_chars/1)
|> Enum.map(&Keyword.get(prio, String.to_atom(&1)))
|> Enum.sum()
end
# PRIVATE SHENANIGANS
defp by_compartment(content) do
mid_len = content |> String.length() |> div(2)
content |> String.split_at(mid_len)
end
defp eq({str1, str2}), do: String.myers_difference(str1, str2)[:eq]
defp find_common_chars(list_of_strings) do
list_of_strings
|> Enum.map(&uniq/1)
|> Enum.join()
|> String.graphemes()
|> Enum.frequencies()
|> Map.filter(fn {_k, v} -> v == 3 end)
|> Map.keys()
|> List.first()
end
defp uniq(str) do
str
|> String.graphemes()
|> Enum.uniq()
|> Enum.join()
end
defp priority_map(ranges) do
ranges
|> Enum.map(&priority/1)
|> Enum.concat()
|> Enum.with_index(1)
end
defp priority(range) do
range
|> Enum.map(&String.to_atom(<<&1::utf8>>))
end
defp file_by_line(file) do
file
|> File.read!()
|> String.split(~r/\R/, trim: true)
end
end
1