advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ahorner/2019/13_2.yml

@@ -0,0 +1,43 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    TILES = [".", "|", "#", "_", "o"].freeze
+
+    def render(tiles)
+      screen = Hash.new(0)
+      score = 0
+
+      tiles.each_slice(3) do |x, y, value|
+        if x == -1 && y == 0
+          score = value
+        else
+          screen[[x, y]] = value
+        end
+      end
+
+      [screen, score]
+    end
+
+    cabinet = Computer.new(INTCODE)
+    screen, = render(cabinet.run)
+    solve!("The total number of blocks is:", screen.values.count { |tile| tile == TILES.index("#") })
+
+    playable = INTCODE.dup
+    playable[0] = 2
+    cabinet = Computer.new(playable)
+
+    final_score = loop do
+      ball, = screen.detect { |_coords, tile| tile == TILES.index("o") }
+      paddle, = screen.detect { |_coords, tile| tile == TILES.index("_") }
+      joystick = ball[0] <=> paddle[0]
+
+      updates, score = render(cabinet.run(inputs: [joystick]))
+      screen.merge!(updates)
+
+      break score if screen.values.none? { |tile| tile == TILES.index("#") }
+    end
+
+    solve!("The score after breaking all blocks is:", final_score)

data/data/solutions/github/ahorner/2019/14_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/14_2.yml

@@ -0,0 +1,60 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    REACTION_MATCHER = /\A(?<inputs>.+) => (?<output>.+)\z/
+    CHEMICAL_MATCHER = /(?<quantity>\d+) (?<name>.+)/
+
+    REACTIONS = INPUT.split("\n").each_with_object({}) do |line, reactions|
+      reaction = line.match(REACTION_MATCHER)
+      output = reaction[:output].match(CHEMICAL_MATCHER)
+      inputs = reaction[:inputs].split(", ").map do |input|
+        input = input.match(CHEMICAL_MATCHER)
+        {name: input[:name], quantity: input[:quantity].to_i}
+      end
+
+      reactions[output[:name]] = {
+        quantity: output[:quantity].to_i,
+        inputs: inputs
+      }
+    end
+
+    def ore_needed(chemical, quantity = 1)
+      requirements = Hash.new(0)
+      requirements[chemical] = quantity
+
+      loop do
+        chemical, quantity = requirements.detect { |name, quantity| name != "ORE" && quantity > 0 }
+
+        reaction = REACTIONS[chemical]
+        output = reaction[:quantity]
+        batches = (quantity.to_f / output).ceil
+        requirements[chemical] -= output * batches
+
+        reaction[:inputs].each { |input| requirements[input[:name]] += input[:quantity] * batches }
+
+        break if requirements.none? { |name, quantity| name != "ORE" && quantity > 0 }
+      end
+
+      requirements["ORE"]
+    end
+
+    solve!("The amount of ORE needed to produce 1 FUEL is:", ore_needed("FUEL"))
+
+    def maximum_output(chemical, ore)
+      maximum = ore_needed(chemical)
+      low = 0
+      high = ore / maximum * 2
+
+      loop do
+        break if low >= high
+
+        mid = ((low + high) / 2.0).ceil
+        req = ore_needed(chemical, mid)
+        (req > ore) ? high = mid - 1 : low = mid
+      end
+
+      low
+    end
+
+    solve!("The maximum amount of fuel you can product with 1 trillion ORE is:", maximum_output("FUEL", 1_000_000_000_000))

data/data/solutions/github/ahorner/2019/15_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/15_2.yml

