defmodule Day01 do
def part1(input) do
all = parse(input)
{first, second} = Enum.unzip(all)
Enum.zip([Enum.sort(first), Enum.sort(second)])
|> Enum.map(fn {a, b} ->
abs(a - b)
end)
|> Enum.sum
end
def part2(input) do
all = parse(input)
{first, second} = Enum.unzip(all)
frequencies = Enum.frequencies(second)
first
|> Enum.map(fn n ->
n * Map.get(frequencies, n, 0)
end)
|> Enum.sum
end
defp parse(input) do
input
|> Enum.map(fn line ->
{first, line} = Integer.parse(line)
line = String.trim(line)
{second, ""} = Integer.parse(line)
{first, second}
end)
end
end
def run(puzzle) do
{l1, l2} = Part1.parse(puzzle)
l2_frequencies = Enum.frequencies(l2)
Enum.reduce(l1, 0, fn n, acc ->
acc + n * Map.get(l2_frequencies, n, 0)
end)
end
defmodule AdventOfCode.Solutions.Y24.Day01 do
alias AoC.Input
def parse(input, _part) do
input
|> Input.stream!(trim: true)
|> Enum.map(&parse_line/1)
|> Enum.unzip()
end
defp parse_line(line) do
[a, b] = String.split(line, " ", trim: true)
{a, ""} = Integer.parse(a)
{b, ""} = Integer.parse(b)
{a, b}
end
def part_one(problem) do
{left, right} = problem
left = Enum.sort(left)
right = Enum.sort(right)
Enum.zip_with(left, right, fn a, b -> abs(a - b) end) |> Enum.sum()
end
def part_two(problem) do
{left, right} = problem
freqs = Enum.frequencies(right)
left |> Enum.map(fn a -> a * Map.get(freqs, a, 0) end) |> Enum.sum()
end
end
Are we not supposed to also include code for opening and reading the input from a file? Or we can opt to just put it in a module attribute and parse that?
I made my own utility modules and functions because I’ve been using Elixir for the past 3-4 AoCs so I’ve accumulated use cases. The goal of posts should be the actual solution, it’s less important where the input comes from!
First time trying to do anything in elixir. I’m still learning in early stage and sometimes it twist my mind to be able to express what i want to do. I think i overcomplicated it a lot, but at least got the correct result
defmodule Aoc2024.Day1 do
def getresult do
{:ok, contents} = File.read("input")
# [ %{left: 40094, right: 37480}, %{left: 52117, right: 14510}, ... ]
itemlist =
contents
|> String.split("\n")
|> Enum.map(fn(line) -> splitlist(line) end)
# Sorted list with only left values
left_items =
itemlist
|> Enum.sort(fn(i1, i2) -> order_items(i1, i2, :left) end)
|> Enum.map(fn(i) -> i.left end)
# same for the right values
right_items =
itemlist
|> Enum.sort(fn(i1, i2) -> order_items(i1, i2, :right) end)
|> Enum.map(fn(i) -> i.right end)
# List of diff of each left and right value at the same list position
difflist =
Enum.zip(left_items, right_items)
|> Enum.map(fn{li, ri} -> abs(li - ri) end)
# sum the values via recursive add
add_values(difflist, 0)
end
defp splitlist(line) do
[left , right] = line |> String.split(" ", trim: true)
%{left: String.to_integer(left) , right: String.to_integer(right)}
end
defp order_items(i1, i2, side) do
case side do
:left -> i1.left <= i2.left
:right -> i1.right <= i2.right
end
end
defp add_values([h | t], result) do
h + add_values(t, result)
end
defp add_values([], result) do
result
end
end
IO.puts(Integer.to_string(Aoc2024.Day1.getresult))
Here’s mine - I did it in Livebook which was a real help, coming from a python/F#-ish world:
# ── Setup ──
fname = "/Users/marksmith/Downloads/AOC24/Day01/input.txt"
lines = File.stream!(fname)
|> Enum.map(&String.split/1)
# ── Part 1 ──
{left, right} = lines
|> Enum.map(&List.to_tuple/1)
|> Enum.map( fn {first,second} -> {String.to_integer(first), String.to_integer(second)} end)
|> Enum.unzip()
left = Enum.sort(left)
right = Enum.sort(right)
first_answer = Enum.zip(left, right)
|> Enum.map(fn {l,r} -> abs(l-r) end)
|> Enum.sum()
# ── Part 2 ──
right_freqs = Enum.frequencies(right)
defmodule Etc do
def match_val(x, rf) do
{_, freq} = Enum.find(rf, {x, 0}, fn {a,_} -> a == x end)
freq
end
end
second_answer = left
|> Enum.map(fn x -> {x, Etc.match_val(x, right_freqs)} end)
|> Enum.map(fn {x,y} -> x * y end)
|> Enum.sum()
There’s probably a more compact way of doing the unzip/sort/rezip bit in Part1 but I wanted to be able to understand it when I looked back on it .
For Part 2 I struggled to extract the second element of a tuple having just found it, so it ended up in a function that returned the second element. I wanted to write that as an anonymous function but struggled with the syntax so went with the defmodule/def approach.
Here’s mine. Much more coding lines than I’d like but I guess my work bleeds into everything. I like small functions and separation of concerns and doctests and typespecs.
defmodule Day01 do
@type id :: non_neg_integer()
@type pair :: {id(), id()}
@type pairs :: [pair()]
@type distance :: non_neg_integer()
@type similarity :: non_neg_integer()
@spec parse_line(String.t()) :: pair()
def parse_line(line) do
line
|> String.trim()
|> String.split(~r/\s+/)
|> Enum.map(fn text ->
{number, ""} = Integer.parse(text)
number
end)
|> List.to_tuple()
end
@spec parse_input(String.t()) :: [pair()]
def parse_input(input) do
input
|> String.split("\n")
|> Enum.reject(fn line -> line == "" end)
|> Enum.map(&parse_line/1)
end
@spec sum_of_distances(pairs()) :: distance()
def sum_of_distances(input) do
{left, right} = Enum.unzip(input)
left = Enum.sort(left)
right = Enum.sort(right)
left
|> Enum.zip(right)
|> Enum.map(fn {a, b} -> abs(a - b) end)
|> Enum.sum()
end
# @spec similarity_score(pairs()) :: similarity()
def similarity_score(input) do
{left, right} = Enum.unzip(input)
frequencies = Enum.frequencies(right)
left
|> Enum.map(fn n -> n * Map.get(frequencies, n, 0) end)
|> Enum.sum()
end
@doc ~S"""
iex> Day01.part_1("3 4\n4 3\n2 5\n1 3\n3 9\n3 3\n")
11
"""
@spec part_1(String.t()) :: distance()
def part_1(input \\ input()) do
input |> parse_input() |> sum_of_distances()
end
@doc ~S"""
iex> Day01.part_2("3 4\n4 3\n2 5\n1 3\n3 9\n3 3\n")
31
iex> Day01.part_2("3 4\n4 3\n2 3\n1 3\n3 9\n3 3\n")
40
"""
@spec part_2(String.t()) :: similarity()
def part_2(input \\ input()) do
input |> parse_input() |> similarity_score()
end
def input(), do: File.read!("input/day_01.txt")
end
Since I did not want to cheat I only checked the solutions of others post factum and interestingly enough mine is almost identical to @bjorng.
