jack's advent of code 2025 ramblings

given the sample input:

987654321111111
811111111111119
234234234234278
818181911112111

assuming input is the above as one big string,

part 1

define this module:

defmodule TwoSlotBattery do
  def find(bats) do
    [x | [y | _l] = list] = bats

    find({x, y}, list)
  end

  def find({x, y}, [a | [b | _r] = rest]) do
    {x, y} = cond do
      a > x -> {a, b}
      a > y -> {x, a}
      true -> {x, y}
    end

    find({x, y}, rest)
  end

  def find({x, y}, [a | []]) do
    {x, y} = cond do
      a > y -> {x, a}
      true -> {x, y}
    end

    {x, y}
  end
end

and use it here:

input
|> Kino.Input.read()
|> String.split("\n")
|> Enum.map(fn bats ->
  bats = bats |> String.graphemes() |> Enum.map(&String.to_integer/1)

  {x, y} = TwoSlotBattery.find(bats)
  x * 10 + y
end)
|> Enum.sum()

i’ll cover input parsing before going into the module

• split on newline, \n
• split on graphemes
• map those to integers

we get this:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1]

then we call TwoSlotBattery.find, which gives us the two values for the two-sized battery!

the find/1 case is this:

def find(bats) do
  [x | [y | _l] = list] = bats

  find({x, y}, list)
end

lists in elixir are linked lists, so there is special syntax for extracting the head / tail of them

say if you have [1, 2, 3], and want to extract the 1, and have the list [2, 3], you can do:

[x | y] = [1, 2, 3]

x will be 1, y will be the rest of the list, i.e. [2, 3]

[x | [y | _l] = list] = bats

so the first thing i do in find, is extract the 1st and 2nd element from the list, but i actually hold a reference to the list with the second element in it still, so i’m only ‘popping’ one element from the list, and then call:

find({x, y}, list)

which means i ‘consume’ the first item from the list here, put it in x, and then a combined version of them together is the first argument to the recursive step, its considering the first two values being a battery

so for the input line 234234234234278, we’d be starting off with 23, and considering everything 3423... onwards

def find({x, y}, [a | [b | _r] = rest]) do
  {x, y} = cond do
    a > x -> {a, b}
    a > y -> {x, a}
    true -> {x, y}
  end

  find({x, y}, rest)
end

def find({x, y}, [a | []]) do
  {x, y} = cond do
    a > y -> {x, a}
    true -> {x, y}
  end

  {x, y}
end

i then define find/2 with two matches, the first match will only hit when we have two items left in the list we are considering, which means we’re considering the current battery, with a potential future battery

[a | [b | _r] = rest]

we do the same trick to keep a reference to the lits after the first item, even though we’re

{x, y} = cond do
  a > x -> {a, b}
  a > y -> {x, a}
  true -> {x, y}
end

i then use cond, which will return a value depending on a condition, no case matching here

if a is greater than x, it means the value we’re looking at is bigger than the largest digit in our two digit number, so we then make the battery equal to {a, b}, i.e. we ignore our current {x, y} battery, and start a new battery based on where we are considering in the list

if that isn’t true, but the lesser value is greater than our current lesser value, we keep the x, but then replace the y with a

if not, we just keep our existing {x, y} battery, as what we’re looking at isn’t better

then, we hit a tail recursive call to keep going

find({x, y}, rest)

with the rest of the list

the only iffy thing about this, is we will eventually get to the end of the list, so elixir will raise an exception once we get to the last element of the list, since our second argument won’t hit the clause

so, we do this:

def find({x, y}, [a | []]) do
  {x, y} = cond do
    a > y -> {x, a}
    true -> {x, y}
  end

  {x, y}
end

its basically the same thing as before, but we can’t replace x anymore, x is going to be the highest value we can store in that battery slot, so we’re only concerned with replacing the y, or just keeping our current battery

then, we just return the tuple, and its given right back to the caller

...
|> Enum.map(fn bats ->
  bats = bats |> String.graphemes() |> Enum.map(&String.to_integer/1)

  {x, y} = TwoSlotBattery.find(bats)
  x * 10 + y
end)
|> Enum.sum()

