Some more graph problems

Author: code-shoily

lib/2015/day_13.ex

@@ -14,10 +14,7 @@ defmodule AdventOfCode.Y2015.Day13 do
   def run(input \\ input()) do
     graph = parse(input)
 
-    {
-      solve(graph),
-      solve(add_me(graph))
-    }
+    {solve(graph), solve(add_me(graph))}
   end
 
   def parse(data \\ input()) do
@@ -58,11 +55,9 @@ defmodule AdventOfCode.Y2015.Day13 do
   end
 
   defp solve(graph) do
-    nodes = Model.all_nodes(graph)
-    [root | _rest] = nodes
+    [root | _rest] = nodes = Model.all_nodes(graph)
     nodes_indexed = Enum.with_index(nodes)
     node_to_idx = Map.new(nodes_indexed)
-    _idx_to_node = Map.new(Enum.map(nodes_indexed, fn {n, i} -> {i, n} end))
 
     weights =
       for {u, i} <- nodes_indexed, {v, j} <- nodes_indexed, into: %{} do

lib/2017/day_07.ex

@@ -3,52 +3,106 @@ defmodule AdventOfCode.Y2017.Day07 do
   --- Day 7: Recursive Circus ---
   Problem Link: https://adventofcode.com/2017/day/7
   Difficulty: m
-  Tags: tree
+  Tags: tree graph
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.Model
+
   def input, do: InputReader.read_from_file(2017, 7)
 
   def run(input \\ input()) do
-    input = parse(input)
+    graph = parse(input)
+
+    {run_1(graph), run_2(graph)}
+  end
+
+  defp run_1(graph) do
+    Yog.arborescence_root(graph)
+  end
 
-    {run_1(input), run_2(input)}
+  defp run_2(graph) do
+    root = run_1(graph)
+    find_imbalance(graph, root)
   end
 
-  defp run_1(input) do
-    input
-    |> Enum.map(fn %{name: name} -> name end)
-    |> MapSet.new()
-    |> MapSet.difference(get_branches(input))
-    |> MapSet.to_list()
-    |> hd()
+  defp find_imbalance(graph, node) do
+    case find_unbalanced_child(graph, node) do
+      {:imbalanced, result} ->
+        result
+
+      {:balanced, _weight} ->
+        nil
+    end
+  end
+
+  defp find_unbalanced_child(graph, node) do
+    children = Model.successor_ids(graph, node)
+    child_results = Enum.map(children, &{unit_and_total_weight(graph, &1), &1})
+
+    imbalanced_case =
+      child_results
+      |> Enum.group_by(fn {{_, total}, _} -> total end)
+      |> Enum.find(fn {_total, nodes} -> length(nodes) == 1 end)
+
+    if imbalanced_case do
+      {imbalanced_weight, [{_res, imbalanced_node}]} = imbalanced_case
+
+      {balanced_weight, _} =
+        Enum.find(child_results, fn {{_, t}, _} -> t != imbalanced_weight end) |> elem(0)
+
+      case find_unbalanced_child(graph, imbalanced_node) do
+        {:imbalanced, result} ->
+          {:imbalanced, result}
+
+        {:balanced, _} ->
+          diff = balanced_weight - imbalanced_weight
+          {:imbalanced, Model.node(graph, imbalanced_node) + diff}
+      end
+    else
+      total =
+        Model.node(graph, node) +
+          (child_results |> Enum.map(fn {{_, t}, _} -> t end) |> Enum.sum())
+
+      {:balanced, total}
+    end
   end
 
-  defp run_2(_input) do
-    {:todo, 2}
+  # Helper to get (own_weight, total_subtree_weight)
+  defp unit_and_total_weight(graph, node) do
+    own = Model.node(graph, node)
+
+    total =
+      Model.successor_ids(graph, node)
+      |> Enum.map(&elem(unit_and_total_weight(graph, &1), 1))
+      |> Enum.sum()
+      |> Kernel.+(own)
+
+    {own, total}
   end
 
   @regex ~r/(?<name>[a-z]+) \((?<weight>\d+)\)( -> (?<branches>(\s*[a-z]+\,?)+))?/
   def parse(data \\ input()) do
-    data
-    |> Transformers.lines()
-    |> Enum.map(fn line ->
-      Regex.named_captures(@regex, line)
-    end)
-    |> Enum.map(fn %{"branches" => branches, "weight" => weight, "name" => name} ->
-      %{
-        branches: (String.trim(branches) != "" && String.split(branches, ", ")) || nil,
-        name: name,
-        weight: String.to_integer(weight)
-      }
-    end)
-  end
+    parsed =
+      data
+      |> Transformers.lines()
+      |> Enum.map(fn line -> Regex.named_captures(@regex, line) end)
+      |> Enum.map(fn %{"branches" => branches, "weight" => weight, "name" => name} ->
+        %{
+          branches: (String.trim(branches) != "" && String.split(branches, ", ")) || [],
+          name: name,
+          weight: String.to_integer(weight)
+        }
+      end)
+
+    graph =
+      Enum.reduce(parsed, Yog.directed(), fn %{name: name, weight: weight}, g ->
+        Model.add_node(g, name, weight)
+      end)
 
