Solve 2025/7/8

Author: code-shoily

lib/2025/day_07.ex

@@ -0,0 +1,103 @@
+defmodule AdventOfCode.Y2025.Day07 do
+  @moduledoc """
+  --- Day 7: Laboratories ---
+  Problem Link: https://adventofcode.com/2025/day/7
+  Difficulty: l
+  Tags: grid dynamic-programming
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog
+
+  def input, do: InputReader.read_from_file(2025, 7)
+
+  @spec run(binary()) :: {non_neg_integer(), any()}
+  def run(input \\ input()) do
+    input = parse(input)
+
+    {run_1(input), run_2(input)}
+  end
+
+  def parse(data \\ input()) do
+    lines = Transformers.lines(data)
+
+    for {line, r} <- Enum.with_index(lines),
+        {char, c} <- Enum.with_index(String.graphemes(line)),
+        into: %{} do
+      {{r, c}, char}
+    end
+  end
+
+  def run_1(grid) do
+    graph = build_graph(grid)
+    start = find_start(grid)
+
+    reached =
+      Yog.Traversal.Walk.fold_walk(
+        over: graph,
+        from: start,
+        using: :breadth_first,
+        initial: MapSet.new(),
+        with: fn acc, node, _meta ->
+          {:continue, MapSet.put(acc, node)}
+        end
+      )
+
+    reached
+    |> Enum.count(fn
+      {r, c} -> Map.get(grid, {r, c}) == "^"
+      _ -> false
+    end)
+  end
+
+  def run_2(grid) do
+    graph = build_graph(grid)
+    start = find_start(grid)
+    max_r = get_max_r(grid)
+
+    case Yog.Traversal.Sort.topological_sort(graph) do
+      {:ok, sorted} ->
+        counts =
+          Enum.reduce(sorted, %{start => 1}, fn node, acc ->
+            case Map.get(acc, node) do
+              nil ->
+                acc
+
+              count ->
+                Yog.successor_ids(graph, node)
+                |> Enum.reduce(acc, fn succ, inner_acc ->
+                  Map.update(inner_acc, succ, count, &(&1 + count))
+                end)
+            end
+          end)
+
+        counts
+        |> Enum.filter(fn {{r, _}, _} -> r > max_r end)
+        |> Enum.reduce(0, fn {_, n}, sum -> sum + n end)
+
+      {:error, :contains_cycle} ->
+        0
+    end
+  end
+
+  defp get_max_r(grid), do: grid |> Map.keys() |> Enum.map(fn {r, _} -> r end) |> Enum.max()
+
+  defp find_start(grid) do
+    Enum.find_value(grid, fn {pos, char} ->
+      if char == "S", do: pos
+    end)
+  end
+
+  defp build_graph(grid) do
+    Enum.reduce(grid, Yog.directed(), fn {{r, c}, char}, graph ->
+      case char do
+        "^" ->
+          graph
+          |> Yog.add_edge_ensure({r, c}, {r + 1, c - 1}, 1, char)
+          |> Yog.add_edge_ensure({r, c}, {r + 1, c + 1}, 1, char)
+
+        _ ->
+          Yog.add_edge_ensure(graph, {r, c}, {r + 1, c}, 1, char)
+      end
+    end)
+  end
+end

lib/2025/day_08.ex

@@ -0,0 +1,91 @@
+defmodule AdventOfCode.Y2025.Day08 do
+  @moduledoc """
+  --- Day 8: Playground ---
+  Problem Link: https://adventofcode.com/2025/day/8
+  Difficulty: s
+  Tags: union-find
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.DisjointSet
+
+  def input, do: InputReader.read_from_file(2025, 8)
+
+  def run(input \\ input()) do
+    coords = parse(input)
+    edges = build_sorted_edges(coords)
+
+    {run_1(coords, edges), run_2(coords, edges)}
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(fn line ->
+      line
+      |> String.split(",")
+      |> Enum.map(&String.to_integer/1)
+      |> List.to_tuple()
+    end)
+    |> List.to_tuple()
+  end
+
+  def build_sorted_edges(coords) do
+    n = tuple_size(coords)
+
+    for i <- 0..(n - 2),
+        j <- (i + 1)..(n - 1) do
+      {i, j, squared_dist(elem(coords, i), elem(coords, j))}
+    end
+    |> Enum.sort_by(fn {_, _, d} -> d end)
+  end
+
+  defp squared_dist({x1, y1, z1}, {x2, y2, z2}) do
+    dx = x1 - x2
+    dy = y1 - y2
+    dz = z1 - z2
+    dx * dx + dy * dy + dz * dz
+  end
+
+  def run_1(coords, edges \\ nil) do
+    edges = edges || build_sorted_edges(coords)
+    n = tuple_size(coords)
+    dsu = Enum.reduce(0..(n - 1), DisjointSet.new(), fn i, acc -> DisjointSet.add(acc, i) end)
+
+    edges
+    |> Enum.take(1000)
+    |> Enum.reduce(dsu, fn {i, j, _}, acc ->
+      DisjointSet.union(acc, i, j)
+    end)
+    |> DisjointSet.to_lists()
+    |> Enum.map(&length/1)
+    |> Enum.sort(:desc)
+    |> Enum.take(3)
+    |> Enum.product()
+  end
+
+  def run_2(coords, edges \\ nil) do
+    edges = edges || build_sorted_edges(coords)
+    n = tuple_size(coords)
+    dsu = Enum.reduce(0..(n - 1), DisjointSet.new(), fn i, acc -> DisjointSet.add(acc, i) end)
+
+    find_last_edge(edges, dsu, n, coords)
+  end
+
+  defp find_last_edge([{i, j, _} | rest], dsu, num_circuits, coords) do
+    {dsu1, root_i} = DisjointSet.find(dsu, i)
+    {dsu2, root_j} = DisjointSet.find(dsu1, j)
+
+    if root_i != root_j do
+      if num_circuits == 2 do
+        {x1, _, _} = elem(coords, i)
+        {x2, _, _} = elem(coords, j)
+        x1 * x2
+      else
+        dsu3 = DisjointSet.union(dsu2, i, j)
+        find_last_edge(rest, dsu3, num_circuits - 1, coords)
+      end
+    else
+      find_last_edge(rest, dsu2, num_circuits, coords)
+    end
+  end
+end

