Taking care of some slow solutions

Author: code-shoily

lib/2016/day_12.ex

@@ -3,76 +3,128 @@ defmodule AdventOfCode.Y2016.Day12 do
   --- Day 12: Leonardo's Monorail ---
   Problem Link: https://adventofcode.com/2016/day/12
   Difficulty: s
-  Tags: slow op-code
+  Tags: assembled-optimization assembunny
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2016, 12)
 
-  @tokens ~w/a b c d cpy inc dec jnz/
-  @regs %{"a" => 0, "b" => 0, "c" => 0, "d" => 0}
-
   def run(input \\ input()) do
     instructions = parse(input)
+    instr_tuple = List.to_tuple(instructions)
+    size = tuple_size(instr_tuple)
 
-    solution_1 = Task.async(fn -> run_1(instructions) end)
-    solution_2 = Task.async(fn -> run_2(instructions) end)
-
-    {
-      Task.await(solution_1, :infinity),
-      Task.await(solution_2, :infinity)
-    }
-  end
-
-  def run_1(instructions) do
-    Map.get(exec(instructions, @regs, 0, Enum.count(instructions)), "a")
-  end
+    task_1 = Task.async(fn -> solve(instr_tuple, {0, 0, 0, 0}, 0, size) end)
+    task_2 = Task.async(fn -> solve(instr_tuple, {0, 0, 1, 0}, 0, size) end)
 
-  def run_2(instructions) do
-    Map.get(exec(instructions, %{@regs | "c" => 1}, 0, Enum.count(instructions)), "a")
+    {Task.await(task_1, :infinity), Task.await(task_2, :infinity)}
   end
 
   def parse(data) do
     data
     |> Transformers.lines()
-    |> Enum.map(fn instruction ->
-      instruction
-      |> String.split(" ")
-      |> Enum.map(&sanitize/1)
+    |> Enum.map(fn line ->
+      String.split(line, " ") |> Enum.map(&sanitize/1)
     end)
-    |> Enum.with_index()
-    |> Map.new(fn {cmd, idx} -> {idx, cmd} end)
   end
 
-  defp exec(_, regs, s, s), do: regs
+  # Use atoms for registers to distinguish from constant integers
+  defp sanitize(val) do
+    case val do
+      "a" ->
+        :a
 
-  defp exec(cmds, regs, idx, s) do
-    case cmds[idx] do
-      ["cpy", val, reg] when is_integer(val) ->
-        exec(cmds, %{regs | reg => val}, idx + 1, s)
+      "b" ->
+        :b
 
-      ["cpy", reg_val, reg] ->
-        exec(cmds, %{regs | reg => regs[reg_val]}, idx + 1, s)
+      "c" ->
+        :c
 
-      ["inc", reg] ->
-        exec(cmds, %{regs | reg => regs[reg] + 1}, idx + 1, s)
+      "d" ->
+        :d
 
-      ["dec", reg] ->
-        exec(cmds, %{regs | reg => regs[reg] - 1}, idx + 1, s)
-
-      ["jnz", 0, _] ->
-        exec(cmds, regs, idx + 1, s)
-
-      ["jnz", val, step] when is_integer(val) ->
-        exec(cmds, regs, idx + step, s)
-
-      ["jnz", reg_val, step] ->
-        exec(cmds, regs, jump_on_nz(regs[reg_val], idx, step), s)
+      other ->
+        case Integer.parse(other) do
+          {n, ""} -> n
+          _ -> other
+        end
     end
   end
 
-  defp jump_on_nz(val, idx, step), do: idx + ((val == 0 && 1) || step)
+  defp solve(_, {a, _, _, _}, pc, size) when pc >= size, do: a
+
+  defp solve(cmds, regs, pc, size) do
+    case elem(cmds, pc) do
+      ["inc", r1] ->
+        # Loop Optimization: Add R2 to R1 and zero out R2
+        if pc + 2 < size do
+          case elem(cmds, pc + 1) do
+            ["dec", r2] ->
+              case elem(cmds, pc + 2) do
+                ["jnz", ^r2, -2] ->
+                  val = get_reg(regs, r1) + get_reg(regs, r2)
+                  solve(cmds, put_reg(regs, r1, val) |> put_reg(r2, 0), pc + 3, size)
+
+                _ ->
+                  val = get_reg(regs, r1) + 1
+                  solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+              end
+
+            _ ->
+              val = get_reg(regs, r1) + 1
+              solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+          end
+        else
+          val = get_reg(regs, r1) + 1
+          solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+        end
+
+      ["dec", r1] ->
+        # Loop Optimization: dec r1; inc r2; jnz r1 -2
+        if pc + 2 < size do
+          case elem(cmds, pc + 1) do
+            ["inc", r2] ->
+              case elem(cmds, pc + 2) do
+                ["jnz", ^r1, -2] ->
+                  val = get_reg(regs, r2) + get_reg(regs, r1)
+                  solve(cmds, put_reg(regs, r2, val) |> put_reg(r1, 0), pc + 3, size)
+
+                _ ->
+                  val = get_reg(regs, r1) - 1
+                  solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+              end
+
+            _ ->
+              val = get_reg(regs, r1) - 1
+              solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+          end
+        else
+          val = get_reg(regs, r1) - 1
+          solve(cmds, put_reg(regs, r1, val), pc + 1, size)
+        end
+
+      ["cpy", src, target] ->
+        val = get_reg(regs, src)
+        solve(cmds, put_reg(regs, target, val), pc + 1, size)
+
+      ["jnz", src, step] ->
+        val = get_reg(regs, src)
+        new_pc = if val != 0, do: pc + step, else: pc + 1
+        solve(cmds, regs, new_pc, size)
+    end
+  end
 
-  defp sanitize(reg) when reg in @tokens, do: reg
-  defp sanitize(reg), do: String.to_integer(reg)
+  # Helper functions for O(1) register access using pattern matching
+  @compile {:inline, get_reg: 2, put_reg: 3}
+  defp get_reg({a, _, _, _}, :a), do: a
+  defp get_reg({_, b, _, _}, :b), do: b
+  defp get_reg({_, _, c, _}, :c), do: c
+  defp get_reg({_, _, _, d}, :d), do: d
+  # It's a constant integer
+  defp get_reg(_, val), do: val
+
+  defp put_reg({_, b, c, d}, :a, v), do: {v, b, c, d}
+  defp put_reg({a, _, c, d}, :b, v), do: {a, v, c, d}
+  defp put_reg({a, b, _, d}, :c, v), do: {a, b, v, d}
+  defp put_reg({a, b, c, _}, :d, v), do: {a, b, c, v}
 end

lib/2017/day_13.ex

@@ -3,18 +3,25 @@ defmodule AdventOfCode.Y2017.Day13 do
   --- Day 13: Packet Scanners ---
   Problem Link: https://adventofcode.com/2017/day/13
   Difficulty: s
-  Tags: sequence slow
+  Tags: sequence optimization
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2017, 13)
 
   def run(input \\ input()) do
