Ever heard of metaprogramming? 
Mine goes up to 12 repetitions and then pattern matches the string which should be technically faster (but I am not sure.)
mudasobwa
Creator of Cure
1
lud
Yeah of course, but I was in rush so actually I just wrote a loop to print the clauses and then pasted them into the module. Quick and dirty 
Edit: well that actually counts as metaprogramming
3
brownerd
defmodule Ben.Day02 do
@moduledoc ~S"""
# Gift Shop
Identify the invalid product IDs
"""
@doc ~S"""
### Example data
11-22,95-115,998-1012,1188511880-1188511890,222220-222224, 1698522-1698528,446443-446449,38593856-38593862,565653-565659, 824824821-824824827,2121212118-2121212124
- The ranges are separated by commas (,)
- each range gives its first ID and last ID separated by a dash (-).
We return an integer indicating the sum of all the invalid IDs found with a 'mirror' sequence like 1010 or 11 or 858858."
iex> part_one("priv/data/ben/day_02_example_data.txt")
1_227_775_554
"""
@spec part_one(String.t()) :: non_neg_integer
def part_one("priv/" <> _rest_of_path = path_to_data) do
path_to_data
|> stream_input()
|> Enum.reduce([], fn
range, acc ->
[Enum.filter(range, &evenly_repeated_sequence_of_digits?/1) | acc]
end)
|> List.flatten()
|> Enum.sum()
end
defp evenly_repeated_sequence_of_digits?(digit) do
half_digit_length = div(digit_length(digit), 2)
divisor_and_modulo = trunc(:math.pow(10, half_digit_length))
digit_of_even_length?(digit) &&
# this compares left half of digit with even length of digits
# to is right half of digits
# no need to convert digit to any other type
div(digit, divisor_and_modulo) == rem(digit, divisor_and_modulo)
end
defp digit_of_even_length?(digit), do: rem(digit_length(digit), 2) == 0
defp digit_length(digit), do: trunc(:math.log10(digit) + 1)
# ------------------------------------------------------------------------------
@doc ~S"""
Now, an ID is invalid if it is made only of some sequence of digits repeated at least twice. So, 12341234 (1234 two times), 123123123 (123 three times), 1212121212 (12 five times), and 1111111 (1 seven times) are all invalid IDs.
iex> part_two("priv/data/ben/day_02_example_data.txt")
4_174_379_265
"""
@spec part_two(String.t()) :: non_neg_integer
def part_two("priv/" <> _rest_of_path = path_to_data) do
path_to_data
|> stream_input()
|> Enum.reduce([], fn
range, acc ->
[Enum.filter(range, &evenly_repeated_or_entirely_repeated_sequence_of_digits?/1) | acc]
end)
|> List.flatten()
|> Enum.sum()
end
defp evenly_repeated_or_entirely_repeated_sequence_of_digits?(digit),
do: evenly_repeated_sequence_of_digits?(digit) || repeated_sequence_of_digits?(digit)
defp repeated_sequence_of_digits?(digit),
do:
digit
|> Integer.to_string()
# Starts with any number except 0
# Has a repeating pattern of digits from [0-9]
# Must end in a digit
|> String.match?(~r/^([1-9]+[0-9]*)\1+$/)
# ------------------------------------------------------------------------------
defp stream_input(input) do
File.read!(input)
|> String.trim()
|> Stream.unfold(&next_word/1)
|> Stream.map(&String.split(&1, "-"))
|> Stream.map(fn [left, right] -> String.to_integer(left)..String.to_integer(right) end)
end
# The next_function for Stream.unfold
defp next_word("") do
# When the accumulator (remaining string) is empty, stop the stream
nil
end
defp next_word(remaining_string) do
case String.split(remaining_string, ",", parts: 2) do
[word, rest] ->
# Yield the word, and use the 'rest' as the next accumulator
{word, rest}
[word] ->
# Yield the final word, and use an empty string "" as the next accumulator
# which will cause the next call to return nil and stop the stream.
{word, ""}
end
end
end
1
BartOtten
Got the answer, then went on to rewrite it faster…
Test with example data: Passed, what can go wrong?!
Final result: slightly too low 
For those wanna figure out my mistake:
part_one: 41294979841 in 286.98ms
part_two: 66497614013 in 280.2ms
defmodule Aoc2025.Solutions.Y25.Day02 do
alias AoC.Input
@max_id_length 10
@max_args Integer.floor_div(@max_id_length, 2)
def parse(input, _part) do
Input.read!(input)
|> String.trim()
|> String.split(",")
end
def part_one(problem), do: solve(problem, :p1)
def part_two(problem), do: solve(problem, :p2)
def solve(problem, mode) do
problem
|> Stream.map(fn x -> String.split(x, "-") end)
|> Stream.map(fn [x, y] -> String.to_integer(x)..String.to_integer(y) end)
|> Enum.flat_map(&check_range(&1, mode))
|> Enum.sum()
end
def check_range(range, mode), do: Enum.map(range, &check_id(mode, Integer.digits(&1)))
# Some macro programming
vars = Macro.generate_unique_arguments(@max_args, __MODULE__)
var_sets = Enum.map(1..@max_args, &Enum.take(vars, &1))
for set <- var_sets do
superset = set ++ set
superset1 = set ++ set ++ set
superset2 = set ++ set ++ set ++ set
superset3 = set ++ set ++ set ++ set ++ set
def check_id(_, unquote(superset) = idl), do: Integer.undigits(idl)
def check_id(:p2, unquote(superset1) = idl), do: Integer.undigits(idl)
def check_id(:p2, unquote(superset2) = idl), do: Integer.undigits(idl)
def check_id(:p2, unquote(superset3) = idl), do: Integer.undigits(idl)
end
def check_id(_, _), do: 0
end
Note to self: examine the whole input file before writing code (I keep using the example data for it, but miss some tricks and optimizations)
1
dompdv
Tried to make it understandable.
defmodule AdventOfCode.Solution.Year2025.Day02 do
import Enum, only: [map: 2, chunk_every: 2, any?: 1, sum: 1]
def part1(input), do: scan(input, 2)
def part2(input), do: scan(input, :number_length)
def scan(input, stop_at) do
sum(for {l, h} <- parse(input), n <- l..h, is_invalid(n, stop_at), do: n)
end
def parse(input) do
input
|> String.trim()
|> String.split(",", trim: true)
|> map(fn r ->
[l, h] = String.split(r, "-")
{String.to_integer(l), String.to_integer(h)}
end)
end
def is_invalid(n, _stop_at) when n <= 9, do: false
def is_invalid(n, stop_at) do
n_into_chars = n |> to_string() |> to_charlist()
number_length = length(n_into_chars)
test_until = if stop_at == :number_length, do: number_length, else: stop_at
# Cut into all sizes of equal pieces (length must be divisible into equal size)
for i <- 2..test_until, rem(number_length, i) == 0 do
n_into_chars |> chunk_every(div(number_length, i)) |> uniform_list?()
end
|> any?()
end
# Alternative: def uniform_list?(l), do: length(Enum.uniq(l)) == 1
def uniform_list?([_a]), do: true
def uniform_list?([a, b | _r]) when a != b, do: false
def uniform_list?([_a, b | r]), do: uniform_list?([b | r])
end
2
vkryukov
look, ma - no brute force!
defmodule Y2025.Day02 do
def digits(a) do
trunc(:math.floor(:math.log10(a))) + 1
end
def pow10(n), do: trunc(:math.pow(10, n))
def multiplier(d, 2), do: pow10(d) + 1
def multiplier(d, n), do: 1 + pow10(d) * multiplier(d, n - 1)
def start_and_multiplier(a, n) do
dig = digits(a)
{d, m} = {div(dig, n), Integer.mod(dig, n)}
if m == 0 do
{div(a, pow10(dig - d)), multiplier(d, n)}
else
{pow10(d), multiplier(d + 1, n)}
end
end
def invalid_ids(a, b, n) do
{start, mult} = start_and_multiplier(a, n)
max_start = pow10(digits(start))
start..(max_start - 1)
|> Enum.reduce_while([], fn i, acc ->
x = i * mult
cond do
x < a -> {:cont, acc}
x > b -> {:halt, Enum.reverse(acc)}
true -> {:cont, [x | acc]}
end
end)
end
def parse(s) do
String.split(s, ",")
|> Enum.map(fn s ->
[a, b] = String.split(s, "-")
[String.to_integer(a), String.to_integer(b)]
end)
end
def part1(s) do
parse(s)
|> Enum.flat_map(fn [a, b] -> invalid_ids(a, b, 2) end)
|> Enum.sum()
end
def all_invalid_ids(a, b) do
2..max(digits(b), 2)
|> Enum.flat_map(fn i -> invalid_ids(a, b, i) end)
|> Enum.uniq()
end
def part2(s) do
parse(s)
|> Enum.flat_map(fn [a, b] -> all_invalid_ids(a, b) end)
|> Enum.sum()
end
end
3
steve-human
Nice, this is the fastest solution I’ve tried. I’m just trying to wrap my head around the math in your start_and_multiplier function
1
vkryukov
The idea is simple, and best illustrated with a few examples:
iex(2)> start_and_multiplier(998,2)
{10, 101}
iex(3)> start_and_multiplier(11,2)
{1, 11}
iex(4)> start_and_multiplier(12345,3)
{10, 10101}
iex(5)> start_and_multiplier(12345678,4)
{12, 1010101}
First start with an observation that repeating a 2 digits number, say 12, three times is the same as multiplying it by 10101. That’s the multiplier part.
The start part is a bit trickier: if the digits of the number a can be divided neatly into n groups of digits, it’s the first such group:
iex(7)> start_and_multiplier(123456, 3)
{12, 10101}
iex(8)> start_and_multiplier(123456, 2)
{123, 1001}
Otherwise, we take the first div(# digits in a, n) digits and take the next power of 10 greater than that number, so e.g., 9 → 10, 23 → 100, etc. The reason is that for numbers like 998, the digits cannot be split evenly in two groups, so the first number we should start with is 1010 = 10 * 101.
1
vkryukov
And so the algorithm is, essentially: invalid ids are all the numbers from [ start * multiplier, (start + 1) * multiplier, (start + 2) * multiplier, ...] that belong to a..b. There is a trick to terminate the loop early, when incrementing start increases the number of digits, at which point multiplier won’t work anymore, and we implicitly use the fact that the difference between a and b is not too large - my algorithm won’t work for a = 10, b = 100000, for example.
2
DavidB
defmodule Day2 do
def file, do: Parser.read_file(2)
def test, do: Parser.read_file("test")
def parse(input) do
input
|> Enum.join()
|> String.split(",")
|> Enum.map(&(&1 |> String.split("-") |> Enum.map(fn a -> String.to_integer(a) end)))
end
def solve(input \\ file()) do
input
|> parse()
|> Enum.reduce([], fn range, acc ->
range
|> find_invalid_ids_in_range(&is_symmetric?/1)
|> Enum.concat(acc)
end)
|> Enum.sum()
end
def solve_two(input \\ file()) do
input
|> parse()
|> Enum.reduce([], fn range, acc ->
range
|> find_invalid_ids_in_range(&contain_pattern?/1)
|> Enum.concat(acc)
end)
|> Enum.sum()
end
def find_invalid_ids_in_range([alpha, omega], filter_function) do
Enum.filter(alpha..omega, &filter_function.(&1))
end
def is_symmetric?(number) do
string = Integer.to_string(number)
length = String.length(string)
{a, b} = String.split_at(string, (length / 2) |> trunc())
a == b
end
def contain_pattern?(number) do
string = Integer.to_string(number)
length = String.length(string)
if length == 1 do
false
else
divide_by = Enum.filter(2..length, fn a -> rem(length, a) == 0 end)
Enum.any?(divide_by, &is_invalid_multiple(string, length, &1))
end
end
def is_invalid_multiple(string, length, divide_by) do
slice_to = trunc(length / divide_by) - 1
pattern = string |> String.slice(0..slice_to)
String.duplicate(pattern, divide_by) == string
end
end
0