Part 2 complete, simple fill

Author: patrickdavey

2019/15/input2.txt

@@ -0,0 +1,41 @@
+#########################################
+#.....#.............#.#.....#.........#O#
+###.#.###.#########.#.#.#.#.#####.###.#.#
+#...#.....#...#...#.#...#.#.....#...#...#
+#.#########.#.#.#.#.#####.#####.###.#####
+#...#.......#.#.#.#.....#...#.#.#...#...#
+#.#.#.#######.###.#####.###.#.#.#.###.#.#
+#.#...#.....#...#.....#...#.#...#.#...#.#
+#.#######.#.###.###.#.###.#.#.###.#.###.#
+#.........#...#...#.#.....#.#.....#.#...#
+#############.###.#.#######.#######.#.###
+#...............#.#.....#...#.......#...#
+#.###############.#####.#.###.#########.#
+#.#.......#.#.....#...#...#...#.......#.#
+#.#####.#.#.#.#####.#.###.#.###.#####.#.#
+#.......#...#...#...#.....#.#.#...#...#.#
+###########.###.###########.#.#.#.#####.#
+#...#.#.....#.#...#...#.....#...#.....#.#
+#.#.#.#.#####.###.#.#.#.#####.#######.#.#
+#.#...#.#.....#...#.#...#...#...#...#.#.#
+#.#####.#.#.#.#.#.#.#######.###.#.#.#.#.#
+#.#.....#.#.#.#.#.#...#.......#.#.#.#...#
+#.#.#######.###.#######.#.###.#.#.#.#####
+#.#.#.....#.#...#.....#.#.#...#...#...#.#
+#.#.#.###.#.#.###.#.#.###.###########.#.#
+#.#...#...#.#...#.#.#.....#.........#...#
+#.#####.###.###.#.#.#######.#######.###.#
+#.#...#.#.....#.#.#.....#...#.....#.....#
+#.#.#.#.#####.#.#.#####.#.###.###.#######
+#...#.#.#...#.#...#...#...#.....#.......#
+#.###.#.#.#.#.#######.#####.#######.#.#.#
+#.#...#...#...#.........#...#.#...#.#.#.#
+###.#########.#####.###.#.###.#.#.#.#.#.#
+#...#.........#.....#...#.#...#.#.#.#.#.#
+#.#.#.#########.#####.###.###.#.#.###.#.#
+#.#.#.#.......#.....#.#.......#.#.....#.#
+#.###.#######.#.###.#.###.#####.#######.#
+#.....#.....#...#...#...#.#.....#.......#
+#.#####.###.#####.#####.###.#####.#######
+#.......#.........#.........#...........#
+#########################################

2019/15/lib/aoc/board.ex

@@ -10,9 +10,9 @@ defmodule AOC.Board do
 
       {min_x, min_y, max_x, max_y} = get_dimensions(board)
 
-      Enum.map(min_y..max_y, &(get_row(&1, board, min_x, max_x)))
+      b = Enum.map(min_y..max_y, &(get_row(&1, board, min_x, max_x)))
       |> Enum.join("\n")
-      |> IO.puts
+      IO.puts("\n\n#{b}\n\n")
     end
 
     board

2019/15/lib/aoc/intcode_agent.ex

@@ -42,7 +42,6 @@ defmodule AOC.IntcodeAgent do
   defp execute({:input, {address}}, state) do
     receive do
       {:input, value } ->
-        IO.puts("just received input: #{value}")
         state
         |> update_program(address, value)
         |> advance_pointer(2)

2019/15/lib/aoc/parser.ex

@@ -17,4 +17,30 @@ defmodule AOC.Parser do
     |> Enum.with_index
     |> Enum.into(%{}, fn { i, j } -> { j, i } end)
   end
+
+  def parse_2(binary) do
+    foo = binary
+    |> String.trim
+    |> String.split("\n")
+    |> Enum.with_index
+    |> Enum.map(&formatted/1)
+    |> List.flatten
+    |> Enum.into(%{})
+  end
+
+  def formatted({line, y}) do
+    line
+    |> String.graphemes
+    |> Enum.with_index
+    |> Enum.map(&(to_tuple(&1, y)))
+  end
+
+  def parse_2 do
+    {:ok, binary} = File.read("./input2.txt")
+    parse_2(binary)
+  end
+
+  defp to_tuple({".", x}, y), do: {{x, y}, 1}
+  defp to_tuple({"#", x}, y), do: {{x, y}, 0}
+  defp to_tuple({"O", x}, y), do: {{x, y}, 2}
 end

2019/15/lib/aoc/runner.ex

@@ -4,9 +4,9 @@ defmodule AOC.Runner do
   @west 3
   @east 4
 
-  @hit_wall 0
-  @moved 1
-  @found_oxygen 2
+  @wall 0
+  @empty_space 1
+  @oxygen 2
 
   alias AOC.{IntcodeAgent, Board}
 
@@ -25,21 +25,41 @@ defmodule AOC.Runner do
     AOC.Parser.parse
   end
 
+  defp maze_data do
+    AOC.Parser.parse_2
+  end
+
+  defp wait_loop(board, repair_droid, [], {0,0}, []) do
+    Board.print(board)
+  end
+
   defp wait_loop(board, repair_droid, path_remainder = [path|t], current_position, current_path) do
     [move | rest] = path
     send(:repair_droid, {:input, move})
     current_position = new_position(current_position, move)
 
-    Board.print(board)
     receive do
       {:terminating, ^repair_droid} ->
         board
-      {:input, @hit_wall, ^repair_droid} ->
+      {:input, @wall, ^repair_droid} ->
         #ignore this entire path
         send(repair_droid, {:reset, self(), structured_data()})