@@ -0,0 +1,175 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    class Blueprint
+      DIRECTIONS = [[0, -1], [0, 1], [-1, 0], [1, 0]].freeze
+      DROID = -1
+      WALL = 0
+      OXYGEN_SYSTEM = 2
+
+      def initialize(map)
+        @map = map
+      end
+
+      def droid
+        @map.key(DROID)
+      end
+
+      def oxygen_system
+        @map.key(OXYGEN_SYSTEM)
+      end
+
+      def wall?(coords)
+        @map[coords] == WALL
+      end
+
+      def adjacent_coords((x, y))
+        DIRECTIONS.map { |i, j| [x + i, y + j] }.reject { |coords| wall?(coords) }
+      end
+    end
+
+    class Droid
+      MOVEMENTS = [1, 2, 3, 4].zip(Blueprint::DIRECTIONS).to_h.freeze
+      REVERSE = {1 => 2, 2 => 1, 3 => 4, 4 => 3}.freeze
+      SUCCESS_CODES = [1, 2].freeze
+
+      def initialize(_program)
+        @computer = Computer.new(INTCODE)
+        @x = 0
+        @y = 0
+      end
+
+      def blueprint
+        map = {[@x, @y] => Blueprint::DROID}
+        queues = {[@x, @y] => MOVEMENTS.keys}
+        path = []
+
+        loop do
+          break if queues.all? { |_, t| t.empty? }
+
+          if queues[[@x, @y]].empty?
+            backtrack = REVERSE[path.pop]
+            @computer.run(inputs: [backtrack])
+            @x, @y = move(backtrack)
+            next
+          end
+
+          direction = queues[[@x, @y]].shift
+          newx, newy = move(direction)
+
+          output = @computer.run(inputs: [direction]).last
+          map[[newx, newy]] ||= output
+
+          next unless SUCCESS_CODES.include?(output)
+
+          @x = newx
+          @y = newy
+          queues[[@x, @y]] ||= MOVEMENTS.keys - [REVERSE[direction]]
+          path << direction
+        end
+
+        Blueprint.new(map)
+      end
+
+      private
+
+      def move(direction)
+        [@x + MOVEMENTS[direction][0], @y + MOVEMENTS[direction][1]]
+      end
+    end
+
+    class Pathfinder
+      class PriorityQueue
+        def initialize
+          @list = []
+        end
+
+        def add(priority, item)
+          @list << [priority, @list.length, item]
+          @list.sort!
+        end
+
+        def next
+          @list.shift[2]
+        end
+
+        def empty?
+          @list.empty?
+        end
+      end
+
+      def initialize(map)
+        @map = map
+      end
+
+      def path(start, target)
+        estimator = proc { |(x, y)| (target[0] - x).abs + (target[1] - y).abs }
+        traverse(start, estimator: estimator) { |spot, path| return path if spot == target }
+      end
+
+      private
+
+      def traverse(start, estimator: proc { 0 })
+        found = {}
+        queue = PriorityQueue.new
+        queue.add(1, [start, [], 0])
+
+        loop do
+          break if queue.empty?
+
+          spot, path, steps = queue.next
+          next if found[spot]
+
+          yield spot, path
+
+          found[spot] = true
+          @map.adjacent_coords(spot).each do |new_spot|
+            next if found[new_spot]
+
+            new_steps = steps + 1
+
+            queue.add(
+              new_steps + estimator.call(new_spot),
+              [new_spot, [*path, new_spot], new_steps]
+            )
+          end
+        end
+      end
+    end
+
+    class OxygenSystem
+      def initialize(map)
+        @map = map
+      end
+
+      def fill_from(target)
+        oxygenated = {}
+        sources = [target]
+        minutes = 0
+
+        loop do
+          sources = sources.flat_map do |source|
+            oxygenated[source] = true
+            @map.adjacent_coords(source).reject { |spot| oxygenated[spot] }
+          end
+
+          break minutes if sources.empty?
+
+          minutes += 1
+        end
+      end
+    end
+
+    droid = Droid.new(INTCODE)
+    blueprint = droid.blueprint
+
+    pathfinder = Pathfinder.new(blueprint)
+    path = pathfinder.path(blueprint.droid, blueprint.oxygen_system)
+    solve!("The minimum path length to the oxygen system is:", path.length)
+
+    oxygen = OxygenSystem.new(blueprint)
+    minutes = oxygen.fill_from(blueprint.oxygen_system)
+    solve!("The number of minutes it will take to fill the map with oxygen is:", minutes)

data/data/solutions/github/ahorner/2019/16_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/16_2.yml

@@ -0,0 +1,37 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    SIGNAL = INPUT.chars.map(&:to_i)
+    BASE_PATTERN = [0, 1, 0, -1].freeze
+
+    def fft(signal)
+      signal.length.times.map do |position|
+        signal.each_with_index.sum { |n, i| n * pattern_for(position, i) }.abs % 10
+      end
+    end
+
+    def pattern_for(position, index)
+      BASE_PATTERN[((index + 1) / (position + 1)) % BASE_PATTERN.length]
+    end
+
+    signal = SIGNAL.dup
+    PHASES ||= 100
+    PHASES.times { signal = fft(signal) }
+
+    solve!("The first eight digits are:", signal.first(8).join)
+
+    def partial_fft(signal)
+      partial_sum = signal.sum
+      signal.length.times.map do |i|
+        value = partial_sum.abs % 10
+        partial_sum -= signal[i]
+        value
+      end
+    end
+
+    offset = SIGNAL.first(7).join.to_i
+    signal = (SIGNAL * 10_000)[offset..]
+    PHASES.times { |_i| signal = partial_fft(signal) }
+
+    solve!("The eight-digit message is:", signal.first(8).join)

