Addressed slow/not-so-fast

Author: code-shoily

lib/2015/day_06.ex

@@ -3,50 +3,114 @@ defmodule AdventOfCode.Y2015.Day06 do
   --- Day 6: Probably a Fire Hazard ---
   Problem Link: https://adventofcode.com/2015/day/6
   Difficulty: m
-  Tags: grid vector reduction slow
+  Tags: grid vector reduction
   """
-  alias AdventOfCode.Helpers.{InputReader, Transformers}
-  alias Aja.Vector
+  import Bitwise
+  alias AdventOfCode.Helpers.InputReader
 
   def input, do: InputReader.read_from_file(2015, 6)
 
   def run(input \\ input()) do
     parsed_input = parse(input)
-    grid = make_grid(1000)
 
-    task_1 = Task.async(fn -> brightness(Enum.reduce(parsed_input, grid, &apply_1/2)) end)
-    task_2 = Task.async(fn -> brightness(Enum.reduce(parsed_input, grid, &apply_2/2)) end)
+    task_1 = Task.async(fn -> part_1(parsed_input) end)
+    task_2 = Task.async(fn -> part_2(parsed_input) end)
 
     {Task.await(task_1, :infinity), Task.await(task_2, :infinity)}
   end
 
   def parse(input \\ input()) do
-    Enum.map(Transformers.lines(input), &parse_input/1)
+    input
+    |> String.split("\n", trim: true)
+    |> Enum.map(&parse_input/1)
   end
 
-  def apply_1(line, grid),
-    do: apply(line, grid, fn _ -> 1 end, fn _ -> 0 end, fn v -> (v == 0 && 1) || 0 end)
+  # Part 1 implementation using bitwise operations on rows (represented as 1000-bit integers)
+  defp part_1(instructions) do
+    # Initial grid: 1000 rows of all zeros (represented as 0)
+    grid = Tuple.duplicate(0, 1000)
 
-  def apply_2(line, grid), do: apply(line, grid, &(&1 + 1), &max(0, &1 - 1), &(&1 + 2))
+    instructions
+    |> Enum.reduce(grid, fn {cmd, x1..x2//_, y1..y2//_}, acc ->
+      mask = ((1 <<< (x2 - x1 + 1)) - 1) <<< x1
 
-  defp apply({cmd, xs, ys}, grid, on, off, toggle) do
-    Vector.foldl(coords(xs, ys), grid, fn [x, y], acc ->
+      Enum.reduce(y1..y2, acc, fn y, rows ->
+        row = elem(rows, y)
+
+        new_row =
+          case cmd do
+            "turn on" -> row ||| mask
+            "turn off" -> row &&& bnot(mask)
+            "toggle" -> bxor(row, mask)
+          end
+
+        put_elem(rows, y, new_row)
+      end)
+    end)
+    |> Tuple.to_list()
+    |> Enum.reduce(0, fn row, acc -> acc + popcount(row) end)
+  end
+
+  # Part 2 implementation using :counters for mutable-like performance
+  defp part_2(instructions) do
+    c = :counters.new(1_000_000, [])
+
+    Enum.each(instructions, fn {cmd, x1..x2//_, y1..y2//_} ->
       case cmd do
-        "turn on" -> Vector.update_at(acc, x, &Vector.update_at(&1, y, on))
-        "turn off" -> Vector.update_at(acc, x, &Vector.update_at(&1, y, off))
-        "toggle" -> Vector.update_at(acc, x, &Vector.update_at(&1, y, toggle))
+        "turn on" ->
+          for y <- y1..y2 do
+            offset = y * 1000 + 1
+            for x <- x1..x2, do: :counters.add(c, offset + x, 1)
+          end
+
+        "turn off" ->
+          for y <- y1..y2 do
+            offset = y * 1000 + 1
+
+            for x <- x1..x2 do
+              idx = offset + x
+              if :counters.get(c, idx) > 0, do: :counters.add(c, idx, -1)
+            end
+          end
+
+        "toggle" ->
+          for y <- y1..y2 do
+            offset = y * 1000 + 1
+            for x <- x1..x2, do: :counters.add(c, offset + x, 2)
+          end
       end
     end)
+
+    # Sum all values
+    Enum.reduce(1..1_000_000, 0, fn i, acc -> acc + :counters.get(c, i) end)
   end
 
-  defp make_grid(dim), do: Vector.duplicate(Vector.duplicate(0, dim), dim)
-  defp brightness(grid), do: Aja.Enum.reduce(grid, 0, &(&2 + Aja.Enum.sum(&1)))
-  defp coords(xs, ys), do: Vector.new(for x <- xs, y <- ys, do: [x, y])
+  # High performance popcount for large integers
+  defp popcount(0), do: 0
+
+  defp popcount(n) do
+    n
+    |> :binary.encode_unsigned()
+    |> count_binary_ones(0)
+  end
+
+  defp count_binary_ones(<<>>, acc), do: acc
+
+  defp count_binary_ones(<<b, rest::binary>>, acc) do
+    count_binary_ones(
+      rest,
+      acc +
+        for <<(bit::1 <- <<b::8>>)>>, reduce: 0 do
+          a -> a + bit
+        end
+    )
+  end
 
   @regex ~r"(?<cmd>toggle|turn\son|turn\soff)\s(?<x1>\d+),(?<y1>\d+)\s\S+\s(?<x2>\d+),(?<y2>\d+)"
-  defp parse_input(line), do: format(Regex.named_captures(@regex, line))
+  defp parse_input(line) do
+    %{"cmd" => cmd, "x1" => x1, "x2" => x2, "y1" => y1, "y2" => y2} =
+      Regex.named_captures(@regex, line)
 
-  defp format(%{"cmd" => cmd, "x1" => x1, "x2" => x2, "y1" => y1, "y2" => y2}) do
     {cmd, String.to_integer(x1)..String.to_integer(x2),
      String.to_integer(y1)..String.to_integer(y2)}
   end

lib/2015/day_15.ex

@@ -3,7 +3,7 @@ defmodule AdventOfCode.Y2015.Day15 do
   --- Day 15: Science for Hungry People ---
   Problem Link: https://adventofcode.com/2015/day/15
   Difficulty: m
-  Tags: quadratic-time not-fast-enough sequence needs-improvement
+  Tags: quadratic-time sequence
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 

lib/2015/day_17.ex

@@ -3,7 +3,7 @@ defmodule AdventOfCode.Y2015.Day17 do
   --- Day 17: No Such Thing as Too Much ---
   Problem Link: https://adventofcode.com/2015/day/17
   Difficulty: s
-  Tags: slow revisit combinatorics
+  Tags: combinatorics
   """
   alias AdventOfCode.Algorithms.Combinatorics
   alias AdventOfCode.Helpers.{InputReader, Transformers}

