#!/usr/bin/env elixir
# Advent of Code 2025. Day 2
Mix.install([
{:nimble_parsec, "~> 1.4.2"},
])
defmodule M do
import NimbleParsec
ranges = repeat(
integer(min: 1)
|> ignore(string("-"))
|> integer(min: 1)
|> tag(:range)
|> optional(ignore(string(",")))
)
defparsec :ranges, ranges
def invalid1(x) do
x = to_string(x)
{a,b} = String.split_at(x, div(String.length(x),2))
a == b
end
def invalid2(x) do
String.match?(to_string(x), ~r/^(\d+?)\1+$/)
end
end
ranges = File.read!("../day02.txt")
|> M.ranges()
|> then(fn {:ok, lst, "\n", %{}, _, _} -> Enum.map(lst, fn {:range, [lo, hi]} -> (lo..hi) end) end)
# Part 1
ranges
|> Enum.flat_map(fn range -> Enum.filter(range, &M.invalid1/1) end)
|> Enum.sum()
|> IO.inspect(label: "Day 02. Part 1")
# Part 2
ranges
|> Enum.flat_map(fn range -> Enum.filter(range, &M.invalid2/1) end)
|> Enum.sum()
|> IO.inspect(label: "Day 02. Part 2")
lkuty
0
adamu
Probably the most interesting thing I did differently was using binary comprehensions to split the string into equal parts:
def repeats?(string, parts \\ 2)
def repeats?(string, parts) when parts > byte_size(string), do: false
def repeats?(string, parts) do
repeats? =
if rem(byte_size(string), parts) > 0 do
# Can't repeat if not divisible
false
else
part_len = div(byte_size(string), parts)
parts = for <<part::binary-size(part_len) <- string>>, do: part
parts |> Enum.uniq() |> length() == 1
end
repeats? or repeats?(string, parts + 1)
end
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2025/day2.exs
0
billylanchantin
Finally getting back to the puzzles…
defmodule Day02 do
def part1(file), do: main(file, &invalid1?/1)
def part2(file), do: main(file, &invalid2?/1)
def main(file, filter) do
rs = file |> File.read!() |> String.replace("\n", "") |> String.split(",") |> Enum.map(&rng/1)
rs
|> Enum.flat_map(fn range -> Enum.filter(range, &(&1 |> Integer.digits() |> filter.())) end)
|> Enum.sum()
end
def rng(string) do
[first, last] = string |> String.split("-") |> Enum.map(&(&1 |> Integer.parse() |> elem(0)))
Range.new(first, last)
end
def invalid1?(digits) do
len = length(digits)
rem(len, 2) == 0 and repeats?(digits, div(len, 2))
end
def invalid2?(digits) do
len = length(digits)
len > 1 and Enum.any?(1..max(div(len, 2), 1), &(rem(len, &1) == 0 and repeats?(digits, &1)))
end
def repeats?(digits, size) do
[chunk | rest] = Enum.chunk_every(digits, size)
Enum.all?(rest, &(&1 == chunk))
end
end
0