defmodule Ben.Day01 do
@moduledoc ~S"""
Day 01 - Secret Entrance
"""
@doc ~S"""
part1/1 takes a string input containing "a sequence of rotation" needed to open a safe to get the password to open the North Pole Base.
However, our security training tells us that we just need to count the amount of times that the dial on the safe is left pointing at 0.
Thus, this function returns the amount of times the dial is left pointing at 0.
### Example data
L68
L30
R48
L5
R60
L55
L1
L99
R14
L8
### Example usage
Input must be a path to a data file in the priv directory.
iex> part1("priv/data/ben/day_01_example_data.txt")
3
iex> part1("hello")
** (ArgumentError) input must be a path to a file in the priv directory
"""
@spec part1(String.t()) :: non_neg_integer
def part1("priv/" <> _rest_of_path = path_to_data) do
path_to_data
|> stream_input()
|> Enum.reduce({50, 0}, &count_zero_positions/2)
|> elem(1)
end
def part1(_incorrect_input),
do: raise(ArgumentError, "input must be a path to a file in the priv directory")
defp count_zero_positions(
<<direction>> <> increment_string = _instruction,
{current_position, total_times_pointing_at_zero} = _accumulator
) do
{increments, _} = Integer.parse(increment_string)
new_position =
case <<direction>> do
"L" -> rem(current_position - increments + 100, 100)
"R" -> rem(current_position + increments, 100)
end
total_times_pointing_at_zero =
if new_position == 0,
do: 1 + total_times_pointing_at_zero,
else: total_times_pointing_at_zero
{new_position, total_times_pointing_at_zero}
end
# ------------------------------------------------------------------------------
@doc ~S"""
Now we need to count the total amount of times the dial points at 0 when executiong each instruction to get the password to the North Pole Base.
iex> part2("priv/data/ben/day_01_example_data.txt")
6
iex> part2("hello")
** (ArgumentError) input must be a path to a file in the priv directory
"""
def part2("priv/" <> _rest_of_path = path_to_data) do
path_to_data
|> stream_input()
|> Enum.reduce({50, 0}, &count_zero_passes/2)
|> elem(1)
end
def part2(_incorrect_input),
do: raise(ArgumentError, "input must be a path to a file in the priv directory")
defp count_zero_passes(
<<direction>> <> increment_string = _instruction,
{current_position, total_times_pointing_at_zero} = _accumulator
) do
{increments, _} = Integer.parse(increment_string)
times_passing_zero = div(increments, 100)
remaining_increments_to_rotate = rem(increments, 100)
new_position =
case <<direction>> do
"L" -> rem(current_position - remaining_increments_to_rotate + 100, 100)
"R" -> rem(current_position + remaining_increments_to_rotate, 100)
end
additional_times_pointing_at_zero =
case <<direction>> do
"L" ->
if current_position != 0 && current_position - remaining_increments_to_rotate <= 0,
do: 1 + times_passing_zero,
else: times_passing_zero
"R" ->
if current_position != 0 && current_position + remaining_increments_to_rotate >= 100,
do: 1 + times_passing_zero,
else: times_passing_zero
end
{new_position, total_times_pointing_at_zero + additional_times_pointing_at_zero}
end
# ------------------------------------------------------------------------------
defp stream_input(input) do
File.stream!(input) |> Stream.map(&String.trim/1)
end
end
brownerd
1
lkuty
I wanted to play a little bit with nimble_parsec. I will try to use it for every parsing job. Usually I use regexes but 1) time to change, 2) and get a more powerful parsing technique.
#!/usr/bin/env elixir
# Advent of Code 2025. Day 1
Mix.install([
{:nimble_parsec, "~> 1.4.2"},
])
defmodule M do
import NimbleParsec
rotation =
choice([string("L"), string("R")])
|> integer(min: 1)
defparsec :rotation, rotation
end
# Part 1
File.stream!("../day01.txt")
|> Stream.map(fn line -> {:ok, [dir, qty], "\n", %{}, _, _} = M.rotation(line) ; {dir, qty} end)
|> Enum.reduce({50, 0}, fn {dir, qty}, {pos, zeroes} ->
pos = Integer.mod(pos + (if dir == "R", do: 1, else: -1) * qty, 100)
{pos, (if pos == 0, do: zeroes+1, else: zeroes)}
end)
|> tap(fn {_pos, zeroes} -> IO.puts("Day 1. Part 1. Number of zeroes: #{zeroes}") end)
# Part 2
File.stream!("../day01.txt")
|> Stream.map(fn line -> {:ok, [dir, qty], "\n", %{}, _, _} = M.rotation(line) ; {dir, qty} end)
|> Enum.reduce({50, 0}, fn {dir, qty}, {pos, zeroes} ->
dist_to_zero = if dir == "L", do: pos, else: Integer.mod(100-pos, 100)
pos = Integer.mod(pos + (if dir == "R", do: 1, else: -1) * qty, 100)
n = div(max(0, qty-dist_to_zero), 100) + (if pos != 0 && qty-dist_to_zero >= 0, do: 1, else: 0)
{pos, zeroes + n}
end)
|> tap(fn {_pos, zeroes} -> IO.puts("Day 1. Part 2. Number of zeroes: #{zeroes}") end)
4
mudasobwa
Creator of Cure
defmodule Day1 do
@input File.read!("day1_1.input")
@phase1 false
if @phase1 do
defp day1_clicks_r(value) when rem(value, 100) == 0, do: 1
defp day1_clicks_r(_value), do: 0
defp day1_clicks_l(current, count), do: day1_clicks_r(current - count)
else
defp day1_clicks_r(value), do: div(value, 100)
defp day1_clicks_l(0, count), do: abs(div(count, 100))
defp day1_clicks_l(current, count), do: abs(div(current - count - 100, 100))
end
defp parse_safe_turn(<<"L", count::binary>>, {current, clicks}) do
count = String.to_integer(count)
{rem(10_000 + current - count, 100), clicks + day1_clicks_l(current, count)}
end
defp parse_safe_turn(<<"R", count::binary>>, {current, clicks}) do
count = String.to_integer(count)
{rem(current + count, 100), clicks + day1_clicks_r(current + count)}
end
def parse_input(input \\ @input, start \\ 50) do
~r/\s+/
|> Regex.split(input, trim: true)
|> Enum.reduce({start, 0}, &parse_safe_turn/2)
end
end
end
2
BartOtten
Late to the party and expected part 2 to trow in some balls, but could easily adapt (add mode to state, add wildguard check_hit clause)
defmodule Aoc2025.Solutions.Y25.Day01 do
alias AoC.Input
@state %{cur: 50, hits: 0, mode: nil}
@min 0
@max 99
def parse(input, _part) do
Input.read!(input) |> String.trim() |> String.split("\n")
end
def part_one(problem), do: run(problem, :p1)
def part_two(problem), do: run(problem, :p2)
def run(problem, mode) do
state =
Enum.reduce(problem, %{@state | mode: mode}, fn line, acc ->
{direction, amount} = parse_ln(line)
goto(acc, direction, amount)
end)
state.hits
end
defp parse_ln("L" <> amount), do: {-1, String.to_integer(amount)}
defp parse_ln("R" <> amount), do: {1, String.to_integer(amount)}
defp turn(%{cur: @min} = state, -1), do: %{state | cur: @max}
defp turn(%{cur: @max} = state, +1), do: %{state | cur: @min}
defp turn(state, direction), do: %{state | cur: state.cur + direction}
defp check_hit(%{cur: 0, mode: :p1} = state, 0), do: %{state | hits: state.hits + 1}
defp check_hit(%{cur: 0, mode: :p2} = state, _), do: %{state | hits: state.hits + 1}
defp check_hit(state, _), do: state
defp goto(state, _, 0),
do: state
defp goto(state, dir, amount),
do: state |> turn(dir) |> check_hit(amount - 1) |> goto(dir, amount - 1)
end
2
mudasobwa
Creator of Cure
dompdv
A little bit late. Also a brute force solution
defmodule AdventOfCode.Solution.Year2025.Day01 do
def dial(input, start, mult, counter_func) do
input
|> String.split("\\n", trim: true)
|> Enum.map(fn
"L" <> rest -> -1 \* String.to_integer(rest)
"R" <> rest -> String.to_integer(rest)
end)
|> Enum.reduce(
{start, 0},
fn delta, {position, score} ->
{next_position(position, delta, mult), score + counter_func.(position, delta, mult)}
end
)
|> elem(1)
end
defp remp(n, p), do: Integer.mod(n, p)
def next_position(current, delta, mult), do: remp(current + delta, mult)
\# Brute force, but simple
def count_hits(start, delta, mult) do
step = if delta < 0, do: -1, else: 1
Enum.count((start + step)..(start + delta)//step, fn i -> remp(i, mult) == 0 end)
end
def stop_at_zero(start, delta, mult) do
if next_position(start, delta, mult) == 0, do: 1, else: 0
end
def part1(input), do: dial(input, 50, 100, &stop_at_zero/3)
def part2(input), do: dial(input, 50, 100, &count_hits/3)
end
1
dompdv
Another brute force solution (just discovering the forum)
defmodule AdventOfCode.Solution.Year2025.Day01 do
def dial(input, start, mult, counter_func) do
input
|> String.split("\n", trim: true)
|> Enum.map(fn
"L" <> rest -> -1 * String.to_integer(rest)
"R" <> rest -> String.to_integer(rest)
end)
|> Enum.reduce(
{start, 0},
fn delta, {position, score} ->
{next_position(position, delta, mult), score + counter_func.(position, delta, mult)}
end
)
|> elem(1)
end
defp remp(n, p), do: Integer.mod(n, p)
def next_position(current, delta, mult), do: remp(current + delta, mult)
# Brute force, but simple
def count_hits(start, delta, mult) do
step = if delta < 0, do: -1, else: 1
Enum.count((start + step)..(start + delta)//step, fn i -> remp(i, mult) == 0 end)
end
def stop_at_zero(start, delta, mult) do
if next_position(start, delta, mult) == 0, do: 1, else: 0
end
def part1(input), do: dial(input, 50, 100, &stop_at_zero/3)
def part2(input), do: dial(input, 50, 100, &count_hits/3)
end
2
vkryukov
defmodule Y2025.Day01 do
def parse(s), do: String.split(s, "\n") |> do_parse()
def do_parse(l) when is_list(l), do: Enum.map(l, &do_parse/1)
def do_parse("L" <> num), do: -String.to_integer(num)
def do_parse("R" <> num), do: String.to_integer(num)
def part1(s) do
s
|> parse()
|> cum_sum(50)
|> Enum.count(&(&1 == 0))
end
def cum_sum(list, start) do
list
|> Enum.reduce([start], fn x, [head | _rest] = list -> [Integer.mod(x + head, 100) | list] end)
end
def part2(s) do
parse(s)
|> count_rotations(50)
end
def count_rotations(list, start) do
list
|> Enum.reduce(
{0, start},
fn x, {count, cur} ->
cond do
x > 0 && cur + x < 100 ->
{count, cur + x}
x < 0 && cur + x > 0 ->
{count, cur + x}
true ->
new_head = Integer.mod(cur + x, 100)
inc = div(abs(cur + x), 100) + if x < 0 && cur != 0, do: 1, else: 0
{count + inc, new_head}
end
end
)
|> elem(0)
end
end
0
DavidB
I removed part 1 when doing part 2, so this is only part 1
defmodule Day1 do
def file, do: Parser.read_file(1)
def test, do: Parser.read_file("test")
def parse(input) do
input
|> Enum.reject(&is_nil/1)
|> Enum.map(&get_number/1)
end
def get_number("R" <> nb), do: {"R", String.to_integer(nb)}
def get_number("L" <> nb), do: {"L", String.to_integer(nb)}
def get_number(a), do: IO.inspect(a)
def solve(input \\ file()) do
input
|> parse()
|> Enum.reduce({50, 0}, fn instructions, {current_pos, counter} ->
calculate_next(current_pos, instructions, counter)
end)
end
# because if you start a 0, the go_back_to_100 will consider you need to add one to the counter
# but you shouldn't because you were already at 0
def calculate_next(0, {"L", number}, counter) do
go_back_to_100(0 - number, counter - 1)
end
def calculate_next(current_nb, {"L", number}, counter) do
go_back_to_100(current_nb - number, counter)
end
def calculate_next(current_nb, {"R", number}, counter) do
go_back_to_100(current_nb + number, counter)
end
def go_back_to_100(100, counter), do: {0, counter + 1}
def go_back_to_100(0, counter), do: {0, counter + 1}
def go_back_to_100(nb, counter) when nb > 99, do: go_back_to_100(nb - 100, counter + 1)
def go_back_to_100(nb, counter) when nb < 0, do: go_back_to_100(100 + nb, counter + 1)
def go_back_to_100(nb, counter), do: {nb, counter}
end
0
adamu
I’m starting late this year, as I was waiting for an offline event I organised today to “work on the first few days”. It turns out I didn’t even finish day 1, thanks to part 2 
I also spent far too long thinking about loops and stuff, before I decided to just brute force every click, which it managed in 3ms.
def part2(rotations) do
Enum.reduce(rotations, {_pos = 50, _password = 0}, fn rotation, {pos, password} ->
new_pos = pos + rotation
step = if pos < new_pos, do: 1, else: -1
password =
for click <- (pos + step)..new_pos//step, reduce: password do
password -> if Integer.mod(click, 100) == 0, do: password + 1, else: password
end
{Integer.mod(new_pos, 100), password}
end)
|> elem(1)
end
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2025/day1.exs
0