Refactor Aja based solutions

Author: code-shoily

lib/2017/day_17.ex

@@ -3,43 +3,37 @@ defmodule AdventOfCode.Y2017.Day17 do
   --- Day 17: Spinlock ---
   Problem Link: https://adventofcode.com/2017/day/17
   Difficulty: m
-  Tags: vector random-access
+  Tags: circular-buffer simulation
   """
-  alias Aja.Vector
-
   def input, do: 394
 
   def run, do: {run_1(), run_2()}
 
-  @target 2017
+  @target_1 2017
   defp run_1 do
-    Vector.new([0])
-    |> insert_nth(0, 0)
-    |> then(fn buffer ->
-      Vector.at(buffer, Aja.Enum.find_index(buffer, &(&1 == 2017)) + 1)
-    end)
-  end
-
-  defp insert_nth(buffer, _, @target), do: buffer
+    step = input()
 
-  defp insert_nth(buffer, position, idx) do
-    idx = idx + 1
-    position = rem(position + input(), idx) + 1
-    {left, right} = {Vector.take(buffer, position), Vector.drop(buffer, position)}
-    buffer = left |> Vector.concat(Vector.new([idx])) |> Vector.concat(right)
+    {buffer, _} =
+      Enum.reduce(1..@target_1, {[0], 0}, fn i, {buf, pos} ->
+        new_pos = rem(pos + step, i) + 1
+        {List.insert_at(buf, new_pos, i), new_pos}
+      end)
 
-    insert_nth(buffer, position, idx)
+    idx = Enum.find_index(buffer, &(&1 == @target_1))
+    Enum.at(buffer, rem(idx + 1, length(buffer)))
   end
 
-  @target 50_000_000
-  defp run_2, do: find_idx_1_after(0, 0, 0)
+  @target_2 50_000_000
+  defp run_2 do
+    step = input()
 
-  defp find_idx_1_after(_, @target, first), do: first
+    {_, after_zero} =
+      Enum.reduce(1..@target_2, {0, 0}, fn i, {pos, first} ->
+        new_pos = rem(pos + step, i) + 1
+        new_first = if new_pos == 1, do: i, else: first
+        {new_pos, new_first}
+      end)
 
-  defp find_idx_1_after(position, idx, first) do
-    idx = idx + 1
-    position = rem(position + input(), idx) + 1
-    first = (position == 1 && idx) || first
-    find_idx_1_after(position, idx, first)
+    after_zero
   end
 end

lib/2023/day_12.ex

@@ -3,78 +3,100 @@ defmodule AdventOfCode.Y2023.Day12 do
   --- Day 12: Hot Springs ---
   Problem Link: https://adventofcode.com/2023/day/12
   Difficulty: xl
-  Tags: memoization vector
+  Tags: memoization
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
-  alias Aja.Vector
 
   def input, do: InputReader.read_from_file(2023, 12)
 
   def run(input \\ input()) do
-    input = parse(input)
-
-    {total_arrangements(input, fn {spring, groups} ->
-       arrangements({as_vector(spring), groups})
-     end),
-     total_arrangements(input, fn {spring, groups} ->
-       arrangements(
-         {[spring] |> List.duplicate(5) |> Enum.join("?") |> as_vector(),
-          groups |> Vector.duplicate(5) |> Vector.flat_map(& &1)}
-       )
-     end)}
+    parsed = parse(input)
+
+    res1 = compute(parsed, 1)
+    res2 = compute(parsed, 5)
+
+    {res1, res2}
   end
 
-  defp total_arrangements(input, fun) do
-    for {:ok, count} <- Task.async_stream(input, fun), reduce: 0 do
-      acc -> acc + count
-    end
+  defp compute(parsed, multiplier) do
+    parsed
+    |> Task.async_stream(
+      fn {springs, groups} ->
+        unfolded_springs = List.duplicate(springs, multiplier) |> Enum.join("?")
+        unfolded_groups = List.duplicate(groups, multiplier) |> List.flatten() |> List.to_tuple()
+
+        Process.get_keys() |> Enum.each(&Process.delete/1)
+        do_count(unfolded_springs, unfolded_groups, 0, 0, 0)
+      end,
+      timeout: :infinity
+    )
+    |> Enum.reduce(0, fn {:ok, count}, acc -> acc + count end)
   end
 
-  def parse(data \\ input()) do
+  def parse(data) do
     for line <- Transformers.lines(data) do
-      [springs, data] = String.split(line, " ")
-      {springs, Vector.new(Transformers.int_words(data, ","))}
+      [springs, groups] = String.split(line, " ")
+      {springs, Transformers.int_words(groups, ",")}
     end
   end
 
-  defp memoize(input, counts), do: Process.put(input, counts)
-  defp memoized({_, _, _, _, _} = input), do: memoized(input, Process.get(input))
-  defp memoized(input, nil), do: tap(arrangements(input), &memoize(input, &1))
-  defp memoized(_, counts), do: counts
-  defp as_vector(springs), do: Vector.new(String.graphemes(springs <> "."))
-  defp arrangements({springs, groups}), do: arrangements({springs, groups, 0, 0, 0})
-
-  defp arrangements({springs, groups, current, current_count, processed} = input) do
-    case {Vector.at(springs, current), Vector.size(springs), Vector.size(groups)} do
-      {_, ^current, ^processed} -> tap(1, &memoize(input, &1))
-      {_, ^current, _} -> tap(0, &memoize(input, &1))
-      {"#", _, _} -> memoized({springs, groups, current + 1, current_count + 1, processed})
-      {".", _, _} -> arrangements(input, :operational)
-      {_, _, ^processed} -> arrangements(input, :operational)
-      _ -> arrangements(input, :unknown)
+  defp do_count(springs, groups, s_idx, g_idx, current_count) do
+    key = {s_idx, g_idx, current_count}
+
+    case Process.get(key) do
+      nil ->
+        res = calc(springs, groups, s_idx, g_idx, current_count)
+        Process.put(key, res)
+        res
+
+      val ->
+        val
     end
   end
 
-  defp arrangements({springs, groups, current, current_count, processed} = input, :operational) do
-    groups_processed = Vector.at(groups, processed)
+  defp calc(springs, groups, s_idx, g_idx, current_count) do
+    if s_idx == byte_size(springs) do
+      cond do
+        g_idx == tuple_size(groups) and current_count == 0 -> 1
+        g_idx == tuple_size(groups) - 1 and current_count == elem(groups, g_idx) -> 1
+        true -> 0
+      end
+    else
+      char = :binary.at(springs, s_idx)
 
-    case {processed < Vector.size(groups), current_count} do
-      {true, ^groups_processed} -> memoized({springs, groups, current + 1, 0, processed + 1})
-      {_, 0} -> memoized({springs, groups, current + 1, 0, processed})
-      _ -> tap(0, fn zero -> memoize(input, zero) end)
+      case char do
+        ?# ->
+          handle_hash(springs, groups, s_idx, g_idx, current_count)
+
+        ?. ->
+          handle_dot(springs, groups, s_idx, g_idx, current_count)
+
+        ?? ->
+          handle_dot(springs, groups, s_idx, g_idx, current_count) +
+            handle_hash(springs, groups, s_idx, g_idx, current_count)
+      end
     end
   end
 
-  defp arrangements({springs, groups, current, current_count, processed} = input, :unknown) do
-    groups_processed = Vector.at(groups, processed)
+  defp handle_hash(springs, groups, s_idx, g_idx, current_count) do
+    if g_idx < tuple_size(groups) and current_count < elem(groups, g_idx) do
+      do_count(springs, groups, s_idx + 1, g_idx, current_count + 1)
+    else
+      0
+    end
+  end
 
-    tap(
-      case current_count do
-        ^groups_processed -> memoized({springs, groups, current + 1, 0, processed + 1})
-        0 -> memoized({springs, groups, current + 1, 0, processed})
-        _ -> 0
-      end + memoized({springs, groups, current + 1, current_count + 1, processed}),
-      fn counts -> memoize(input, counts) end
-    )
+  defp handle_dot(springs, groups, s_idx, g_idx, current_count) do
+    case current_count do
+      0 ->
+        do_count(springs, groups, s_idx + 1, g_idx, 0)
+
+      n ->
+        if g_idx < tuple_size(groups) and n == elem(groups, g_idx) do
+          do_count(springs, groups, s_idx + 1, g_idx + 1, 0)
+        else
+          0
+        end
+    end
   end
 end

lib/2023/day_15.ex

@@ -3,10 +3,9 @@ defmodule AdventOfCode.Y2023.Day15 do
   --- Day 15: Lens Library ---
   Problem Link: https://adventofcode.com/2023/day/15
   Difficulty: s
-  Tags: hash ordered-map
+  Tags: hash ordered-list
   """
   alias AdventOfCode.Helpers.InputReader
