Refactor 2025

Author: code-shoily

lib/2025/day_01.ex

@@ -0,0 +1,58 @@
+defmodule AdventOfCode.Y2025.Day01 do
+  @moduledoc """
+  --- Day 1: Secret Entrance ---
+  Problem Link: https://adventofcode.com/2025/day/1
+  Difficulty: e
+  Tags: simulation safe-dial
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+
+  def input, do: InputReader.read_from_file(2025, 1)
+
+  def run(input \\ input()) do
+    instructions = parse(input)
+
+    {solve_1(instructions), solve_2(instructions)}
+  end
+
+  defp solve_1(instructions) do
+    {count, _final} =
+      Enum.reduce(instructions, {0, 50}, fn {dir, steps}, {cnt, pos} ->
+        delta = if dir == "L", do: -steps, else: steps
+        new_pos = Integer.mod(pos + delta, 100)
+        new_cnt = if new_pos == 0, do: cnt + 1, else: cnt
+        {new_cnt, new_pos}
+      end)
+
+    count
+  end
+
+  defp solve_2(instructions) do
+    {count, _final} =
+      Enum.reduce(instructions, {0, 50}, fn {dir, steps}, {cnt, pos} ->
+        hits = count_hits(pos, dir, steps)
+        delta = if dir == "L", do: -steps, else: steps
+        new_pos = Integer.mod(pos + delta, 100)
+        {cnt + hits, new_pos}
+      end)
+
+    count
+  end
+
+  defp count_hits(pos, "R", steps) do
+    Integer.floor_div(pos + steps, 100) - Integer.floor_div(pos, 100)
+  end
+
+  defp count_hits(pos, "L", steps) do
+    Integer.floor_div(pos - 1, 100) - Integer.floor_div(pos - steps - 1, 100)
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(fn line ->
+      {side, steps} = String.split_at(line, 1)
+      {side, String.to_integer(steps)}
+    end)
+  end
+end

lib/2025/day_02.ex

@@ -0,0 +1,80 @@
+defmodule AdventOfCode.Y2025.Day02 do
+  @moduledoc """
+  --- Day 2: Gift Shop ---
+  Problem Link: https://adventofcode.com/2025/day/2
+  Difficulty: m
+  Tags: simulation generation string-manipulation math
+  """
+  alias AdventOfCode.Helpers.InputReader
+
+  def input, do: InputReader.read_from_file(2025, 2)
+
+  def run(input \\ input()) do
+    ranges = parse(input)
+    merged = merge_ranges(ranges)
+
+    max_val = merged |> Enum.map(fn {_, hi} -> hi end) |> Enum.max()
+    max_len = max_val |> to_string() |> String.length()
+
+    solution_1 = solve(merged, max_len, :exactly_twice)
+    solution_2 = solve(merged, max_len, :at_least_twice)
+
+    {solution_1, solution_2}
+  end
+
+  defp solve(ranges, max_len, rule) do
+    candidates =
+      for len <- 2..max_len,
+          k <- find_multipliers(len, rule),
+          p = div(len, k),
+          min_x = Integer.pow(10, p - 1),
+          max_x = Integer.pow(10, p) - 1,
+          x <- min_x..max_x do
+        s = to_string(x)
+        String.duplicate(s, k) |> String.to_integer()
+      end
+      |> MapSet.new()
+
+    candidates
+    |> Enum.filter(fn id -> in_ranges?(id, ranges) end)
+    |> Enum.sum()
+  end
+
+  defp find_multipliers(len, :exactly_twice) do
+    if rem(len, 2) == 0, do: [2], else: []
+  end
+
+  defp find_multipliers(len, :at_least_twice) do
+    for k <- 2..len, rem(len, k) == 0, do: k
+  end
+
+  defp in_ranges?(id, ranges) do
+    Enum.any?(ranges, fn {lo, hi} -> id >= lo and id <= hi end)
+  end
+
+  defp merge_ranges(ranges) do
+    ranges
+    |> Enum.sort()
+    |> Enum.reduce([], fn
+      {lo, hi}, [] ->
+        [{lo, hi}]
+
+      {lo, hi}, [{prev_lo, prev_hi} | rest] ->
+        if lo <= prev_hi + 1 do
+          [{prev_lo, max(hi, prev_hi)} | rest]
+        else
+          [{lo, hi}, {prev_lo, prev_hi} | rest]
+        end
+    end)
+    |> Enum.reverse()
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> String.split(~r/[, \n]/, trim: true)
+    |> Enum.map(fn line ->
+      [lo, hi] = String.split(line, "-")
+      {String.to_integer(lo), String.to_integer(hi)}
+    end)
+  end
+end

lib/2025/day_03.ex

@@ -0,0 +1,56 @@
+defmodule AdventOfCode.Y2025.Day03 do
+  @moduledoc """
+  --- Day 3: Lobby ---
+  Problem Link: https://adventofcode.com/2025/day/3
+  Difficulty: m
+  Tags: greedy stack subsequence-optimization
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+
+  def input, do: InputReader.read_from_file(2025, 3)
+
+  def run(input \\ input()) do
+    banks = parse(input)
+
+    {solve(banks, 2), solve(banks, 12)}
+  end
+
+  defp solve(banks, k) do
+    banks
+    |> Enum.map(fn digits -> max_subsequence(digits, k) end)
+    |> Enum.sum()
+  end
+
+  defp max_subsequence(digits, k) do
+    total_len = length(digits)
+    can_drop = total_len - k
+
+    {stack, _can_drop} =
+      Enum.reduce(digits, {[], can_drop}, fn d, {stk, drop} ->
+        {new_stk, new_drop} = pop_greedy(stk, d, drop)
+        {[d | new_stk], new_drop}
+      end)
+
+    stack
+    |> Enum.reverse()
+    |> Enum.take(k)
+    |> Enum.join()
+    |> String.to_integer()
+  end
+
+  defp pop_greedy([top | rest], d, drop) when drop > 0 and d > top do
+    pop_greedy(rest, d, drop - 1)
+  end
+
+  defp pop_greedy(stk, _, drop), do: {stk, drop}
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(fn line ->
+      line
+      |> String.graphemes()
+      |> Enum.map(&String.to_integer/1)
+    end)
+  end
+end