-  defp get_branches(parsed_data) do
-    parsed_data
-    |> Enum.flat_map(fn
-      %{branches: nil} -> []
-      %{branches: branches} -> branches
+    Enum.reduce(parsed, graph, fn %{name: name, branches: branches}, g ->
+      Enum.reduce(branches, g, fn branch, g_acc ->
+        Model.add_edge!(g_acc, name, branch, nil)
+      end)
     end)
-    |> MapSet.new()
   end
 end

lib/2020/day_07.ex

@@ -20,15 +20,13 @@ defmodule AdventOfCode.Y2020.Day07 do
   defp solve_part_1(builder) do
     {:ok, shiny_gold_id} = Labeled.get_id(builder, "shiny gold")
     graph = Labeled.to_graph(builder)
-    # Transpose to find containers (walking from gold bag outwards)
     transposed = Transform.transpose(graph)
 
     Implicit.implicit_fold(
       from: shiny_gold_id,
       using: :breadth_first,
       initial: MapSet.new(),
       successors_of: fn id ->
-        # Use transposed graph to find which bags can contain this one
         transposed
         |> Yog.successors(id)
         |> Enum.map(fn {nid, _} -> nid end)
@@ -49,11 +47,9 @@ defmodule AdventOfCode.Y2020.Day07 do
   end
 
   defp count_bags_inside(graph, node_id) do
-    # Successors are the bags contained within this one
     successors = Yog.successors(graph, node_id)
 
     Enum.reduce(successors, 0, fn {child_id, count}, acc ->
-      # Each child bag plus all the bags inside it
       acc + count + count * count_bags_inside(graph, child_id)
     end)
   end
@@ -62,7 +58,6 @@ defmodule AdventOfCode.Y2020.Day07 do
     lines = Transformers.lines(data)
 
     Enum.reduce(lines, Labeled.directed(), fn line, builder ->
-      # Example: "vibrant plum bags contain 5 faded blue bags, 6 dotted black bags."
       [parent, contents] = String.split(line, " bags contain ")
 
       contents

lib/2020/day_24.ex

@@ -3,7 +3,7 @@ defmodule AdventOfCode.Y2020.Day24 do
   --- Day 24: Lobby Layout ---
   Problem Link: https://adventofcode.com/2020/day/24
   Difficulty: m
-  Tags: hexagon walk half-done
+  Tags: hexagon walk
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 
@@ -13,21 +13,63 @@ defmodule AdventOfCode.Y2020.Day24 do
 
   def run(input \\ input()) do
     input = parse(input)
-    {run_1(input), {:todo, 2}}
+    black_tiles = run_1(input)
+
+    {
+      MapSet.size(black_tiles),
+      run_2(black_tiles)
+    }
+  end
+
+  def run_1(steps) do
+    steps
+    |> Enum.map(fn sides -> Enum.reduce(sides, {0, 0}, &walk/2) end)
+    |> Enum.frequencies()
+    |> Enum.filter(fn {_, count} -> rem(count, 2) == 1 end)
+    |> MapSet.new(fn {tile, _} -> tile end)
+  end
+
+  def run_2(black_tiles) do
+    1..100
+    |> Enum.reduce(black_tiles, fn _day, tiles -> simulate(tiles) end)
+    |> MapSet.size()
+  end
+
+  defp simulate(black_tiles) do
+    all_to_check =
+      black_tiles
+      |> Enum.flat_map(fn pos -> [pos | hex_neighbors(pos)] end)
+      |> MapSet.new()
+
+    # 2. Apply rules
+    all_to_check
+    |> Enum.reduce(MapSet.new(), fn pos, acc ->
+      black_neighbor_count =
+        hex_neighbors(pos)
+        |> Enum.count(&MapSet.member?(black_tiles, &1))
+
+      is_black = MapSet.member?(black_tiles, pos)
+
+      should_be_black =
+        if is_black do
+          black_neighbor_count == 1 or black_neighbor_count == 2
+        else
+          black_neighbor_count == 2
+        end
+
+      if should_be_black, do: MapSet.put(acc, pos), else: acc
+    end)
   end
 
-  def run_1(input) do
-    input
-    |> flip()
-    |> black_tiles()
-    |> length()
+  defp hex_neighbors(pos) do
+    ["e", "w", "ne", "nw", "se", "sw"] |> Enum.map(&walk(&1, pos))
   end
 
   @directions ~r/e|w|se|sw|ne|nw/
   def parse(input) do
     for line <- Transformers.lines(input) do
       @directions
-      |> Regex.scan(line, capture: :first)
+      |> Regex.scan(line)
       |> List.flatten()
     end
   end
@@ -38,10 +80,4 @@ defmodule AdventOfCode.Y2020.Day24 do
   defp walk("ne", {x, y}), do: {(Integer.is_even(y) && x + 1) || x, y - 1}
   defp walk("sw", {x, y}), do: {(Integer.is_even(y) && x) || x - 1, y + 1}
   defp walk("se", {x, y}), do: {(Integer.is_even(y) && x + 1) || x, y + 1}
-
-  defp flip(tiles), do: Enum.map(tiles, fn sides -> Enum.reduce(sides, {0, 0}, &walk/2) end)
-
-  defp black_tiles(tiles) do
-    for {_, tile} <- Enum.frequencies(tiles), rem(tile, 2) == 1, do: tile
-  end
 end