lib/advent_of_code.ex

@@ -2,9 +2,9 @@ defmodule AdventOfCode do
   @moduledoc """
   Module that solves problem given year and day.
   """
-  @latest_year 2024
+  @latest_year 2025
 
-  @type year() :: 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024
+  @type year() :: 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025
   @type day() :: pos_integer()
 
   @doc """

lib/helpers/generator.ex

@@ -16,64 +16,81 @@ defmodule AdventOfCode.Helpers.Generator do
   - Test cases containing default tests for `run_1` and `run_2` at `test/<year>/day_<day>_test.exs` file
   """
   def run({year, day}) do
-    # Write the input data at `priv/input_files`
-    input_file_path =
-      :advent_of_code
-      |> :code.priv_dir()
-      |> Path.join("input_files")
-      |> Path.join("#{year}_#{day}.txt")
+    padded_day = zero_padded(day)
 
-    input_file =
-      input_file_path
-      |> create_input_file(year, day)
+    # Write the input data at `priv/input_files`
+    input_path = "priv/input_files/#{year}_#{day}.txt"
+    input_result = create_input_file(input_path, year, day)
 
     # Write code files at `lib/<year>/day_<day>.ex`
     code_content =
       @code_template
       |> EEx.eval_file(day: day, year: year, title: get_title(year, day))
 
-    code_file =
-      "lib/#{year}/day_#{zero_padded(day)}.ex"
-      |> create_file(code_content)
+    code_path = "lib/#{year}/day_#{padded_day}.ex"
+    code_result = create_file(code_path, code_content)
 
     # Write test files at `test/<year>/day_<year>_test.exs`
     test_content =
       @test_template
       |> EEx.eval_file(day: day, year: year)
 
