I used a regex trick that I just learned yesterday.
My code is messy so won’t share it. But I’m gonna share my trick.
Regex.scan(~r/(?=(\d+))/, "123456789", capture: :all_but_first)
returns
[
["123456789"],
["23456789"],
["3456789"],
["456789"],
["56789"],
["6789"],
["789"],
["89"],
["9"]
]
The key is the (?=) part and the () combined with the capture: :all_but_first option, not the \d+ part in the regex.
I stand corrected (I was in fact thinking of Ruby)! Updated my comment and referenced yours, thanks for teaching me something today.
I’ve not done AoC before so this was a fun diversion for a Saturday morning.
For part 1 I had a simple for comprehension that I think is quite easy to understand:
def extract_integer(text) do
[first, last] =
for <<char <- text>>, char in ?0..?9, reduce: [nil, nil] do
[nil, nil] -> [char - ?0, char - ?0]
[first, _] -> [first, char - ?0]
end
first * 10 + last
end
But it runs in about 500 μs on my MacBook Pro (M1 Max) and uses about 1.6 MB of memory whereas my final solution just uses recursive functions and it finishes in less than 200 μs using less than 128 KB of memory.
def extract_integer_1b(<<>>, [first, last]) do
first * 10 + last
end
def extract_integer_1b(<<char, rest::binary>>, [nil, nil]) when char in ?0..?9 do
extract_integer_1b(rest, [char - ?0, char - ?0])
end
def extract_integer_1b(<<char, rest::binary>>, [first, _]) when char in ?0..?9 do
extract_integer_1b(rest, [first, char - ?0])
end
def extract_integer_1b(<<_char, rest::binary>>, acc) do
extract_integer_1b(rest, acc)
end
The second part just builds on the first part. And, like others, it generates the function heads for the recursive functions from static data. This runs in about 300 μs.
@integer_map %{
"zero" => 0,
"one" => 1,
"two" => 2,
"three" => 3,
"four" => 4,
"five" => 5,
"six" => 6,
"seven" => 7,
"eight" => 8,
"nine" => 9
}
def extract_integer_2(<<>>, [first, last]) do
first * 10 + last
end
for {text, int} <- @integer_map do
last_char = String.last(text)
def extract_integer_2(<<unquote(text) , rest::binary>>, [nil, nil]) do
extract_integer_2(<<unquote(last_char), rest::binary>>, [unquote(int), unquote(int)])
end
def extract_integer_2(<<unquote(text) , rest::binary>>, [first, _]) do
extract_integer_2(<<unquote(last_char), rest::binary>>, [first, unquote(int)])
end
end
def extract_integer_2(<<char, rest::binary>>, [nil, nil]) when char in ?0..?9 do
extract_integer_2(rest, [char - ?0, char - ?0])
end
def extract_integer_2(<<char, rest::binary>>, [first, _]) when char in ?0..?9 do
extract_integer_2(rest, [first, char - ?0])
end
def extract_integer_2(<<_char, rest::binary>>, acc) do
extract_integer_2(rest, acc)
end
Wow some solutions here are cool.
I used a simple regular expressions based approach
https://github.com/code-shoily/advent_of_code/blob/master/lib/2023/day_01.ex
My solution does have to parse all numbers instead of just the first and last, and does not support “oNe” @al2o3cr 
but it’s still fast.
defmodule AdventOfCode.Y23.Day1 do
alias AoC.Input, warn: false
def read_file(file, _part) do
Input.stream!(file, trim: true)
end
def parse_input(input, _part) do
input
end
def part_one(problem) do
problem
|> Enum.map(&String.to_charlist/1)
|> Enum.map(&solve_line_p1/1)
|> Enum.reduce(&Kernel.+/2)
end
defp solve_line_p1(chars) do
digits = Enum.filter(chars, &(&1 in ?0..?9))
{first, last} = first_last(digits)
List.to_integer([first, last])
end
defp first_last(items) do
[h | _] = items
[g | _] = :lists.reverse(items)
{h, g}
end
def part_two(problem) do
problem
|> Enum.map(&solve_line_p2/1)
|> Enum.reduce(&Kernel.+/2)
end
defp solve_line_p2(line) do
line
|> collect_digits([])
|> first_last()
|> then(fn {a, b} -> a * 10 + b end)
end
defp collect_digits(<<c, rest::binary>>, acc) when c in ?0..?9,
do: collect_digits(rest, [c - ?0 | acc])
~w(one two three four five six seven eight nine)
|> Enum.with_index(1)
|> Enum.each(fn {<<c, keep::binary>>, digit} ->
defp collect_digits(<<unquote(c), unquote(keep)::binary, rest::binary>>, acc) do
collect_digits(<<unquote(keep)::binary, rest::binary>>, [unquote(digit) | acc])
end
end)
defp collect_digits(<<_, rest::binary>>, acc), do: collect_digits(rest, acc)
defp collect_digits(<<>>, acc), do: :lists.reverse(acc)
end
You can also use a capture in an positive lookahead to write the whole thing as a one-liner using Perl:
perl -pe 's/^[^\d]*(?=(\d)).*(\d)[^\d]*$/\1\2\n/' input.txt | paste -s -d+ - | bc
The lookahead is critical because otherwise inputs like abc4def won’t find the 4 twice.
Here the my solution that uses macro to generate functions
https://github.com/nallwhy/advent-of-code/blob/main/2023/day_01.livemd
My beginner’s solution
defmodule Day01 do
def part2(str) do
str
|> String.split
|> Enum.map(&spelled_out_words_to_digits/1)
|> Enum.map(&recover_two_digit_number/1)
|> Enum.sum
end
def part1(str) do
str
|> String.split
|> Enum.map(&recover_two_digit_number/1)
|> Enum.sum
end
def recover_two_digit_number(str) do
digits = str
|> String.graphemes
|> Enum.filter(&is_digit?/1)
List.first(digits) <> List.last(digits)
|> String.to_integer
end
def is_digit?(s) do
s |> String.contains?(["0", "1", "2", "3",
"4", "5", "6", "7", "8", "9"])
end
def spelled_out_words_to_digits(str) do
str
|> String.replace("one", "one1one")
|> String.replace("two", "two2two")
|> String.replace("three", "three3three")
|> String.replace("four", "four4four")
|> String.replace("five", "five5five")
|> String.replace("six", "six6six")
|> String.replace("seven", "seven7seven")
|> String.replace("eight", "eight8eight")
|> String.replace("nine", "nine9nine")
end
end
I am using Livebook for my solution.
Kino.FS.file_path("01.txt")
|> File.stream!()
|> Stream.map(fn line ->
matches =
Regex.scan(~r/\d/, line)
|> List.flatten()
first = List.first(matches)
last = List.last(matches)
String.to_integer("#{first}#{last}")
end)
|> Enum.sum()
pattern = ~r/(?=(\d|one|two|three|four|five|six|seven|eight|nine))/
Kino.FS.file_path("01.txt")
|> File.stream!()
|> Stream.map(fn line ->
matches =
Regex.scan(pattern, line, capture: :all_but_first)
|> List.flatten()
|> Enum.map(fn
"one" -> "1"
"two" -> "2"
"three" -> "3"
"four" -> "4"
"five" -> "5"
"six" -> "6"
"seven" -> "7"
"eight" -> "8"
"nine" -> "9"
input -> input
end)
first = List.first(matches)
last = List.last(matches)
String.to_integer(first <> last)
end)
|> Enum.sum()
You can also find the code on GitHub.
Really was not prepared for the overlapping text integers. In fact, based on my example input I assumed that was explicitly NOT supposed to be valid. Does not bode well for my performance long term this year, LOL.
My focus was on using a single pass over the string, i.e., avoiding one pass forward and another pass over the reversed string. Wish I had known about the :global flag for String.replace as I think that would have been cleaner than the regex solution I’m using.
@digit_strings %{
"one" => "1",
"two" => "2",
"three" => "3",
"four" => "4",
"five" => "5",
"six" => "6",
"seven" => "7",
"eight" => "8",
"nine" => "9"
}
@regex ("(?=(" <> (@digit_strings |> Map.keys() |> Enum.join("|") |> Kernel.<>("))")))
|> Regex.compile()
|> elem(1)
def parse(input) do
input
|> Day1.input()
|> Input.lines()
|> Enum.map(fn line ->
Regex.replace(@regex, line, fn _, x -> Map.get(@digit_strings, x) end)
end)
end
def do_solve(data) do
data
|> Enum.map(fn line ->
first_and_last_ints(line)
|> String.to_integer()
end)
|> Enum.sum()
end
defp first_and_last_ints(line) when is_binary(line) do
line
|> String.graphemes()
|> Enum.reduce({"", nil}, fn g, {s, last} ->
with {i, ""} <- Integer.parse(g) do
if s == "" do
{s <> "#{i}", i}
else
{s, i}
end
else
_ ->
{s, last}
end
end)
|> append_last()
end
defp append_last({s, i}), do: s <> "#{i}"