Solve 2025/10,11

Author: code-shoily

lib/2025/day_07.ex

@@ -7,6 +7,7 @@ defmodule AdventOfCode.Y2025.Day07 do
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
   alias Yog
+  alias Yog.Traversal.{Sort, Walk}
 
   def input, do: InputReader.read_from_file(2025, 7)
 
@@ -32,7 +33,7 @@ defmodule AdventOfCode.Y2025.Day07 do
     start = find_start(grid)
 
     reached =
-      Yog.Traversal.Walk.fold_walk(
+      Walk.fold_walk(
         over: graph,
         from: start,
         using: :breadth_first,
@@ -54,7 +55,7 @@ defmodule AdventOfCode.Y2025.Day07 do
     start = find_start(grid)
     max_r = get_max_r(grid)
 
-    case Yog.Traversal.Sort.topological_sort(graph) do
+    case Sort.topological_sort(graph) do
       {:ok, sorted} ->
         counts =
           Enum.reduce(sorted, %{start => 1}, fn node, acc ->

lib/2025/day_10.ex

@@ -0,0 +1,214 @@
+defmodule AdventOfCode.Y2025.Day10 do
+  @moduledoc """
+  --- Day 10: Factory ---
+  Problem Link: https://adventofcode.com/2025/day/10
+  Difficulty: l
+  Tags: graph shortest-path bitwise dynamic-programming
+  """
+  import Bitwise
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.Pathfinding.AStar
+
+  def input, do: InputReader.read_from_file(2025, 10)
+
+  def run(input \\ input()) do
+    input = parse(input)
+
+    {run_1(input), run_2(input)}
+  end
+
+  def run_1(input) do
+    input
+    |> Enum.map(&solve_machine_1/1)
+    |> Enum.sum()
+  end
+
+  def run_2(input) do
+    input
+    |> Enum.map(fn m ->
+      Process.put(:memo_p2, %{})
+      res = solve_machine_2(m)
+      Process.delete(:memo_p2)
+      res
+    end)
+    |> Enum.sum()
+  end
+
+  defp solve_machine_1(m) do
+    states = get_button_states(m.buttons_lists)
+    target_mask = m.indicator
+
+    states
+    |> Map.get(target_mask, [])
+    |> Enum.map(fn {_, presses} -> presses end)
+    |> case do
+      [] ->
+        search_machine_1_yog(m)
+
+      list ->
+        Enum.min(list)
+    end
+  end
+
+  defp search_machine_1_yog(%{indicator: target_mask, buttons_mask: buttons_mask}) do
+    successors = fn mask ->
+      Enum.map(buttons_mask, fn btn -> {bxor(mask, btn), 1} end)
+    end
+
+    heuristic = fn mask ->
+      diff = bxor(mask, target_mask)
+      count_set_bits(diff)
+    end
+
+    is_goal = fn mask -> mask == target_mask end
+
+    case AStar.implicit_a_star(0, successors, is_goal, heuristic) do
+      {:ok, cost} -> cost
+      :error -> 0
+    end
+  end
+
+  defp count_set_bits(v) do
+    if v == 0 do
+      0
+    else
+      1 + count_set_bits(v &&& v - 1)
+    end
+  end
+
+  defp solve_machine_2(%{joltage: target_v, buttons_lists: buttons_lists}) do
+    states = get_button_states(buttons_lists)
+    solve_recursive(target_v, states)
+  end
+
+  defp solve_recursive(v, states) do
+    if Enum.all?(v, &(&1 == 0)) do
+      0
+    else
+      memo = Process.get(:memo_p2)
+
+      if Map.has_key?(memo, v) do
+        Map.get(memo, v)
+      else
+        res = compute_recursive(v, states)
+        Process.put(:memo_p2, Map.put(memo, v, res))
+        res
+      end
+    end
+  end
+
+  defp compute_recursive(v, states) do
+    target_parity =
+      v
+      |> Enum.with_index()
+      |> Enum.reduce(0, fn {val, idx}, acc ->
+        if rem(val, 2) == 1, do: acc + (1 <<< idx), else: acc
+      end)
+
+    subsets = Map.get(states, target_parity, [])
+
+    subsets
+    |> Enum.flat_map(fn {inc_v, presses} ->
+      next_v =
+        Enum.zip_with(v, inc_v, fn v_val, inc_val ->
+          v_val - inc_val
+        end)
+
+      if Enum.all?(next_v, &(&1 >= 0)) do
+        next_v_div = Enum.map(next_v, &div(&1, 2))
+        [presses + 2 * solve_recursive(next_v_div, states)]
+      else
+        []
+      end
+    end)
+    |> case do
+      # Infinity
+      [] -> 1_000_000_000
+      list -> Enum.min(list)
+    end
+  end
+
+  defp get_button_states(buttons_lists) do
+    m = length(buttons_lists)
+
+    num_counters =
+      if buttons_lists == [] do
+        0
+      else
+        buttons_lists |> List.flatten() |> Enum.max() |> Kernel.+(1)
+      end
+
+    0..((1 <<< m) - 1)
+    |> Enum.reduce(%{}, fn i, acc ->
+      {parity, inc_v, presses} =
+        Enum.reduce(0..(m - 1), {0, List.duplicate(0, num_counters), 0}, fn j, {p, iv, pr} ->
+          if (i &&& 1 <<< j) != 0 do
+            btn = Enum.at(buttons_lists, j)
+            # Update parity mask
+            p2 = Enum.reduce(btn, p, fn bit, p_acc -> bxor(p_acc, 1 <<< bit) end)
+            # Update increment vector
+            iv2 =
+              Enum.reduce(btn, iv, fn bit, iv_acc -> List.update_at(iv_acc, bit, &(&1 + 1)) end)
+
+            {p2, iv2, pr + 1}
+          else
+            {p, iv, pr}
+          end
+        end)
+
+      Map.update(acc, parity, [{inc_v, presses}], &[{inc_v, presses} | &1])
+    end)
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Enum.map(&parse_line/1)
+  end
+
+  defp parse_line(line) do
+    [[_, indicator_str]] = Regex.scan(~r/\[([.#]+)\]/, line)
+    buttons_matches = Regex.scan(~r/\(([\d,]+)\)/, line)
+    [[_, joltage_str]] = Regex.scan(~r/\{([\d,]+)\}/, line)
+
+    indicator_list =
+      indicator_str
+      |> String.graphemes()
+      |> Enum.map(fn
+        "." -> 0
+        "#" -> 1
+      end)
+
+    indicator_mask =
+      indicator_list
+      |> Enum.with_index()
+      |> Enum.reduce(0, fn {val, idx}, acc ->
+        if val == 1, do: acc + (1 <<< idx), else: acc
+      end)
+
+    buttons_lists =
+      buttons_matches
+      |> Enum.map(fn [_, m] ->
+        m |> String.split(",") |> Enum.map(&String.to_integer/1)
+      end)
+
+    buttons_mask =
+      buttons_lists
+      |> Enum.map(fn indices ->
+        Enum.reduce(indices, 0, fn idx, acc -> acc + (1 <<< idx) end)
+      end)
+
+    joltage =
+      joltage_str
+      |> String.split(",")
+      |> Enum.map(&String.to_integer/1)
+
+    %{
+      num_lights: length(indicator_list),
+      indicator: indicator_mask,
+      buttons_lists: buttons_lists,
+      buttons_mask: buttons_mask,
+      joltage: joltage
+    }
+  end
+end

lib/2025/day_11.ex

@@ -0,0 +1,76 @@
+defmodule AdventOfCode.Y2025.Day11 do
+  @moduledoc """
+  --- Day 11: Reactor ---
+  Problem Link: https://adventofcode.com/2025/day/11
+  Difficulty: m
+  Tags: graph dynamic-programming
+  """
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+
+  def input, do: InputReader.read_from_file(2025, 11)
+
+  def run(input \\ input()) do
+    graph = parse(input)
+
+    {run_1(graph), run_2(graph)}
+  end
+
+  def run_1(graph) do
+    do_count_paths(graph, "you", "out")
+  end
+
+  def run_2(graph) do
+    p1 =
+      do_count_paths(graph, "svr", "dac") *
+        do_count_paths(graph, "dac", "fft") *
+        do_count_paths(graph, "fft", "out")
+
+    p2 =
+      do_count_paths(graph, "svr", "fft") *
+        do_count_paths(graph, "fft", "dac") *
+        do_count_paths(graph, "dac", "out")
+
+    p1 + p2
+  end
+
+  defp do_count_paths(_graph, source, source), do: 1
+
+  defp do_count_paths(graph, source, target) do
+    if Yog.Traversal.reachable?(graph, source, target) do
+      {:ok, order} = Yog.Traversal.topological_sort(graph)
+
+      order
+      |> Enum.reverse()
+      |> Enum.reduce(%{}, fn node, acc ->
+        if node == target do
+          Map.put(acc, node, 1)
+        else
+          graph
+          |> Yog.successor_ids(node)
+          |> Enum.reduce(0, fn succ, sum ->
+            sum + Map.get(acc, succ, 0)
+          end)
+          |> then(&Map.put(acc, node, &1))
+        end
+      end)
+      |> Map.get(source, 0)
+    else
+      0
+    end
+  end
+
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Enum.reduce(Yog.directed(), fn line, g ->
+      [src, dsts_str] = String.split(line, ":", parts: 2)
+
+      dsts_str
+      |> String.trim()
+      |> String.split(" ", trim: true)
+      |> Enum.reduce(g, fn dst, g_acc ->
+        Yog.add_edge_ensure(g_acc, String.trim(src), dst, 1, nil)
+      end)
+    end)
+  end
+end

test/2025/day_10_test.exs

@@ -0,0 +1,12 @@
+defmodule AdventOfCode.Y2025.Day10Test do
+  @moduledoc false
+
+  use ExUnit.Case, async: true
+  @moduletag :y2510
+
+  alias AdventOfCode.Y2025.Day10, as: Solution
+
+  test "Year 2025, Day 10 run/1" do
+    assert Solution.run() == {375, 15_377}
+  end
+end

test/2025/day_11_test.exs

@@ -0,0 +1,12 @@
+defmodule AdventOfCode.Y2025.Day11Test do
+  @moduledoc false
+
+  use ExUnit.Case, async: true
+  @moduletag :y2511
+
+  alias AdventOfCode.Y2025.Day11, as: Solution
+
+  test "Year 2025, Day 11 run/1" do
+    assert Solution.run() == {428, 331_468_292_364_745}
+  end
+end