Remove erlang solution

Author: code-shoily

lib/2022/day_08.ex

@@ -3,13 +3,96 @@ defmodule AdventOfCode.Y2022.Day08 do
   --- Day 8: Treetop Tree House ---
   Problem Link: https://adventofcode.com/2022/day/8
   Difficulty: m
-  Tags: erlang grid
+  Tags: grid graph traversal
   """
-  alias AdventOfCode.Helpers.InputReader
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.Builder.Grid
+  alias Yog.Traversal.Implicit
 
   def input, do: InputReader.read_from_file(2022, 8)
 
   def run(input \\ input()) do
-    :day_22_8.solve(input)
+    grid_data = input |> Transformers.lines() |> Enum.map(&Transformers.digits/1)
+    grid = Grid.from_2d_list(grid_data, :directed, Grid.always())
+
+    {part1(grid), part2(grid)}
+  end
+
+  defp part1(grid) do
+    for r <- 0..(grid.rows - 1),
+        c <- 0..(grid.cols - 1),
+        visible?(grid, r, c),
+        reduce: 0 do
+      acc -> acc + 1
+    end
+  end
+
+  defp part2(grid) do
+    for r <- 0..(grid.rows - 1),
+        c <- 0..(grid.cols - 1) do
+      scenic_score(grid, r, c)
+    end
+    |> Enum.max()
+  end
+
+  defp visible?(grid, r, c) do
+    if r == 0 or r == grid.rows - 1 or c == 0 or c == grid.cols - 1 do
+      true
+    else
+      {:ok, h} = Grid.get_cell(grid, r, c)
+
+      Enum.any?([{-1, 0}, {1, 0}, {0, -1}, {0, 1}], fn {dr, dc} ->
+        directional_walk(grid, r + dr, c + dc, dr, dc)
+        |> Enum.all?(fn other_h -> other_h < h end)
+      end)
+    end
   end
+
+  defp scenic_score(grid, r, c) do
+    {:ok, h} = Grid.get_cell(grid, r, c)
+
+    Enum.reduce([{-1, 0}, {1, 0}, {0, -1}, {0, 1}], 1, fn {dr, dc}, acc ->
+      acc * viewing_distance(grid, r + dr, c + dc, dr, dc, h)
+    end)
+  end
+
+  defp directional_walk(grid, r, c, dr, dc) do
+    Implicit.implicit_fold(
+      from: {r, c},
+      using: :breadth_first,
+      successors_of: fn {curr_r, curr_c} ->
+        nr = curr_r + dr
+        nc = curr_c + dc
+        if in_bounds?(grid, nr, nc), do: [{nr, nc}], else: []
+      end,
+      initial: [],
+      with: fn acc, {curr_r, curr_c}, _meta ->
+        {:ok, h} = Grid.get_cell(grid, curr_r, curr_c)
+        {:continue, [h | acc]}
+      end
+    )
+  end
+
+  defp viewing_distance(grid, r, c, dr, dc, h) do
+    if not in_bounds?(grid, r, c) do
+      0
+    else
+      Implicit.implicit_fold(
+        from: {r, c},
+        using: :breadth_first,
+        successors_of: fn {curr_r, curr_c} ->
+          {:ok, curr_h} = Grid.get_cell(grid, curr_r, curr_c)
+          nr = curr_r + dr
+          nc = curr_c + dc
+          if curr_h < h and in_bounds?(grid, nr, nc), do: [{nr, nc}], else: []
+        end,
+        initial: 0,
+        with: fn acc, _coord, _meta ->
+          {:continue, acc + 1}
+        end
+      )
+    end
+  end
+
+  defp in_bounds?(grid, r, c), do: r >= 0 and r < grid.rows and c >= 0 and c < grid.cols
 end

lib/2022/day_09.ex

@@ -3,13 +3,69 @@ defmodule AdventOfCode.Y2022.Day09 do
   --- Day 9: Rope Bridge ---
   Problem Link: https://adventofcode.com/2022/day/9
   Difficulty: m
-  Tags: erlang grid walk
+  Tags: grid walk
   """