back to here, we then just take these values, i make sure it goes from {9, 2} to 92, and sum each line, to get the answer!

part 2

my above solution would probably function… if i wanted a combinatorial explosion of handling cases… so lets see if i can take my previous approach, but make it work for any n list of batteries!

here i hard code 12, but there basically is no reason i couldn’t make it of arbitrary size

defmodule TwelveSlotBattery do
  def find(list) do
    power = 1..12 |> Enum.map(fn _x -> nil end)
    find(power, list)
  end

  def find(power, [a | rest]) do
    rest_len = length(rest)

    replace = power
    |> Enum.with_index()
    |> Enum.find_index(fn {p, i} ->
      cond do
        p == nil -> true
        a > p and (11 - i) <= rest_len -> true
        true -> false
      end
    end)

    power = if replace do
      power = List.replace_at(power, replace, a)

      power = power
      |> Enum.with_index()
      |> Enum.map(fn {elm, index} ->
        if index > replace do
          nil
        else
          elm
        end
      end)

      power
    else
      power
    end

    find(power, rest)
  end

  def find(power, []) do
    power
  end
end

def find(list) do
  power = 1..12 |> Enum.map(fn _x -> nil end)
  find(power, list)
end

so, similar find/1 call, but this time, our {x, y} is no more, we’re going to create a list of nil values the size of the batteries we want, so we can fill it

we pass in the full list here, as we haven’t slotted up the power with the list

def find(power, [a | rest]) do
  rest_len = length(rest)

  replace = power
  |> Enum.with_index()
  |> Enum.find_index(fn {p, i} ->
    cond do
      p == nil -> true
      a > p and (11 - i) <= rest_len -> true
      true -> false
    end
  end)

  power = if replace do
    power = List.replace_at(power, replace, a)

    power = power
    |> Enum.with_index()
    |> Enum.map(fn {elm, index} ->
      if index > replace do
        nil
      else
        elm
      end
    end)

    power
  else
    power
  end

  find(power, rest)
end

bit of a long function, but she’s still tail recursive!

we pluck out a from the list, which is going to be the value we consider if we’re going to put into our batteries

rest_len = length(rest)

replace = power
|> Enum.with_index()
|> Enum.find_index(fn {p, i} ->
  cond do
    p == nil -> true
    a > p and (11 - i) <= rest_len -> true
    true -> false
  end
end)

we iterate over our existing list of twelve values (either nil if we have nothing, or filled with power), and we consider if we should replace the index of the battery with the value we’re on in the list

• if the value in the battery slot is nil, yeah!, slot ‘er up
• if our a > p, and we still have enough values left in the list that this replace wouldn’t leave us with nils later on, slot ‘er up
• if neither, no, don’t replace

power = if replace do
  power = List.replace_at(power, replace, a)

  power = power
  |> Enum.with_index()
  |> Enum.map(fn {elm, index} ->
    if index > replace do
      nil
    else
      elm
    end
  end)

  power
else
  power
end

so we have this replace index, and when we do so, we clear all of the batteries after the slot we’re replacing in, hence after we do the replace, we filter through the power list to make every value we had before nil, so future batteries will just slot into them

and yeah, if we’re not replacing, don’t change power

find(power, rest)

then the recursive step, and once rest is no more:

def find(power, []) do
  power
end

we return power, no fancy steps here to clean up this time!

this means my part 2 solution is a great solution for part 1, but i kinda like keeping my part one solution around for posterity of my thoughts on the part 1 way of solving the problem

but yeah, same as before basically:

input
|> Kino.Input.read()
|> String.split("\n")
|> Enum.map(fn bats ->
  bats = bats |> String.graphemes() |> Enum.map(&String.to_integer/1)

  TwelveSlotBattery.find(bats) |> Enum.join("") |> Integer.parse() |> elem(0)
end)
|> Enum.sum()

input parsing and summing logic is similar, except this time i turn the list of numbers into a string, and then back into a number, and sum

and there we go!

the full solution can be found [here]