data/data/solutions/github/ahorner/2019/17_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/17_2.yml

@@ -0,0 +1,118 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    class Navigator
+      MOVES = {"^" => [0, -1], ">" => [1, 0], "v" => [0, 1], "<" => [-1, 0]}.freeze
+      DIRECTIONS = MOVES.keys
+      TURNS = {"L" => -1, "R" => 1}.freeze
+
+      def initialize(map)
+        @map = map
+      end
+
+      def path
+        path = []
+        position, dir = @map.detect { |_, c| MOVES.key?(c) }
+        x, y = position
+
+        loop do
+          i, j = MOVES[dir]
+
+          if @map[[x + i, y + j]] == "#"
+            count = 0
+
+            loop do
+              x += i
+              y += j
+              count += 1
+              break unless @map[[x + i, y + j]] == "#"
+            end
+
+            path << count
+          else
+            turn = TURNS.keys.detect do |t|
+              m, n = MOVES[turn_to(dir, t)]
+              @map[[x + m, y + n]] == "#"
+            end
+
+            break unless turn
+
+            path << turn
+            dir = turn_to(dir, turn)
+          end
+        end
+
+        path.join(",")
+      end
+
+      private
+
+      def turn_to(direction, turn)
+        current = DIRECTIONS.index(direction)
+        DIRECTIONS[(current + TURNS[turn]) % DIRECTIONS.count]
+      end
+    end
+
+    class PathCompressor
+      FUNCTIONS = %w[A B C].freeze
+      MEMORY_LIMIT = 20
+
+      def initialize(path)
+        @path = path
+      end
+
+      def main_routine
+        FUNCTIONS.zip(functions).reduce(@path) { |routine, (f, function)| routine.gsub(function, f) }
+      end
+
+      def functions(path = @path, current = [])
+        return current if path.empty?
+        return nil if current.length >= FUNCTIONS.length
+
+        candidates = (1..MEMORY_LIMIT).map { |i| normalize(path[0..i]) }.uniq
+        candidates.detect do |candidate|
+          new_path = normalize(path.gsub(candidate, ""))
+          final = functions(new_path, current + [candidate])
+          break final if final
+        end
+      end
+
+      private
+
+      def normalize(path)
+        path.sub(/^,+/, "").sub(/,+$/, "")
+      end
+    end
+
+    x = 0
+    y = 0
+
+    MAP = Computer.new(INTCODE).run.each_with_object({}) do |tile, map|
+      if tile == 10
+        x = 0
+        y += 1
+        next
+      else
+        map[[x, y]] = tile.chr
+        x += 1
+      end
+    end
+
+    intersections = MAP.select do |(x, y), tile|
+      tile == "#" && Navigator::MOVES.all? { |_, (i, j)| MAP[[x + i, y + j]] == "#" }
+    end
+
+    solve!("The sum of alignment parameters is:", intersections.sum { |(i, j), _| i * j })
+
+    path = Navigator.new(MAP).path
+    compressor = PathCompressor.new(path)
+    instructions = [compressor.main_routine, *compressor.functions, "n"]
+
+    wakeup = INTCODE.dup.tap { |program| program[0] = 2 }
+    vacuum = Computer.new(wakeup)
+    output = instructions.flat_map { |line| vacuum.run(inputs: line.chars.map(&:ord) + [10]) }
+
+    solve!("The amount of dust collected is:", output.last)

data/data/solutions/github/ahorner/2019/18_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/18_2.yml

