Advent of Code 2024 - Day 3

bjorng · December 3, 2024, 6:56am

I went for a solution using regexes and regretted it almost immediately. It took me a while to realize that Regex.run/3 with the :global option will not return multiple solutions (as :re.run/3 would), but that I needed to use Regex.scan/3. Fortunately, having invested a lot of time solving part 1 with a regex, it turned out it was possible to solve also part 2 with a regex.

github.com

bjorng/advent-of-code/blob/main/2024/day03/lib/day03.ex

defmodule Day03 do
  def part1(input) do
    Regex.scan(~r/mul\((\d{1,3}),(\d{1,3})\)/,
      input,
      [capture: :all_but_first])
    |> Enum.map(fn numbers ->
      [a, b] = Enum.map(numbers, &String.to_integer(&1))
      a * b
    end)
    |> Enum.sum
  end

  def part2(input) do
    Regex.scan(~r/(mul)\((\d{1,3}),(\d{1,3})\)|don't\(\)|do\(\)/,
                input)
    |> Enum.map(fn matched ->
      case matched do
        [_, "mul" | numbers]->
          [a, b] = Enum.map(numbers, &String.to_integer(&1))
          a * b

This file has been truncated. show original

Having tried regexes, I decided to implement a solution in Erlang using the binary syntax to do the parsing:

github.com

bjorng/advent-of-code/blob/main/2024/day03/day03.escript

#!/usr/bin/env escript

main(_) ->
    Input = get_input(),
    io:format("Part 1: ~p\n", [part1(Input)]),
    io:format("Part 2: ~p\n", [part2(Input)]).

part1(Input) ->
    lists:sum([N || N <- parse(Input),
                    is_integer(N)]).

part2(Input) ->
    Ops0 = parse(Input),
    Ops = filter_ops(Ops0),
    lists:sum(Ops).

filter_ops([disable|T0]) ->
    T = lists:dropwhile(fun(E) -> E =/= enable end, T0),
    filter_ops(T);
filter_ops([enable|T]) ->

This file has been truncated. show original

UPDATE: After looking at the other solutions, I realized that I only looked for do and don't instead of do() and don't(). That happened to produce the correct result (at least for my input), but I’ve now updated my programs to match the parens too.