-  alias Aja.OrdMap
 
   def input, do: InputReader.read_from_file(2023, 15)
 
@@ -21,36 +20,40 @@ defmodule AdventOfCode.Y2023.Day15 do
     input
     |> parse_2()
     |> Enum.reduce(%{}, fn
-      {op, b, len}, acc ->
-        hash = hash(b)
+      {:add, label, len}, boxes ->
+        h = hash(label)
 
-        case op do
-          :add -> Map.update(acc, hash, OrdMap.new(%{b => len}), &OrdMap.put(&1, b, len))
-          :remove -> Map.update(acc, hash, OrdMap.new(%{}), &OrdMap.drop(&1, [b]))
-        end
+        Map.update(boxes, h, [{label, len}], fn lenses ->
+          if List.keymember?(lenses, label, 0) do
+            List.keyreplace(lenses, label, 0, {label, len})
+          else
+            lenses ++ [{label, len}]
+          end
+        end)
+
+      {:remove, label}, boxes ->
+        h = hash(label)
+        Map.update(boxes, h, [], &List.keydelete(&1, label, 0))
     end)
     |> total_focus()
   end
 
-  defp total_focus(map) do
-    Enum.reduce(map, 0, fn {box, boxes}, acc ->
+  defp total_focus(boxes) do
+    Enum.reduce(boxes, 0, fn {box_idx, lenses}, acc ->
       acc +
-        (boxes
-         |> OrdMap.to_list()
-         |> Enum.with_index(1)
-         |> Enum.reduce(0, &(&2 + row_focus(&1, box))))
+        Enum.reduce(Enum.with_index(lenses, 1), 0, fn {{_, len}, slot}, inner_acc ->
+          inner_acc + (box_idx + 1) * slot * len
+        end)
     end)
   end
 
-  defp row_focus({{_, len}, slot}, box), do: (box + 1) * slot * len
-
-  def parse_1(input \\ input()), do: String.split(input, ",", trim: true)
+  defp parse_1(input), do: String.split(input, ",", trim: true) |> Enum.map(&String.trim/1)
 
-  def parse_2(commands) do
+  defp parse_2(commands) do
     Enum.map(commands, fn cmd ->
       case Regex.run(~r{([a-zA-Z]+)(=|-)([0-9]*)}, cmd) do
         [_, label, "=", len] -> {:add, label, String.to_integer(len)}
-        [_, label, "-", ""] -> {:remove, label, 0}
+        [_, label, "-", ""] -> {:remove, label}
       end
     end)
   end