jack's advent of code 2025 ramblings

given the sample input:

..@@.@@@@.
@@@.@.@.@@
@@@@@.@.@@
@.@@@@..@.
@@.@@@@.@@
.@@@@@@@.@
.@.@.@.@@@
@.@@@.@@@@
.@@@@@@@@.
@.@.@@@.@.

assuming input is the above as one big string,

part 1

grid = input
  |> Kino.Input.read()
  |> String.split("\n")
  |> Enum.map(fn row ->
    String.graphemes(row) |> Enum.map(fn
      "." -> :.
      "@" -> :@
    end)
  end)

input parse, turn the strings into atoms, this spits out:

[
  [:., :., :@, :@, :., :@, :@, :@, :@, :.],
  [:@, :@, :@, :., :@, :., :@, :., :@, :@],
  [:@, :@, :@, :@, :@, :., :@, :., :@, :@],
  [:@, :., :@, :@, :@, :@, :., :., :@, :.],
  [:@, :@, :., :@, :@, :@, :@, :., :@, :@],
  [:., :@, :@, :@, :@, :@, :@, :@, :., :@],
  [:., :@, :., :@, :., :@, :., :@, :@, :@],
  [:@, :., :@, :@, :@, :., :@, :@, :@, :@],
  [:., :@, :@, :@, :@, :@, :@, :@, :@, :.],
  [:@, :., :@, :., :@, :@, :@, :., :@, :.]
]

defmodule PaperBoy do
  def get_at(grid, {x, y}) do
    if x < 0 or y < 0 do
      nil
    else
      row = Enum.at(grid, y)

      if is_nil(row) do
        nil
      else
        Enum.at(row, x)
      end
    end
  end

  def can_forklift(grid, {x, y}) do
    value = get_at(grid, {x, y})

    if value == :@ do
      check_surronding(grid, {x, y})
    else
      :.
    end
  end

  def check_surronding(grid, {x, y}) do
    paper_count = for xp <- -1..1 do
      for yp <- -1..1 do
        if xp == 0 and yp == 0 do
          0
        else
          x = xp + x
          y = yp + y
          value = get_at(grid, {x, y})

          if value == :@ do
            1
          else
            0
          end
        end
      end
    end
    |> List.flatten()
    |> Enum.sum()

    if paper_count < 4 do
      :x
    else
      :@
    end
  end
end

size = length(grid)

marked_grid = for y <- 0..(size - 1) do
  for x <- 0..(size - 1) do
    PaperBoy.can_forklift(grid, {x, y})
  end
end

good ol PaperBoy

i start by taking the grid i just parsed, and iterating over it using two for loops to get every {x, y} point on the grid:

size = length(grid)

marked_grid = for y <- 0..(size - 1) do
  for x <- 0..(size - 1) do
    PaperBoy.can_forklift(grid, {x, y})
  end
end

i loop from y then x, since when i address the grid, i’ll first be handling its rows, then columns, so y first, then x

can_forklift/2 takes in the grid, and a tuple of the x/y i’m checking

def can_forklift(grid, {x, y}) do
  value = get_at(grid, {x, y})

  if value == :@ do
    check_surronding(grid, {x, y})
  else
    :.
  end
end

we first get the value, using our own get_at util, and if its :@, we check its surrondings, if not, return :., keeping it as-is

get_at/2 is defined as so:

def get_at(grid, {x, y}) do
  if x < 0 or y < 0 do
    nil
  else
    row = Enum.at(grid, y)

    if is_nil(row) do
      nil
    else
      Enum.at(row, x)
    end
  end
end

i’d love to be shown this exist somewhere in the stdlib, but Enum.at if passed a negative number, will wrap, which i don’t want!

so this function is a bit heavy, we basically just check to make sure if either number is negative (its out of bounds, and would trigger Enum.at wrapping), we return nil

if not, we get the row, which might be out of bounds for being too big, so we also nil return, and if not, we get the x, which might be nil, but that will then be handled by the caller

