Advent of Code 2024 - Day 1

I did it in F# and now that I see your Elixir code, mine is exactly the same code (in a different language lol)

The three spaces was this years twone for me and cost me a minute.

Happy Advent Of Code everyone!

Part1:

def run(puzzle) do
  puzzle
  |> parse()
  |> then(fn {l1, l2} -> Enum.zip(Enum.sort(l1), Enum.sort(l2)) end)
  |> Enum.reduce(0, fn {n1, n2}, acc -> acc + abs(n1 - n2) end)
end

def parse(puzzle) do
  puzzle
  |> String.split("\n")
  |> Enum.reduce({[], []}, fn line, {acc1, acc2} ->
    [n1, n2] = String.split(line, "   ")
    {[to_integer(n1) | acc1], [to_integer(n2) | acc2]}
  end)
end

Part2:

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

Pretty fun despite it’s simplicity, but the prompts are getting looong:

defmodule AOC.Y2024.Day1 do
  @moduledoc false

  use AOC.Solution

  @impl true
  def load_data() do
    Data.load_day(2024, 1)
    |> Enum.map(&String.split(&1, ~r/\s+/, trim: true))
    |> Enum.map(fn [a, b] -> {String.to_integer(a), String.to_integer(b)} end)
    |> Array.transpose()
  end

  @impl true
  def part_one([l, r]) do
    l
    |> Enum.sort()
    |> Enum.zip(Enum.sort(r))
    |> General.map_sum(fn {a, b} -> abs(a - b) end)
  end

  @impl true
  def part_two([l, r]) do
    Enum.frequencies(r)
    |> then(fn freq ->
      General.map_sum(l, fn a -> a * Map.get(freq, a, 0) end)
    end)
  end
end

Github: aoc/lib/aoc/y2024/day_1.ex at main · woojiahao/aoc · GitHub (made a whole bunch of utility modules and functions from past years, to reduce code duplication)

Here are my solutions using Livebook:

https://github.com/pehbehbeh/adventofcode/blob/main/2024/01.livemd

Starting very simple, but Elixir shines

It’s basically @bjorng 's solution.

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

It’s the most wonderful time of the year!

https://github.com/sevenseacat/advent_of_code/blob/main/lib/y2024/day01.ex

Part 1:

[_ | rest] = all =
  puzzle_input
  |> String.split(["\n", "   "], trim: true)
  |> Enum.map(& String.to_integer/1)

left_sorted = Enum.take_every(all, 2) |> Enum.sort()
right_sorted = Enum.take_every(rest, 2) |> Enum.sort()

Enum.zip_reduce([left_sorted, right_sorted], 0, fn [a, b], acc ->
  acc + abs(a - b)
end)

Part 2:

[_ | rest] = all =
  puzzle_input
  |> String.split(["\n", "   "], trim: true)
  |> Enum.map(& String.to_integer/1)

left = Enum.take_every(all, 2)
right_frequencies = Enum.take_every(rest, 2) |> Enum.frequencies()

left
|> Enum.reduce(0, fn a, acc ->
  acc + (a * Map.get(right_frequencies, a, 0))
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?

Well, I used KinoAOC — KinoAOC v0.1.7 for Livebook, and it binds the input to puzzle_input automatically

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!