@@ -0,0 +1,135 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    GRID = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), grid|
+      line.chars.each_with_index { |tile, x| grid[[x, y]] = tile }
+    end.freeze
+
+    class Vault
+      DIRECTIONS = [[0, -1], [0, 1], [-1, 0], [1, 0]].freeze
+
+      KEY_MATCHER = /\A[[:lower:]]\z/
+      DOOR_MATCHER = /\A[[:upper:]]\z/
+
+      ENTRANCE = "@".freeze
+      WALL = "#".freeze
+
+      def initialize(map)
+        @map = map
+      end
+
+      def chambers
+        entrances.keys
+      end
+
+      def key_paths
+        @key_paths ||= keys.merge(entrances).each_with_object({}) do |(key, location), routes|
+          queue = [[location, []]]
+          distances = {location => 0}
+          keys = []
+
+          while queue.any?
+            tile, requirements = queue.shift
+
+            adjacent_tiles(tile).each do |target|
+              next if distances[target]
+
+              distances[target] = distances[tile] + 1
+              keys << [@map[target], requirements, distances[target]] if key?(target)
+
+              queue << if interactive?(target)
+                [target, requirements + [@map[target].downcase]]
+              else
+                [target, requirements]
+              end
+            end
+          end
+
+          routes[key] = keys
+        end
+      end
+
+      private
+
+      def keys
+        @keys ||= @map.each_with_object({}) do |(tile, c), collection|
+          collection[c] = tile if key?(tile)
+        end
+      end
+
+      def entrances
+        @entrances ||= begin
+          entrance_tiles = @map.select { |_, c| c == ENTRANCE }
+          entrance_tiles.map.with_index { |(tile, _), chamber| ["@#{chamber}", tile] }.to_h
+        end
+      end
+
+      def interactive?(tile)
+        door?(tile) || key?(tile)
+      end
+
+      def door?(tile)
+        @map[tile] =~ DOOR_MATCHER
+      end
+
+      def key?(tile)
+        @map[tile] =~ KEY_MATCHER
+      end
+
+      def wall?(tile)
+        @map[tile] == WALL
+      end
+
+      def adjacent_tiles((x, y))
+        DIRECTIONS.map { |i, j| [x + i, y + j] }.reject { |coords| wall?(coords) }
+      end
+    end
+
+    class Explorer
+      def initialize(key_paths)
+        @key_paths = key_paths
+      end
+
+      def steps_from(origins, inventory = [], cache = {})
+        cache[[origins.sort.join, inventory.sort.join]] ||= begin
+          keys = reachable_keys(origins, inventory)
+
+          if keys.any?
+            keys.map do |chamber, key, distance|
+              positions = origins.dup.tap { |pos| pos[chamber] = key }
+              distance + steps_from(positions, inventory + [key], cache)
+            end.min
+          else
+            0
+          end
+        end
+      end
+
+      private
+
+      def reachable_keys(origins, inventory)
+        origins.each_with_index.each_with_object([]) do |(origin, chamber), keys|
+          @key_paths[origin].each do |key, requirements, distance|
+            next if inventory.include?(key)
+            next unless (requirements - inventory).empty?
+
+            keys << [chamber, key, distance]
+          end
+        end
+      end
+    end
+
+    vault = Vault.new(GRID)
+    explorer = Explorer.new(vault.key_paths)
+    solve!("The minimum number of steps to find all keys is:", explorer.steps_from(vault.chambers))
+
+    CHAMBERED_GRID = GRID.dup.tap do |grid|
+      x, y = GRID.key(Vault::ENTRANCE)
+      [[-1, -1], [1, -1], [-1, 1], [1, 1]].each { |i, j| grid[[x + i, y + j]] = Vault::ENTRANCE }
+      [[0, -1], [-1, 0], [0, 0], [1, 0], [0, 1]].each { |i, j| grid[[x + i, y + j]] = Vault::WALL }
+    end.freeze
+
+    vault = Vault.new(CHAMBERED_GRID)
+    explorer = Explorer.new(vault.key_paths)
+    solve!("The minimum number of steps to find all keys in the chambered vault is:", explorer.steps_from(vault.chambers))

data/data/solutions/github/ahorner/2019/19_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2019/19_2.yml

@@ -0,0 +1,37 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    class Beam
+      def initialize(program)
+        @program = program
+      end
+
+      def pulls?(x, y)
+        Computer.new(@program).run(inputs: [x, y]).last == 1
+      end
+
+      def fit_point(size)
+        offset = size - 1
+        x = 0
+        y = size + 1
+
+        loop do
+          x += 1 until pulls?(x, y)
+          break [x, y - offset] if pulls?(x + offset, y - offset)
+
+          y += 1
+        end
+      end
+    end
+
+    beam = Beam.new(INTCODE)
+
+    grid = {}
+    50.times { |y| 50.times { |x| grid[[x, y]] = beam.pulls?(x, y) } }
+    solve!("The number of beam points in a 50x50 grid is:", grid.count(&:last))
+
+    x, y = beam.fit_point(100)
+    solve!("The best 100x100 is:", (x * 10_000) + y)

data/data/solutions/github/ahorner/2019/20_1.yml

@@ -0,0 +1 @@
+--- []