-    input = parse(input)
-    limit = Enum.max(Map.keys(input))
+    # Optimization: Store scanners as a list of {pos, period} tuples
+    scanners =
+      input
+      |> parse()
+      |> Enum.map(fn {pos, range} -> {pos, 2 * (range - 1), range} end)
 
-    task_1 = Task.async(fn -> run_1(input, limit) end)
-    task_2 = Task.async(fn -> run_2(input, limit) end)
+    # Scanners with smaller periods are more likely to catch us early,
+    # so sorting them can speed up Enum.any? short-circuiting in Part 2.
+    sorted_scanners = Enum.sort_by(scanners, fn {_, period, _} -> period end)
+
+    task_1 = Task.async(fn -> solve_1(scanners) end)
+    task_2 = Task.async(fn -> solve_2(sorted_scanners) end)
 
     {Task.await(task_1, :infinity), Task.await(task_2, :infinity)}
   end
@@ -23,42 +30,23 @@ defmodule AdventOfCode.Y2017.Day13 do
     data
     |> Transformers.lines()
     |> Map.new(fn line ->
-      line
-      |> String.split(": ")
-      |> Enum.map(&String.to_integer/1)
-      |> List.to_tuple()
+      [pos, range] = String.split(line, ": ") |> Enum.map(&String.to_integer/1)
+      {pos, range}
     end)
   end
 
-  defp run_1(input, limit, delay \\ 0) do
-    input
-    |> sneak(limit, delay)
-    |> severity(input)
-  end
-
-  defp run_2(input, limit, delay \\ 0) do
-    case sneak(input, limit, delay) do
-      [] -> delay
-      _ -> run_2(input, limit, delay + 1)
-    end
+  defp solve_1(scanners) do
+    scanners
+    |> Enum.filter(fn {pos, period, _} -> rem(pos, period) == 0 end)
+    |> Enum.map(fn {pos, _, range} -> pos * range end)
+    |> Enum.sum()
   end
 