lib/2015/day_18.ex

@@ -3,84 +3,75 @@ defmodule AdventOfCode.Y2015.Day18 do
   --- Day 18: Like a GIF For Your Yard ---
   Problem Link: https://adventofcode.com/2015/day/18
   Difficulty: m
-  Tags: grid map not-fast-enough
+  Tags: grid map cellular-automata
   """
-  alias AdventOfCode.Algorithms.Grid
   alias AdventOfCode.Helpers.{InputReader, Transformers}
 
+  @rows 100
+  @cols 100
+  @corners [{0, 0}, {0, 99}, {99, 0}, {99, 99}]
+
   def input, do: InputReader.read_from_file(2015, 18)
-  @repetitions 1..100
-  @last_index 99
-  @corners [{0, 0}, {0, @last_index}, {@last_index, 0}, {@last_index, @last_index}]
 
   def run(input \\ input()) do
-    grid = parse(input)
-
-    solution_1 = Task.async(fn -> steps(grid, &state/3) end)
+    on_set = parse(input)
 
-    solution_2 =
-      Task.async(fn -> grid |> update_corners() |> steps(&state_with_faulty_corners/3) end)
+    task_1 = Task.async(fn -> solve(on_set, false) end)
+    task_2 = Task.async(fn -> solve(on_set, true) end)
 
-    {
-      Task.await(solution_1, 10_000),
-      Task.await(solution_2, 10_000)
-    }
+    {Task.await(task_1), Task.await(task_2)}
   end
 
-  def parse(data \\ input()) do
+  def parse(data) do
     data
     |> Transformers.lines()
-    |> Enum.map(&String.graphemes/1)
-    |> Grid.grid2d()
-  end
-
-  defp steps(grid, tx) do
-    @repetitions
-    |> Enum.reduce(grid, fn _, acc -> iterate(acc, tx) end)
-    |> Enum.count(fn {_, light} -> light == "#" end)
-  end
-
-  defp iterate(grid, tx) do
-    Map.new(grid, fn {{x, y}, state} ->
-      tx.(grid, {x, y}, state)
+    |> Enum.with_index()
+    |> Enum.reduce(MapSet.new(), fn {line, r}, acc ->
+      line
+      |> String.graphemes()
+      |> Enum.with_index()
+      |> Enum.reduce(acc, fn {char, c}, inner_acc ->
+        if char == "#", do: MapSet.put(inner_acc, {r, c}), else: inner_acc
+      end)
     end)
   end
 
-  defp state(grid, {x, y}, state) do
-    ons = grid |> get_neighbors({x, y}) |> Enum.count(&(&1 == "#"))
+  defp solve(on_set, corners_sticky?) do
+    on_set = if corners_sticky?, do: MapSet.union(on_set, MapSet.new(@corners)), else: on_set
 
-    state =
-      case state do
-        "#" -> (ons in [2, 3] && "#") || "."
-        "." -> (ons == 3 && "#") || "."
-      end
+    1..100
+    |> Enum.reduce(on_set, fn _, current_on ->
+      # Step 1: Count neighbors for all "interesting" cells
+      neighbor_counts =
+        Enum.reduce(current_on, %{}, fn {r, c}, counts ->
+          Enum.reduce(neighbors(r, c), counts, fn pos, acc ->
+            Map.update(acc, pos, 1, &(&1 + 1))
+          end)
+        end)
 
-    {{x, y}, state}
-  end
+      # Step 2: Apply GOL rules
+      new_on =
+        Enum.reduce(neighbor_counts, MapSet.new(), fn {pos, count}, acc ->
+          cond do
+            count == 3 -> MapSet.put(acc, pos)
+            count == 2 and MapSet.member?(current_on, pos) -> MapSet.put(acc, pos)
+            true -> acc
+          end
+        end)
 
-  defp get_neighbors(grid, {x, y}) do
-    [
-      {x + 1, y},
-      {x - 1, y},
-      {x, y + 1},
-      {x, y - 1},
-      {x + 1, y + 1},
-      {x + 1, y - 1},
-      {x - 1, y - 1},
-      {x - 1, y + 1}
-    ]
-    |> Enum.map(fn coords -> grid[coords] end)
-    |> Enum.reject(&is_nil/1)
-  end
-
-  defp update_corners(grid) do
-    Map.merge(grid, Map.new(@corners, &{&1, "#"}))
+      if corners_sticky?, do: MapSet.union(new_on, MapSet.new(@corners)), else: new_on
+    end)
+    |> MapSet.size()
   end
 
-  defp state_with_faulty_corners(grid, {x, y}, state) do
-    case state(grid, {x, y}, state) do
-      {corner, _} when corner in @corners -> {corner, "#"}
-      state -> state
+  defp neighbors(r, c) do
+    for dr <- -1..1,
+        dc <- -1..1,
+        not (dr == 0 and dc == 0),
+        nr = r + dr,
+        nc = c + dc,
+        nr >= 0 and nr < @rows and nc >= 0 and nc < @cols do
+      {nr, nc}
     end
   end
 end

lib/2015/day_19.ex

@@ -3,7 +3,7 @@ defmodule AdventOfCode.Y2015.Day19 do
   --- Day 19: Medicine for Rudolph ---
   Problem Link: https://adventofcode.com/2015/day/19
   Difficulty: m
-  Tags: not-fast-enough needs-improvement vector random-access
+  Tags: vector random-access
 
   Helpful Tips for Part II: (,) analogy
   https://www.reddit.com/r/adventofcode/comments/3xflz8/day_19_solutions/cy4etju

lib/2015/day_20.ex

@@ -3,54 +3,61 @@ defmodule AdventOfCode.Y2015.Day20 do
   --- Day 20: Infinite Elves and Infinite Houses ---
   Problem Link: https://adventofcode.com/2015/day/20
   Difficulty: l
-  Tags: slow infinite-sequence sequence
+  Tags: slow infinite-sequence sequence sieve optimization
   """