-  alias AdventOfCode.Helpers.InputReader
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2022, 9)
 
   def run(input \\ input()) do
-    :day_22_9.solve(input)
+    instructions = parse(input)
+    {part1(instructions), part2(instructions)}
   end
+
+  defp part1(instructions), do: solve(instructions, 2)
+  defp part2(instructions), do: solve(instructions, 10)
+
+  defp solve(instructions, count) do
+    start_rope = List.duplicate({0, 0}, count)
+
+    {_rope, visited} =
+      Enum.reduce(instructions, {start_rope, MapSet.new([{0, 0}])}, fn {dir, steps}, acc ->
+        Enum.reduce(1..steps, acc, fn _, {rope, visited} ->
+          [head | tails] = rope
+          new_head = move_head(head, dir)
+
+          # Each knot follows the one before it
+          new_rope =
+            Enum.scan(tails, new_head, fn tail, prev ->
+              follow(prev, tail)
+            end)
+
+          full_rope = [new_head | new_rope]
+          {full_rope, MapSet.put(visited, List.last(full_rope))}
+        end)
+      end)
+
+    MapSet.size(visited)
+  end
+
+  defp parse(input) do
+    input
+    |> Transformers.lines()
+    |> Enum.map(fn line ->
+      [dir, steps] = String.split(line, " ")
+      {dir, String.to_integer(steps)}
+    end)
+  end
+
+  defp move_head({r, c}, "U"), do: {r - 1, c}
+  defp move_head({r, c}, "D"), do: {r + 1, c}
+  defp move_head({r, c}, "L"), do: {r, c - 1}
+  defp move_head({r, c}, "R"), do: {r, c + 1}
+
+  defp follow({hr, hc}, {tr, tc}) do
+    dr = hr - tr
+    dc = hc - tc
+
+    if abs(dr) <= 1 and abs(dc) <= 1 do
+      {tr, tc}
+    else
+      {tr + sign(dr), tc + sign(dc)}
+    end
+  end
+
+  defp sign(0), do: 0
+  defp sign(n) when n > 0, do: 1
+  defp sign(n) when n < 0, do: -1
 end

lib/2022/day_10.ex

@@ -1,15 +1,66 @@
 defmodule AdventOfCode.Y2022.Day10 do
   @moduledoc """
-  --- Day 10: Cathode-Ray Tube ---p
+  --- Day 10: Cathode-Ray Tube ---
   Problem Link: https://adventofcode.com/2022/day/10
   Difficulty: m
-  Tags: erlang visual-result op-code
+  Tags: visual-result op-code
   """
-  alias AdventOfCode.Helpers.InputReader
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2022, 10)
 
   def run(input \\ input()) do
-    :day_22_10.solve(input)
+    cycles = simulate(parse(input))
+
+    part1 =
+      [20, 60, 100, 140, 180, 220]
+      |> Enum.map(fn c -> c * cycles[c] end)
+      |> Enum.sum()
+
+    part2 = draw(cycles)
+
+    {part1, part2}
+  end
+
+  defp parse(input) do
+    input
+    |> Transformers.lines()
+    |> Enum.map(fn
+      "noop" -> :noop
+      "addx " <> val -> {:addx, String.to_integer(val)}
+    end)
+  end
+
+  defp simulate(instructions) do
+    {cycles, _, _} =
+      Enum.reduce(instructions, {%{}, 1, 1}, fn
+        :noop, {acc, cycle, x} ->
+          {Map.put(acc, cycle, x), cycle + 1, x}
+
+        {:addx, v}, {acc, cycle, x} ->
+          acc = acc |> Map.put(cycle, x) |> Map.put(cycle + 1, x)
+          {acc, cycle + 2, x + v}
+      end)
+
+    cycles
+  end
+
+  defp draw(cycles) do
+    for r <- 0..5 do
+      for c <- 0..39 do
+        cycle = r * 40 + c + 1
+        x = cycles[cycle]
+
+        if c in (x - 1)..(x + 1) do
+          IO.write("█")
+        else
+          IO.write("▒")
+        end
+      end
+
+      IO.puts("")
+    end
+
+    :ok
   end
 end