def check_surronding(grid, {x, y}) do
  paper_count = for xp <- -1..1 do
    for yp <- -1..1 do
      if xp == 0 and yp == 0 do
        0
      else
        x = xp + x
        y = yp + y
        value = get_at(grid, {x, y})

        if value == :@ do
          1
        else
          0
        end
      end
    end
  end
  |> List.flatten()
  |> Enum.sum()

  if paper_count < 4 do
    :x
  else
    :@
  end
end

check_surronding/2 is the meat

this gets is a neighbor-finding matrix:

for xp <- -1..1 do
  for yp <- -1..1 do
    # find real x,y, handle...
  end
end

we use this to find the value of each surronding location, with our existing ‘safe’ get_at/1 function, we also skip when xp and yp are 0, i.e. we are on the cell we are checking, not a neighbor

and yeah, we see if its a roll, i.e. :@, and return 1, if its not, return 0

we then sum each of these values, and if its less than 4, return :x, if not, return :@

we return :x here, because then we actually end up with a grid that looks like how the sample displays it!

[
  [:., :., :x, :x, :., :x, :x, :@, :x, :.],
  [:x, :@, :@, :., :@, :., :@, :., :@, :@],
  [:@, :@, :@, :@, :@, :., :x, :., :@, :@],
  [:@, :., :@, :@, :@, :@, :., :., :@, :.],
  [:x, :@, :., :@, :@, :@, :@, :., :@, :x],
  [:., :@, :@, :@, :@, :@, :@, :@, :., :@],
  [:., :@, :., :@, :., :@, :., :@, :@, :@],
  [:x, :., :@, :@, :@, :., :@, :@, :@, :@],
  [:., :@, :@, :@, :@, :@, :@, :@, :@, :.],
  [:x, :., :x, :., :@, :@, :@, :., :x, :.]
]

marked_grid
|> List.flatten()
|> Enum.count(&(&1 == :x))

we than flatten the grid into a single list, an count the :x values!

part 2

defmodule PaperMan do
  def collect_rolls(grid, rolls \\ 0) do
    size = length(grid)

    marked_grid = for y <- 0..(size - 1) do
      for x <- 0..(size - 1) do
        PaperBoy.can_forklift(grid, {x, y})
      end
    end

    marked_count = count_marked_grid(marked_grid)

    if marked_count == 0 do
      rolls
    else
      cleaned_grid = marked_grid
        |> Enum.map(fn row ->
          row
          |> Enum.map(fn
            :x -> :.
            x -> x
          end)
        end)

      collect_rolls(cleaned_grid, rolls + marked_count)
    end
  end

  def count_marked_grid(marked_grid) do
    marked_grid
    |> List.flatten()
    |> Enum.count(&(&1 == :x))
  end
end

PaperMan.collect_rolls(grid)

when a PaperBoy isn’t enough, you reach for a PaperMan…

now thankfully, PaperBoy basically is intact from when i did my part 1, me trying to be clever and basically return a new grid with the xs marked was actually a good starting point for part 2

def collect_rolls(grid, rolls \\ 0) do
  size = length(grid)

  marked_grid = for y <- 0..(size - 1) do
    for x <- 0..(size - 1) do
      PaperBoy.can_forklift(grid, {x, y})
    end
  end

  marked_count = count_marked_grid(marked_grid)

  ...

this is similar code as to before, we just get the marked_grid like we just did, and count the number of spaces a forklift can go

  if marked_count == 0 do
    rolls
  else
    cleaned_grid = marked_grid
      |> Enum.map(fn row ->
        row
        |> Enum.map(fn
          :x -> :.
          x -> x
        end)
      end)

    collect_rolls(cleaned_grid, rolls + marked_count)
  end
end

except now, if we found any forklifts, we clear them out by filtering over the grid, removing all the :x values, and parsing again!

and right before we parse, we count how many we found marked on that run, and add it to a running total

once we run into a grid that we can mark no more, we return how many rolls we marked

nice!

i think my answer is quite slow… but its an answer

the full solution can be found [here]