-        wait_loop(Map.put(board, current_position, @hit_wall), repair_droid, t, {0,0}, [])
-      {:input, @moved, ^repair_droid} ->
-        board = Map.put(board, current_position, @moved)
+        wait_loop(Map.put(board, current_position, @wall), repair_droid, t, {0,0}, [])
+      {:input, @empty_space, ^repair_droid} ->
+        board = Map.put(board, current_position, @empty_space)
+        cond do
+          rest == [] ->
+            # means we have reached the end of this track, add routes onto tail
+            # and continue _from start_
+            new_paths = add_paths(t, move, current_path ++ [move])
+            send(repair_droid, {:reset, self(), structured_data()})
+            wait_loop(board, repair_droid, new_paths, {0,0}, [])
+          true ->
+            wait_loop(board, repair_droid, [rest] ++ t, current_position, current_path ++ [move])
+        end
+      {:input, @oxygen, ^repair_droid} ->
+        board = Map.put_new(board, current_position, @oxygen)
+        IO.puts(current_path |> length |> Kernel.+(1))
         cond do
           rest == [] ->
             # means we have reached the end of this track, add routes onto tail
@@ -50,8 +70,6 @@ defmodule AOC.Runner do
           true ->
             wait_loop(board, repair_droid, [rest] ++ t, current_position, current_path ++ [move])
         end
-      {:input, @found_oxygen, ^repair_droid} ->
-        current_path |> length |> Kernel.+(1)
     end
   end
 
@@ -84,4 +102,38 @@ defmodule AOC.Runner do
   def new_position({x, y}, @south), do: {x, y + 1}
   def new_position({x, y}, @east), do: {x + 1, y}
   def new_position({x, y}, @west), do: {x - 1, y}
+
+
+  # part 2 functions
+  def part_2(maze \\ maze_data()) do
+    Board.print(maze)
+
+    fill_maze(maze, 0)
+  end
+
+  defp fill_maze(maze, steps) do
+    if Map.values(maze) |> Enum.uniq |> length == 1 do
+      steps - 1
+    else
+      Board.print(maze)
+      maze
+      |> Enum.filter(fn({point, v}) -> v == 2 end)
+      |> Enum.reduce(maze, &fill_oxygen/2)
+      |> fill_maze(steps + 1)
+    end
+  end
+
+  defp fill_oxygen({{x, y}, _oxygen}, maze) do
+    maze = Map.put(maze, {x, y}, @wall)
+    maze = fill_maze(maze, {x - 1, y}, Map.get(maze, {x - 1 , y}, @wall))
+    maze = fill_maze(maze, {x + 1, y}, Map.get(maze, {x + 1, y}, @wall))
+    maze = fill_maze(maze, {x, y - 1}, Map.get(maze, {x, y - 1}, @wall))
+    fill_maze(maze, {x, y + 1}, Map.get(maze, {x, y + 1}, @wall))
+  end
+
+  def fill_maze(maze, point, @wall), do: maze
+  def fill_maze(maze, point, @oxygen), do: maze
+  def fill_maze(maze, point, @empty_space) do
+    Map.put(maze, point, @oxygen)
+  end
 end

2019/15/run.exs

@@ -1,2 +1,2 @@
-IO.puts "part1 : #{ AOC.Runner.part_1 }"
+# IO.puts "part1 : #{ AOC.Runner.part_1 }"
 IO.puts "part2: #{ AOC.Runner.part_2 }"

2019/15/test/aoc/runner_test.exs

@@ -1,70 +1,16 @@
 defmodule AOCRunnerTest do
   use ExUnit.Case
-  alias AOC.{IntcodeAgent, Parser}
-
-  test "first sample works" do
-    supervisor_pid = self()
-    computer = spawn_link(fn -> IntcodeAgent.init(%{supervisor: supervisor_pid}) end)
-    send(computer, {:set_initial, self(), first_program()})
-    send(computer, :run)
-
-    assert(input_loop([], computer) == [109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99])
-  end
-
-  test "second sample works" do
-    supervisor_pid = self()
-    computer = spawn_link(fn -> IntcodeAgent.init(%{supervisor: supervisor_pid}) end)
-    send(computer, {:set_initial, self(), second_program()})
-    send(computer, :run)
-
-    assert(input_loop([], computer) == [1219070632396864])
-  end
-
-  test "third sample works" do
-    supervisor_pid = self()
-    computer = spawn_link(fn -> IntcodeAgent.init(%{supervisor: supervisor_pid}) end)
-    send(computer, {:set_initial, self(), third_program()})
-    send(computer, :run)
-
-    assert(input_loop([], computer) == [1125899906842624])
-  end
-
-  defp first_program do
-    Parser.parse("109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99")
-  end
-
-  defp second_program do
-    Parser.parse("1102,34915192,34915192,7,4,7,99,0")
-  end
-
-  defp third_program do
-    Parser.parse("104,1125899906842624,99")
-  end
-
-  defp input_loop(acc, amp) do
-    receive do
-      {:terminating, ^amp} ->
-        IO.puts("terminating")
-        acc
-      {:input, value, ^amp} ->
-        input_loop(acc ++ [value], amp)
-    end
+  alias AOC.{Runner, Parser}
+
+  test "first maze fill" do
+    s = """
+    ######
+    #..###
+    #.#..#
+    #.O.##
+    ######
+    """
+
+    assert(Runner.part_2(Parser.parse_2(s)) == 4)
   end
 end
-
-
-
-#     Input.start_link([])
-#   end
-
-  # test "sample best works" do
-  #   Input.start_link([])
-  #   assert(Runner.part_1(Parser.parse("3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0")) == 43210)
-  # end
-
-  # test "sample feedback works" do
-  #   assert(Runner.part_2(Parser.parse("3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5")) == 139629729)
-  # end
-# end
-
-