lib/2025/day_05.ex

@@ -0,0 +1,74 @@
+defmodule AdventOfCode.Y2025.Day05 do
+  @moduledoc """
+  --- Day 5: Cafeteria ---
+  Problem Link: https://adventofcode.com/2025/day/5
+  Difficulty: e
+  Tags: simulation ranges interval-merging
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+
+  def input, do: InputReader.read_from_file(2025, 5)
+
+  def run(input \\ input()) do
+    [ranges_raw, ids_raw] = String.split(input, ~r/\n\s*\n/, parts: 2)
+    ranges = parse_ranges(ranges_raw)
+    ids = parse_ids(ids_raw)
+
+    {run_1(ranges, ids), run_2(ranges)}
+  end
+
+  defp run_1(ranges, ids) do
+    merged = merge_ranges(ranges)
+
+    ids
+    |> Enum.count(fn id -> in_ranges?(id, merged) end)
+  end
+
+  defp run_2(ranges) do
+    ranges
+    |> merge_ranges()
+    |> Enum.map(fn {lo, hi} -> hi - lo + 1 end)
+    |> Enum.sum()
+  end
+
+  defp in_ranges?(id, ranges) do
+    Enum.any?(ranges, fn {lo, hi} -> id >= lo and id <= hi end)
+  end
+
+  defp merge_ranges(ranges) do
+    ranges
+    |> Enum.sort()
+    |> Enum.reduce([], fn
+      {lo, hi}, [] ->
+        [{lo, hi}]
+
+      {lo, hi}, [{prev_lo, prev_hi} | rest] ->
+        if lo <= prev_hi + 1 do
+          [{prev_lo, max(hi, prev_hi)} | rest]
+        else
+          [{lo, hi}, {prev_lo, prev_hi} | rest]
+        end
+    end)
+    |> Enum.reverse()
+  end
+
+  defp parse_ranges(data) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(fn line ->
+      [lo, hi] = String.split(line, "-")
+      {String.to_integer(lo), String.to_integer(hi)}
+    end)
+  end
+
+  defp parse_ids(data) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(&String.to_integer/1)
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+  end
+end

lib/2025/day_06.ex

@@ -0,0 +1,117 @@
+defmodule AdventOfCode.Y2025.Day06 do
+  @moduledoc """
+  --- Day 6: Trash Compactor ---
+  Problem Link: https://adventofcode.com/2025/day/6
+  Difficulty: m
+  Tags: grid parsing math
+  """
+
+  def input, do: File.read!("priv/input_files/2025_6.txt")
+
+  def run(input \\ input()) do
+    grid =
+      input
+      |> String.split("\n")
+      |> Enum.reject(&(&1 == ""))
+
+    width = grid |> Enum.map(&String.length/1) |> Enum.max()
+    grid = Enum.map(grid, fn line -> String.pad_trailing(line, width) end)
+
+    blocks = identify_blocks(grid, width)
+
+    {solve_part1(grid, blocks), solve_part2(grid, blocks)}
+  end
+
+  defp identify_blocks(grid, width) do
+    non_space_cols =
+      Enum.reduce(0..(width - 1), [], fn j, acc ->
+        if Enum.all?(grid, fn row -> String.at(row, j) == " " end) do
+          acc
+        else
+          [j | acc]
+        end
+      end)
+      |> Enum.reverse()
+
+    non_space_cols
+    |> Enum.chunk_while(
+      [],
+      fn
+        j, [] -> {:cont, [j]}
+        j, [last | _] = chunk when j == last + 1 -> {:cont, [j | chunk]}
+        j, chunk -> {:cont, Enum.reverse(chunk), [j]}
+      end,
+      fn
+        [] -> {:cont, []}
+        chunk -> {:cont, Enum.reverse(chunk), []}
+      end
+    )
+    |> Enum.map(fn chunk -> {List.first(chunk), length(chunk)} end)
+  end
+
+  defp solve_part1(grid, blocks) do
+    height = length(grid)
+
+    blocks
+    |> Enum.map(fn {start, len} ->
+      numbers =
+        for row_idx <- 0..(height - 2) do
+          grid
+          |> Enum.at(row_idx)
+          |> String.slice(start, len)
+          |> String.replace(" ", "")
+        end
+        |> Enum.reject(&(&1 == ""))
+        |> Enum.map(&String.to_integer/1)
+
+      op = get_op(grid, {start, len})
+      apply_op(numbers, op)
+    end)
+    |> Enum.sum()
+  end
+
+  defp solve_part2(grid, blocks) do
+    height = length(grid)
+
+    blocks
+    |> Enum.reverse()
+    |> Enum.map(fn {start, len} ->
+      numbers =
+        for j <- (start + len - 1)..start//-1 do
+          digits =
+            for row_idx <- 0..(height - 2) do
+              String.at(Enum.at(grid, row_idx), j)
+            end
+            |> Enum.join()
+            |> String.replace(" ", "")
+
+          if digits == "", do: nil, else: String.to_integer(digits)
+        end
+        |> Enum.reject(&is_nil/1)
+
+      op = get_op(grid, {start, len})
+      apply_op(numbers, op)
+    end)
+    |> Enum.sum()
+  end
+
+  defp get_op(grid, {start, len}) do
+    grid
+    |> List.last()
+    |> String.slice(start, len)
+    |> String.trim()
+  end
+
+  defp apply_op([n | rest], "+") do
+    Enum.reduce(rest, n, &Kernel.+/2)
+  end
+
+  defp apply_op([n | rest], "*") do
+    Enum.reduce(rest, n, &Kernel.*/2)
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> String.split("\n", trim: true)
+  end
+end