-  defp sneak(input, limit, delay) do
-    Enum.reduce(0..limit, [], fn pos, detections ->
-      case Map.get(input, pos) do
-        nil -> detections
-        range -> (detect?(pos, range, delay) && [pos | detections]) || detections
-      end
+  defp solve_2(scanners) do
+    Stream.iterate(0, &(&1 + 1))
+    |> Enum.find(fn delay ->
+      # Short-circuiting any check makes this much faster than iterating all layers
+      !Enum.any?(scanners, fn {pos, period, _} -> rem(delay + pos, period) == 0 end)
     end)
   end
-
-  defp detect?(pico_second, range, delay) do
-    rem(pico_second + delay, 2 * (range - 1)) == 0
-  end
-
-  defp severity(detections, input) do
-    input
-    |> Map.take(detections)
-    |> Enum.sum_by(fn {k, v} -> k * v end)
-  end
 end

lib/2017/day_15.ex

@@ -3,72 +3,72 @@ defmodule AdventOfCode.Y2017.Day15 do
   --- Day 15: Dueling Generators ---
   Problem Link: https://adventofcode.com/2017/day/15
   Difficulty: l
-  Tags: number-theory bitwise slow
-
-  FIXME: Number being Marsenne Prime, can't help but think there's a faster way to this.
+  Tags: number-theory bitwise optimization
   """
   import Bitwise
 
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2017, 15)
 
-  @multipliers %{"A" => 16_807, "B" => 48_271}
+  @mod 2_147_483_647
 
   def run(input \\ input()) do
-    input = parse(input)
+    [a, b] = parse(input)
 
-    part_1 = Task.async(fn -> final_count_1(input) end)
-    part_2 = Task.async(fn -> final_count_2(input) end)
+    # Use Task.async for parallelism
+    part_1 = Task.async(fn -> solve_1(a, b, 0, 0) end)
+    part_2 = Task.async(fn -> solve_2(a, b, 0, 0) end)
 
-    {
-      Task.await(part_1, :infinity),
-      Task.await(part_2, :infinity)
-    }
+    {Task.await(part_1, :infinity), Task.await(part_2, :infinity)}
   end
 
-  @regex ~r"Generator (A|B) starts with (\d+)"
   def parse(input) do
     input
     |> Transformers.lines()
     |> Enum.map(fn line ->
-      [name, start] = Regex.run(@regex, line, capture: :all_but_first)
-
-      {String.to_integer(start), @multipliers[name]}
+      [_, val] = Regex.run(~r/starts with (\d+)/, line)
+      String.to_integer(val)
     end)
   end
 
-  defp final_count_1([{a, multiplier_a}, {b, multiplier_b}]) do
-    get_final_count(
-      40_000_000,
-      [generator(a, multiplier_a), generator(b, multiplier_b)]
-    )
-  end
+  defp solve_1(_, _, 40_000_000, result), do: result
 
-  defp final_count_2([{a, multiplier_a}, {b, multiplier_b}]) do
-    get_final_count(5_000_000, [
-      generator(a, multiplier_a, multiple_of(4)),
-      generator(b, multiplier_b, multiple_of(8))
-    ])
-  end
+  defp solve_1(a, b, count, result) do
+    na = next(a, 16_807)
+    nb = next(b, 48_271)
 
-  defp generator(initial, multiplier, filter \\ & &1) do
-    initial
-    |> next(multiplier)
-    |> Stream.iterate(&next(&1, multiplier))
-    |> filter.()
+    if (na &&& 0xFFFF) == (nb &&& 0xFFFF) do
+      solve_1(na, nb, count + 1, result + 1)
+    else
+      solve_1(na, nb, count + 1, result)
+    end
   end
 
-  defp get_final_count(limit, [a, b]) do
-    [a, b]
-    |> Stream.zip()
-    |> Enum.take(limit)
-    |> Enum.count(&same_lowest_bits?/1)
+  defp solve_2(_, _, 5_000_000, result), do: result
+
+  defp solve_2(a, b, count, result) do
+    na = next_filtered(a, 16_807, 3)
+    nb = next_filtered(b, 48_271, 7)
+
+    if (na &&& 0xFFFF) == (nb &&& 0xFFFF) do
+      solve_2(na, nb, count + 1, result + 1)
+    else
+      solve_2(na, nb, count + 1, result)
+    end
   end
 
-  @mask (1 <<< 16) - 1
-  defp same_lowest_bits?({a, b}), do: bxor(a &&& @mask, b &&& @mask) == 0
+  @compile {:inline, next: 2}
+  defp next(val, mult) do
+    prod = val * mult
+    # Mersenne Prime (2^31 - 1) optimization
+    res = (prod >>> 31) + (prod &&& @mod)
+    if res >= @mod, do: res - @mod, else: res
+  end
 
-  defp multiple_of(amount), do: &Stream.filter(&1, fn val -> rem(val, amount) == 0 end)
-  defp next(prev, multiplier), do: rem(prev * multiplier, 2_147_483_647)
+  defp next_filtered(val, mult, mask) do
+    n = next(val, mult)
+    # Using bitwise & mask for multiple_of(4) -> &&& 3 == 0, multiple_of(8) -> &&& 7 == 0
+    if (n &&& mask) == 0, do: n, else: next_filtered(n, mult, mask)
+  end
 end