Refactor away from GenServer

Author: code-shoily

lib/2015/day_07.ex

@@ -3,111 +3,84 @@ defmodule AdventOfCode.Y2015.Day07 do
   --- Day 7: Some Assembly Required ---
   Problem Link: https://adventofcode.com/2015/day/7
   Difficulty: m
-  Tags: genserver data-modelling op-code
+  Tags: graph dag logic-gates bitwise
   """
+  import Bitwise
   alias AdventOfCode.Helpers.{InputReader, Transformers}
-  alias AdventOfCode.Y2015.Day07.ControlPanel
 
   def input, do: InputReader.read_from_file(2015, 7)
 
-  @bin_ops ~w/RSHIFT LSHIFT AND OR/
-
   def run(input \\ input()) do
-    parsed_input = parse(input)
-    solution_1 = run_1(parsed_input)
-    solution_2 = run_2(parsed_input, solution_1)
+    wires = parse(input)
 
-    {solution_1, solution_2}
-  end
+    values_1 = solve_circuit(wires)
+    solution_1 = values_1["a"]
 
-  defp run_1(parsed_input) do
-    process_and_get_signal(parsed_input, "a")
-  end
+    wires_2 = Map.put(wires, "b", {:assign, [solution_1]})
+    values_2 = solve_circuit(wires_2)
+    solution_2 = values_2["a"]
 
-  defp run_2({assignments, relations}, override) do
-    assignments
-    |> Enum.map(fn
-      {"b", assignment} -> {"b", Map.merge(assignment, %{relation: {:assign, override}})}
-      assignment -> assignment
-    end)
-    |> then(fn assignments -> {assignments, relations} end)
-    |> process_and_get_signal("a")
+    {solution_1, solution_2}
   end
 
-  def parse(data \\ input()) do
-    data
-    |> Transformers.lines()
-    |> Enum.map(&tokenize/1)
-    |> Map.new(fn {instruction, wire} ->
-      {wire, %{relation: instruction, providers: get_providers(instruction)}}
-    end)
-    |> Enum.split_with(fn
-      {_, %{providers: []}} -> true
-      _ -> false
-    end)
-  end
+  defp solve_circuit(wires) do
+    edges =
+      for {target, {_op, args}} <- wires,
+          arg <- args,
+          is_binary(arg),
+          do: {arg, target, 1}
 
-  # --- <Solution Functions> ---
-  defp process_and_get_signal({assignments, relations} = instructions, wire) do
-    ControlPanel.start_servers()
+    graph =
+      Map.keys(wires)
+      |> Enum.reduce(Yog.directed(), fn wire, g -> Yog.add_node(g, wire, nil) end)
+      |> Yog.add_edges!(edges)
 
-    ControlPanel.create_wires(instructions)
-    ControlPanel.build_dependencies(relations)
-    ControlPanel.provide_signals(assignments)
+    {:ok, sorted} = Yog.Traversal.topological_sort(graph)
 
-    result = ControlPanel.get_signal(wire)
+    Enum.reduce(sorted, %{}, fn wire, values ->
+      {op, args} = wires[wire]
 
-    ControlPanel.stop_servers()
+      arg_vals =
+        Enum.map(args, fn
+          arg when is_integer(arg) -> arg
+          arg when is_binary(arg) -> Map.get(values, arg)
+        end)
 
-    result
-  end
-
-  defp tokenize(line) do
-    line
-    |> String.split("->")
-    |> then(fn [lhs, rhs] ->
-      {parse_instruction(lhs), String.trim(rhs)}
+      Map.put(values, wire, compute(op, arg_vals))
     end)
   end
 
-  defp get_providers(relation) do
-    case relation do
-      {_, value} when is_binary(value) ->
-        [value]
-
-      {_, value_a, value_b} when is_binary(value_a) and is_binary(value_b) ->
-        [value_a, value_b]
-
-      {_, value, _} when is_binary(value) ->
-        [value]
+  defp compute(:assign, [x]), do: x
+  defp compute(:not, [x]), do: bnot(x) &&& 0xFFFF
+  defp compute(:and, [x, y]), do: x &&& y &&& 0xFFFF
+  defp compute(:or, [x, y]), do: (x ||| y) &&& 0xFFFF
+  defp compute(:lshift, [x, y]), do: x <<< y &&& 0xFFFF
+  defp compute(:rshift, [x, y]), do: x >>> y &&& 0xFFFF
 
-      {_, _, value} when is_binary(value) ->
-        [value]
-
-      _ ->
-        []
-    end
+  def parse(data \\ input()) do
+    data
+    |> Transformers.lines()
+    |> Map.new(fn line ->
+      [lhs, rhs] = String.split(line, " -> ")
+      {rhs, parse_op(lhs)}
+    end)
   end
 
-  defp parse_instruction(s) do
-    case Regex.split(~r/\s+/, s, trim: true) do
-      ["NOT", value] ->
-        {:not, sanitize(value)}
-
-      [value_1, op, value_2] when op in @bin_ops ->
-        {String.to_atom(String.downcase(op)), sanitize(value_1), sanitize(value_2)}
-
-      [value] ->
-        {:assign, sanitize(value)}
+  defp parse_op(s) do
+    case String.split(s) do
+      ["NOT", x] -> {:not, [val(x)]}
+      [x, "AND", y] -> {:and, [val(x), val(y)]}
+      [x, "OR", y] -> {:or, [val(x), val(y)]}
+      [x, "LSHIFT", y] -> {:lshift, [val(x), val(y)]}
+      [x, "RSHIFT", y] -> {:rshift, [val(x), val(y)]}
+      [x] -> {:assign, [val(x)]}
     end
   end
 
-  defp sanitize(value) do
-    case Integer.parse(value) do
-      {value, ""} -> value
-      :error -> value
+  defp val(s) do
+    case Integer.parse(s) do
+      {n, ""} -> n
+      _ -> s
     end
   end
-
-  # --- </Solution Functions> ---
 end