-  alias AdventOfCode.Algorithms.Arithmetics
+
   alias AdventOfCode.Helpers.InputReader
 
   def input, do: InputReader.read_from_file(2015, 20)
 
   def run(input \\ input()) do
-    input = String.to_integer(input)
-
-    part_1 = Task.async(fn -> run_1(input) end)
-    part_2 = Task.async(fn -> run_2(input) end)
+    target = String.trim(input) |> String.to_integer()
 
-    {Task.await(part_1, 10_000), Task.await(part_2, 10_000)}
-  end
-
-  defp run_1(input) do
-    house_with_gifts(input, &number_of_gifts/1)
-  end
+    task_1 = Task.async(fn -> solve_1(target) end)
+    task_2 = Task.async(fn -> solve_2(target) end)
 
-  defp run_2(input) do
-    house_with_gifts(input, &number_of_gifts_below_50/1)
+    {Task.await(task_1, :infinity), Task.await(task_2, :infinity)}
   end
 
-  def house_with_gifts(limit, fun) do
-    Stream.iterate(1, &(&1 + 1))
-    |> Stream.map(fun)
-    |> Enum.take_while(fn {_, gifts} -> gifts < limit end)
-    |> Enum.max_by(fn {house, _} -> house end)
-    |> then(fn {house, _} -> house + 1 end)
+  # Part 1: Each elf i delivers 10*i gifts to every i-th house.
+  # First house with >= target gifts.
+  def solve_1(target) do
+    # Upper bound: house `target/10` is guaranteed to get `target` gifts from elf `target/10`.
+    limit = div(target, 10)
+    arr = :atomics.new(limit, [{:signed, false}])
+
+    # Sieve of Eratosthenes-style accumulation
+    # O(N log N) total operations
+    Enum.each(1..limit, fn elf ->
+      val = elf * 10
+      # Start from elf, go to limit by elf steps
+      for house <- elf..limit//elf do
+        :atomics.add(arr, house, val)
+      end
+    end)
+
+    Enum.find(1..limit, fn h -> :atomics.get(arr, h) >= target end)
   end
 
-  defp number_of_gifts(house) do
-    gifts =
-      house
-      |> Arithmetics.divisors()
-      |> Enum.sum_by(&(&1 * 10))
-
-    {house, gifts}
-  end
-
-  defp number_of_gifts_below_50(house) do
-    gifts =
-      house
-      |> Arithmetics.divisors()
-      |> Enum.filter(fn divisor -> div(house, divisor) < 50 end)
-      |> Enum.sum_by(&(&1 * 11))
-
-    {house, gifts}
+  # Part 2: Each elf i delivers 11*i gifts to their first 50 houses.
+  def solve_2(target) do
+    limit = div(target, 11) + 1
+    arr = :atomics.new(limit, [{:signed, false}])
+
+    Enum.each(1..limit, fn elf ->
+      val = elf * 11
+      # Elf i delivers to i, 2i, ..., 50i
+      # We take the first 50 houses but must not exceed limit
+      steps = min(50, div(limit, elf))
+
+      if steps > 0 do
+        for s <- 1..steps do
+          house = s * elf
+          if house <= limit, do: :atomics.add(arr, house, val)
+        end
+      end
+    end)
+
+    Enum.find(1..limit, fn h -> :atomics.get(arr, h) >= target end)
   end
 end