lib/2022/day_11.ex

@@ -3,13 +3,120 @@ defmodule AdventOfCode.Y2022.Day11 do
   --- Day 11: Monkey in the Middle ---
   Problem Link: https://adventofcode.com/2022/day/11
   Difficulty: l
-  Tags: erlang parse-heavy arithmetic
+  Tags: parse-heavy arithmetic
   """
-  alias AdventOfCode.Helpers.InputReader
+  alias AdventOfCode.Helpers.{InputReader, Transformers}
 
   def input, do: InputReader.read_from_file(2022, 11)
 
   def run(input \\ input()) do
-    :day_22_11.solve(input)
+    monkeys = parse(input)
+    {solve1(monkeys), solve2(monkeys)}
+  end
+
+  defp solve1(monkeys) do
+    monkeys
+    |> simulate(20, fn w -> div(w, 3) end)
+    |> monkey_business()
+  end
+
+  defp solve2(monkeys) do
+    common_mod = monkeys |> Map.values() |> Enum.map(& &1.test) |> Enum.reduce(1, &*/2)
+
+    monkeys
+    |> simulate(10_000, fn w -> rem(w, common_mod) end)
+    |> monkey_business()
+  end
+
+  defp simulate(monkeys, rounds, relax_fn) do
+    ids = Map.keys(monkeys) |> Enum.sort()
+
+    Enum.reduce(1..rounds, monkeys, fn _, monkeys_acc ->
+      Enum.reduce(ids, monkeys_acc, fn id, monkeys_round ->
+        monkey = monkeys_round[id]
+
+        if monkey.items == [] do
+          monkeys_round
+        else
+          throws =
+            Enum.reduce(monkey.items, %{}, fn item, throw_acc ->
+              new_worry = monkey.op.(item) |> relax_fn.()
+
+              target =
+                if rem(new_worry, monkey.test) == 0,
+                  do: monkey.true_target,
+                  else: monkey.false_target
+
+              Map.update(throw_acc, target, [new_worry], fn current -> current ++ [new_worry] end)
+            end)
+
+          Enum.reduce(throws, monkeys_round, fn {target_id, items}, ms ->
+            update_in(ms, [target_id, :items], fn current -> current ++ items end)
+          end)
+          |> update_in([id, :inspected], &(&1 + length(monkey.items)))
+          |> put_in([id, :items], [])
+        end
+      end)
+    end)
+  end
+
+  defp monkey_business(monkeys) do
+    monkeys
+    |> Map.values()
+    |> Enum.map(& &1.inspected)
+    |> Enum.sort(:desc)
+    |> Enum.take(2)
+    |> Enum.product()
+  end
+
+  defp parse(input) do
+    input
+    |> Transformers.sections()
+    |> Enum.with_index()
+    |> Enum.reduce(%{}, fn {section, idx}, acc ->
+      lines = Transformers.lines(section)
+      [_, items_l, op_l, test_l, t_l, f_l] = Enum.map(lines, &String.trim/1)
+
+      monkey = %{
+        items: parse_items(items_l),
+        op: parse_op(op_l),
+        test: parse_last_int(test_l),
+        true_target: parse_last_int(t_l),
+        false_target: parse_last_int(f_l),
+        inspected: 0
+      }
+
+      Map.put(acc, idx, monkey)
+    end)
+  end
+
+  defp parse_items(line) do
+    line
+    |> String.split(": ")
+    |> List.last()
+    |> String.split(", ")
+    |> Enum.map(&String.to_integer/1)
+  end
+
+  defp parse_last_int(line) do
+    line
+    |> String.split(" ")
+    |> List.last()
+    |> String.to_integer()
+  end
+
+  defp parse_op(line) do
+    [_, expr] = String.split(line, "new = ")
+    [left_s, op_s, right_s] = String.split(expr, " ")
+
+    fn old ->
+      l = if left_s == "old", do: old, else: String.to_integer(left_s)
+      r = if right_s == "old", do: old, else: String.to_integer(right_s)
+
+      case op_s do
+        "+" -> l + r
+        "*" -> l * r
+      end
+    end
   end
 end