-    test_file =
-      "test/#{year}/day_#{zero_padded(day)}_test.exs"
-      |> create_file(test_content)
+    test_path = "test/#{year}/day_#{padded_day}_test.exs"
+    test_result = create_file(test_path, test_content)
 
-    "INPUT: #{input_file}\tCODE: #{code_file}\tTEST: #{test_file}\n"
+    [input_result, code_result, test_result]
   end
 
   defp create_file(path, content) do
     if !File.exists?(path) do
-      File.write(path, content)
+      path |> Path.dirname() |> File.mkdir_p!()
+
+      case File.write(path, content) do
+        :ok -> {:ok, path}
+        {:error, reason} -> {:error, path, reason}
+      end
+    else
+      {:exists, path}
     end
   end
 
   defp fetch_cookie(year, day) do
-    HTTPoison.start()
-
-    "https://adventofcode.com/#{year}/day/#{day}/input"
-    |> HTTPoison.get([{"cookie", "session=#{System.get_env("COOKIE", "")}"}])
-    |> then(fn response ->
-      case response do
-        {:ok, %HTTPoison.Response{body: body}} -> {:ok, body}
-        _ -> nil
-      end
-    end)
+    session_key = System.get_env("AOC_SESSION_KEY")
+
+    if is_nil(session_key) or session_key == "" do
+      {:error, "AOC_SESSION_KEY environment variable is not set"}
+    else
+      HTTPoison.start()
+
+      "https://adventofcode.com/#{year}/day/#{day}/input"
+      |> HTTPoison.get([{"cookie", "session=#{session_key}"}])
+      |> then(fn response ->
+        case response do
+          {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> {:ok, body}
+          {:ok, %HTTPoison.Response{status_code: status}} -> {:error, "Received HTTP #{status}"}
+          {:error, %HTTPoison.Error{reason: reason}} -> {:error, reason}
+          _ -> {:error, "unknown error"}
+        end
+      end)
+    end
   end
 
   defp create_input_file(path, year, day) do
     if !File.exists?(path) do
-      with {:ok, data} <- fetch_cookie(year, day),
-           {:ok, file} <- File.open(path, [:write]),
-           :ok <- IO.write(file, data) do
-        File.close(file)
+      path |> Path.dirname() |> File.mkdir_p!()
+
+      case fetch_cookie(year, day) do
+        {:ok, data} ->
+          case File.write(path, data) do
+            :ok -> {:ok, path}
+            {:error, reason} -> {:error, path, reason}
+          end
+
+        {:error, reason} ->
+          {:error, path, reason}
       end
+    else
+      {:exists, path}
     end
   end
 

lib/mix/tasks/gen.ex

@@ -5,8 +5,8 @@ defmodule Mix.Tasks.Gen do
   Type `mix gen --year <year> --day <day>` to create the boilerplate files for
   solving the problem of the year <year> and day <day>.
 
-  For example, `mix gen --year 2015 --day 2` will generate `lib/2015/day_2.ex`,
-  `lib/data/inputs/2015_2.txt`, and `test/2015/day_2_test.exs` and contain the common
+  For example, `mix gen --year 2015 --day 2` will generate `lib/2015/day_02.ex`,
+  `priv/input_files/2015_2.txt`, and `test/2015/day_02_test.exs` and contain the common
   structure (i.e. module name, file reader function, test cases etc)
   """
 
@@ -25,7 +25,16 @@ defmodule Mix.Tasks.Gen do
       {year, day} ->
         {to_string(year), to_string(day)}
         |> Generator.run()
-        |> Mix.shell().info()
+        |> Enum.each(fn
+          {:ok, path} ->
+            Mix.shell().info([:green, "* created ", :reset, path])
+
+          {:exists, path} ->
+            Mix.shell().info([:yellow, "* skipped ", :reset, path, " (already exists)"])
+
+          {:error, path, reason} ->
+            Mix.shell().error([:red, "* error   ", :reset, path, " (reason: #{inspect(reason)})"])
+        end)
 
       _ ->
         Mix.shell().error("[Usage] #{@usage}")