Here’s my day 3 code
This was quite easy. I was afraid Part 2 would be “un-regex-able” and was preparing for hand crafting automata but looks like it wasn’t the case. Also, nice to have that Toboggan reference. I love cross-overs.
Part 1:
defmodule Part1 do def scan(input) do Regex.scan(~r/mul\((\d{1,3}),(\d{1,3})\)/, input, capture: :all_but_first) |> Enum.reduce(0, fn [a, b], acc -> acc + String.to_integer(a) * String.to_integer(b) end) end end Part 2:
defmodule Part2 do def scan(input, enabled \\ :enabled, acc \\ 0) def scan(input, :enabled, acc) do case Regex.split(~r/don't\(\)/, input, parts: 2) do [valid, rest] -> scan(rest, :disabled, acc + Part1.scan(valid)) [valid] -> acc + Part1.scan(valid) end end def scan(input, :disabled, acc) do case Regex.split(~r/do\(\)/, input, parts: 2) do [_invalid, rest] -> scan(rest, :enabled, acc) [_invalid] -> acc end end end 1 Like
Here are my solutions for today. (if another thread for this pops up, I’ll try to delete it. My version of this thread is still pending approval 
)
Part 1:
defmodule Day3.Part1 do def solve() do File.stream!("03/input.txt") |> Enum.reduce( 0, fn line, acc -> acc + (~r/mul\((\d{1,3}),(\d{1,3})\)/ |> Regex.scan(line |> String.trim(), capture: :all_but_first) |> Enum.reduce( 0, fn [a, b], acc -> acc + String.to_integer(a) * String.to_integer(b) end )) end ) |> IO.puts() end end Day3.Part1.solve() Part 2:
defmodule Day3.Part2 do defp sum_part(part) do ~r/mul\((\d{1,3}),(\d{1,3})\)/ |> Regex.scan(part, capture: :all_but_first) |> Enum.reduce( 0, fn [a, b], acc -> acc + String.to_integer(a) * String.to_integer(b) end ) end def solve() do File.stream!("03/input.txt") |> Enum.reduce( {0, true}, fn line, {acc, start_enabled?} -> {acc + (line |> String.trim() |> String.split("do") |> (fn parts -> if start_enabled? do parts else parts |> Enum.drop(1) end end).() |> Enum.filter(&(not String.starts_with?(&1, "n't()"))) |> Enum.map(&sum_part/1) |> Enum.sum()), ~r/do\(\)/ |> Regex.scan(line, capture: :all, return: :index) |> List.last() |> List.last() |> elem(0) > ~r/don't\(\)/ |> Regex.scan(line, capture: :all, return: :index) |> List.last() |> List.last() |> elem(0)} end ) |> elem(0) |> IO.puts() end end Day3.Part2.solve() 2 Likes
I haven’t used regex in a while - made a few dumb mistakes before getting it right, lol.
1 Like
Thanks for your regex. It’s the first time I saw (?>pattern) in a regex.
Here’s my solution:
Part 1
~r/ (?<=mul\() # prefixed by "mul(" (positive lookbehind, not captured) (\d{1,3}) # max-3-digit number (captured) , # matches a comma (not captured) (\d{1,3}) # max-3-digit number (captured) (?=\)) # suffixed by ")" (positive lookahead, not captured) /x |> Regex.scan(puzzle_input, capture: :all_but_first) |> List.flatten() |> Enum.map(&String.to_integer/1) |> Enum.chunk_every(2) |> Enum.map(fn [a, b] -> a * b end) |> Enum.sum() Part 2
~r/ (do\(\)) # matches "do()" (captured) | # or (don't\(\)) # matches "don't()" (captured) | # or (?<=mul\()(\d{1,3}),(\d{1,3})(?=\)) # matches the same pattern as in Part 1, captures only the numbers /x |> Regex.scan(puzzle_input, capture: :all_but_first) |> Enum.map(fn ["do()"] -> :on ["", "don't()"] -> :off ["", "", a, b] -> {String.to_integer(a), String.to_integer(b)} end) |> Enum.reduce({0, :on}, fn :on, {sum, _} -> {sum, :on} :off, {sum, _} -> {sum, :off} {a, b}, {sum, :on} -> {sum + a * b, :on} _, acc -> acc end) |> elem(0) 3 Likes
Hey!
This is my solution for Day 03.
Part 1
Regex.scan(~r/mul\((\d+),(\d+)\)/, puzzle_input, capture: :all_but_first) |> Enum.map(fn [a, b] -> String.to_integer(a) * String.to_integer(b) end) |> Enum.sum() Part 2
Regex.scan(~r/mul\((-?\d+),(-?\d+)\)|do(?:n't)?\(\)/, puzzle_input) |> Enum.reduce({0, :enabled}, fn ["don't()"], {count, _status} -> {count, :disabled} ["do()"], {count, _status} -> {count, :enabled} [_text, a, b], {count, :enabled} -> result = String.to_integer(a) * String.to_integer(b) {result + count, :enabled} [_text, _a, _b], {count, :disabled} -> {count, :disabled} end) |> elem(0) 5 Likes
I just realized I could just have one function with regex as an additional parameter. (In case of first, adding true on both cases unlocks the whole list for processing)
I love it. Saves me a lot of “emptiness” lol.
1 Like
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.
Having tried regexes, I decided to implement a solution in Erlang using the binary syntax to do the parsing:
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.
4 Likes
This is the way.
3 Likes
Just some average-ugly regexes.
3 Likes
More regexes.
I’m not sure why do produces ["", "", "do()"] and don't produces ["", "", "", "don't()"]. The number of empty strings is consistent, but my regex-fu is not enough to figure out why / prevent it.
def part1(input) do Regex.scan(~r/mul\((\d+),(\d+)\)/, input, capture: :all_but_first) |> Enum.map(fn [a, b] -> String.to_integer(a) * String.to_integer(b) end) |> Enum.sum() end def part2(input) do Regex.scan(~r/mul\((\d+),(\d+)\)|(do\(\))|(don't\(\))/, input, capture: :all_but_first) |> Enum.reduce({0, :process}, fn ["", "", "do()"], {sum, _} -> {sum, :process} ["", "", "", "don't()"], {sum, _} -> {sum, :skip} _, {sum, :skip} -> {sum, :skip} [a, b], {sum, :process} -> {sum + String.to_integer(a) * String.to_integer(b), :process} end) |> elem(0) end Empty placeholder for the preceding “do()” in the regex |-s. If you swap them then you will see the reverse scenario
1 Like
Because (do\(\)) is the 3rd capture group, and (don't\(\)) is the 4th in your regex.
2 Likes
I wanted to do binary parsing as well but the regexes are too convenient here, so quick solution like a lot in this thread:
defmodule AdventOfCode.Solutions.Y24.Day03 do alias AoC.Input def parse(input, _part) do String.trim(Input.read!(input)) end def part_one(problem) do ~r/mul\(([0-9]{1,3}),([0-9]{1,3})\)/ |> Regex.scan(problem) |> Enum.reduce(0, fn [_, a, b], acc -> String.to_integer(a) * String.to_integer(b) + acc end) end def part_two(problem) do ~r/(mul\(([0-9]{1,3}),([0-9]{1,3})\)|do\(\)|don't\(\))/ |> Regex.scan(problem) |> Enum.reduce({0, true}, fn ["do()" | _], {acc, _enabled?} -> {acc, true} ["don't()" | _], {acc, _enabled?} -> {acc, false} [_, _, a, b], {acc, true} -> {String.to_integer(a) * String.to_integer(b) + acc, true} [_, _, _, _], {acc, false} -> {acc, false} end) |> elem(0) end end 2 Likes
@code-shoily @Aetherus makes sense, thanks! But how to prevent it while still using capture: :all_but_first? 
Maybe it’s not something that’s worth worrying about 
My todays solution was a much quicker than the other days, and I am posting this in a hurry, trying to get into the next meeting in time…
Though I have to speak a work of warning:
This solution is RegEx free
3 Likes
Part 2 threw me for a loop because the inputs were all separated by lines. But overall pretty fun problem
defmodule AOC.Y2024.Day3 do @moduledoc false use AOC.Solution @mul_regex ~r/mul\((\d+),(\d+)\)/ @do_regex ~r/do\(\)/ @dont_regex ~r/don\'t\(\)/ @impl true def load_data() do Data.load_day(2024, 3) |> Enum.join() end @impl true def part_one(data) do Regex.scan(@mul_regex, data, capture: :all_but_first) |> Enum.map(fn v -> Enum.map(v, &String.to_integer(&1)) end) |> General.map_sum(fn [a, b] -> a * b end) end @impl true def part_two(data) do data |> get_do_instructions() |> Enum.concat(get_dont_instructions(data)) |> Enum.concat(get_mul_instructions(data)) |> Enum.sort(fn a, b -> elem(a, 0) < elem(b, 0) end) |> Enum.reduce({0, :do}, fn {_, :do}, {acc, _} -> {acc, :do} {_, :dont}, {acc, _} -> {acc, :dont} {_, :mul, a, b}, {acc, :do} -> {acc + a * b, :do} {_, :mul, _, _}, {acc, :dont} -> {acc, :dont} end) |> elem(0) end defp get_mul_instructions(data), do: Regex.scan(@mul_regex, data, return: :index) |> Enum.map(fn [{mul_idx, _}, {f, fl}, {s, sl}] -> {mul_idx, :mul, data |> String.slice(f, fl) |> String.to_integer(), data |> String.slice(s, sl) |> String.to_integer()} end) defp get_do_instructions(data), do: Regex.scan(@do_regex, data, capture: :first, return: :index) |> Enum.flat_map(& &1) |> Enum.map(fn {i, _} -> {i, :do} end) defp get_dont_instructions(data), do: Regex.scan(@dont_regex, data, capture: :first, return: :index) |> Enum.flat_map(& &1) |> Enum.map(fn {i, _} -> {i, :dont} end) end 1 Like
Nice!
This made me realize that there is no case in my input where there would be a 4 digit number in the mul expressions.
No Regex and no sub-binaries
defp parse_instructions("mul(" <> rest, acc) do parse_int_1(rest, 0, acc) end defp parse_instructions("do()" <> rest, acc) do parse_instructions(rest, [:do | acc]) end defp parse_instructions("don't()" <> rest, acc) do parse_instructions(rest, [:dont | acc]) end defp parse_instructions(<<_, rest::bytes>>, acc) do parse_instructions(rest, acc) end defp parse_instructions(<<>>, acc) do :lists.reverse(acc) end defp parse_int_1(<<c, rest::bytes>>, inner_acc, outer_acc) when c in ?0..?9 do parse_int_1(rest, inner_acc * 10 + c - ?0, outer_acc) end defp parse_int_1(<<?,, rest::bytes>>, inner_acc, outer_acc) do parse_int_2(rest, 0, [inner_acc | outer_acc]) end defp parse_int_1(<<_, rest::bytes>>, _inner_acc, outer_acc) do parse_instructions(rest, outer_acc) end defp parse_int_2(<<c, rest::bytes>>, inner_acc, outer_acc) when c in ?0..?9 do parse_int_2(rest, inner_acc * 10 + c - ?0, outer_acc) end defp parse_int_2(<<?), rest::bytes>>, r, [l | outer_acc]) do parse_instructions(rest, [{:mul, l, r} | outer_acc]) end defp parse_int_2(<<_, rest::bytes>>, _inner_acc, [_l | outer_acc]) do parse_instructions(rest, outer_acc) end Full: aoc2024/lib/day3.ex at master · ruslandoga/aoc2024 · GitHub
2 Likes