advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,89 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    class Droplet
+      SIDES = [
+        Vector[1, 0, 0],
+        Vector[-1, 0, 0],
+        Vector[0, 1, 0],
+        Vector[0, -1, 0],
+        Vector[0, 0, 1],
+        Vector[0, 0, -1]
+      ]
+
+      attr_reader :positions
+
+      def initialize(positions)
+        @positions = positions
+        @cubes = positions.to_h { |pos| [pos, true] }
+
+        minx, maxx = positions.map { |c| c[0] }.minmax
+        miny, maxy = positions.map { |c| c[1] }.minmax
+        minz, maxz = positions.map { |c| c[2] }.minmax
+        @ranges = [[minx, maxx], [miny, maxy], [minz, maxz]]
+
+        @trapped = {}
+      end
+
+      def [](position)
+        @cubes[position]
+      end
+
+      def external?(position)
+        @ranges.each_with_index.any? do |(min, max), i|
+          position[i] < min || position[i] > max
+        end
+      end
+
+      def trapped?(position)
+        return false if external?(position)
+
+        queue = SIDES.map { |side| position + side }
+        tested = {position => true}
+
+        trapped = loop do
+          position = queue.shift
+          break true if position.nil?
+
+          next if @cubes[position]
+          next if tested[position]
+          tested[position] = true
+
+          break @trapped[position] if @trapped.key?(position)
+          break false if external?(position)
+
+          SIDES.each do |side|
+            new_position = position + side
+            queue << new_position unless tested[new_position] || @cubes[new_position]
+          end
+        end
+
+        tested.each_key { |pos| @trapped[pos] = trapped }
+        trapped
+      end
+    end
+
+    DROPLET = Droplet.new(
+      INPUT.split("\n").map do |line|
+        Vector[*line.split(",").map(&:to_i)]
+      end
+    )
+
+    exposed = DROPLET.positions.flat_map do |cube|
+      Droplet::SIDES.filter_map do |side|
+        cube + side unless DROPLET[cube + side]
+      end
+    end
+    solve!(
+      "The surface area of the lava droplet is:",
+      exposed.count
+    )
+
+    external = exposed.reject { |position| DROPLET.trapped?(position) }
+    solve!(
+      "The exterior surface area of the lava droplet is:",
+      external.count
+    )

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

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

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

@@ -0,0 +1,117 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    class Resource < Vector
+      TYPES = %i[ore clay obsidian geode]
+
+      def [](type)
+        case type
+        when :ore then super(0)
+        when :clay then super(1)
+        when :obsidian then super(2)
+        when :geode then super(3)
+        else super
+        end
+      end
+    end
+
+    class Blueprint
+      BOTS = {
+        ore: Vector[1, 0, 0, 0],
+        clay: Vector[0, 1, 0, 0],
+        obsidian: Vector[0, 0, 1, 0],
+        geode: Vector[0, 0, 0, 1]
+      }
+
+      attr_reader :id
+
+      def initialize(id:, bots:)
+        @id = id
+        @bots = bots
+        @needs = Resource::TYPES.to_h do |resource|
+          [resource, @bots.map { |_, cost| cost[resource] }.max]
+        end
+      end
+
+      def [](resource)
+        @bots[resource]
+      end
+
+      def max_needed(resource)
+        @needs[resource]
+      end
+
+      def impossible?(bot, production)
+        costs = @bots[bot]
+        Resource::TYPES.any? do |resource|
+          costs[resource] > 0 && production[resource] == 0
+        end
+      end
+
+      def buildable?(bot, resources)
+        (resources - self[bot]).none?(&:negative?)
+      end
+    end
+
+    BLUEPRINT_MATCHER = /Blueprint (?<id>\d+)/
+    BOT_MATCHER = /Each (?<resource>[a-z]+) robot costs (?<costs>[^.]+)\./
+    RESOURCE_MATCHER = /(?<amount>\d+) (?<resource>[a-z]+)/
+
+    BLUEPRINTS = INPUT.split("\n").map do |description|
+      id = BLUEPRINT_MATCHER.match(description)[:id].to_i
+      bots = description.scan(BOT_MATCHER).to_h do |bot, costs|
+        costs = costs.scan(RESOURCE_MATCHER).to_h { |amount, resource| [resource.to_sym, amount] }
+        costs = Resource::TYPES.map { |resource| costs[resource].to_i }
+
+        [bot.to_sym, Resource[*costs]]
+      end
+
+      Blueprint.new(id:, bots:)
+    end
+
+    def potential_geodes(time)
+      (time - 1) * time / 2
+    end
+
+    def max_geodes(blueprint, time, focus: nil, production: Resource[1, 0, 0, 0], inventory: Resource[0, 0, 0, 0], best: 0)
+      if focus.nil?
+        return Resource::TYPES.reduce(best) do |best, resource|
+          max_geodes(blueprint, time, focus: resource, production:, inventory:, best:)
+        end
+      end
+
+      return [best, inventory[:geode]].max if focus != :geode && production[focus] >= blueprint.max_needed(focus)
+      return [best, inventory[:geode]].max if blueprint.impossible?(focus, production)
+
+      theoretical = inventory[:geode] + production[:geode] * time + potential_geodes(time)
+      return best if theoretical <= best
+
+      loop do
+        break [best, inventory[:geode]].max if time == 0
+
+        if blueprint.buildable?(focus, inventory)
+          new_inventory = inventory - blueprint[focus] + production
+          new_production = production + Blueprint::BOTS[focus]
+
+          return Resource::TYPES.reduce(best) do |best, resource|
+            max_geodes(blueprint, time - 1, focus: resource, production: new_production, inventory: new_inventory, best:)
+          end
+        end
+
+        time -= 1
+        inventory += production
+      end
+    end
+
+    solve!(
+      "The sum of blueprint quality levels is:",
+      BLUEPRINTS.map { |bp| bp.id * max_geodes(bp, 24) }.sum
+    )
+
+    solve!(
+      "The product of maximum geodes opened is:",
+      BLUEPRINTS.first(3).map { |bp| max_geodes(bp, 32) }.reduce(:*)
+    )

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

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

data/data/solutions/github/ahorner/2022/20_2.yml

@@ -0,0 +1,50 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    class EncryptedFile
+      COORDS = [1000, 2000, 3000]
+
+      Number = Struct.new(:value, :position)
+
+      def initialize(values)
+        @numbers = values.map.with_index { |v, i| Number.new(v, i) }
+        @order = @numbers.dup
+      end
+
+      def mix!(times = 1)
+        times.times do
+          @order.each do |number|
+            @numbers.rotate!(@numbers.index(number))
+            @numbers.shift
+            @numbers.rotate!(number.value)
+            @numbers.unshift(number)
+          end
+        end
+      end
+
+      def coords
+        values = @numbers.map(&:value)
+        i = values.index(0)
+
+        COORDS.map { |c| values[(i + c) % values.size] }
+      end
+    end
+
+    NUMBERS = INPUT.split("\n").map(&:to_i)
+    file = EncryptedFile.new(NUMBERS)
+    file.mix!
+
+    solve!(
+      "The sum of the grove coordinates is:",
+      file.coords.sum
+    )
+
+    DECRYPTION_KEY = 811589153
+    file = EncryptedFile.new(NUMBERS.map { |n| n * DECRYPTION_KEY })
+    file.mix!(10)
+
+    solve!(
+      "The sum of the decrypted grove coordinates is:",
+      file.coords.sum
+    )

data/data/solutions/github/ahorner/2022/21_1.yml

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

data/data/solutions/github/ahorner/2022/21_2.yml

@@ -0,0 +1,99 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    class MonkeyBunch
+      MONKEY_MATCHER = /^(?<name>[a-z]+): (?<job>.+)$/
+      JOB_MATCHER = /^(?<first>[a-z]+) (?<operand>.) (?<second>[a-z]+)$/
+      NUMBER_MATCHER = /^[0-9]+/
+
+      def initialize(monkeys)
+        @jobs = monkeys.to_h do |monkey|
+          data = MONKEY_MATCHER.match(monkey)
+          [data[:name], data[:job]]
+        end
+
+        @results = {}
+      end
+
+      def [](name)
+        @results[name] = begin
+          case @jobs[name]
+          when JOB_MATCHER
+            operate($~[:operand], self[$~[:first]], self[$~[:second]])
+          when NUMBER_MATCHER
+            @jobs[name].to_i
+          end
+        end
+      end
+
+      def value_for(name)
+        yells = results
+        friends = connected_to(name)
+        test_from = "root"
+        value = nil
+
+        loop do
+          break value if test_from == name
+
+          job = JOB_MATCHER.match(@jobs[test_from])
+          known, test_from, pos =
+            if friends.include?(job[:first])
+              [yells[job[:second]], job[:first], 1]
+            else
+              [yells[job[:first]], job[:second], 2]
+            end
+
+          value = value ? invert(job[:operand], value, known, pos) : known
+        end
+      end
+
+      private
+
+      def operate(operand, i, j)
+        case operand
+        when "+" then i + j
+        when "-" then i - j
+        when "*" then i * j
+        when "/" then i / j
+        end
+      end
+
+      def invert(operand, final, n, pos)
+        case operand
+        when "+" then final - n
+        when "-" then (pos == 1) ? final + n : n - final
+        when "*" then final / n
+        when "/" then (pos == 1) ? final * n : n / final
+        end
+      end
+
+      def results
+        @results = {}
+        self["root"]
+
+        @results
+      end
+
+      def connected_to(name)
+        original = @jobs[name]
+
+        initial = results
+        @jobs[name] = "0"
+        changed = results
+
+        @jobs[name] = original
+
+        changed.keys.select { |k| changed[k] != initial[k] }
+      end
+    end
+
+    bunch = MonkeyBunch.new(INPUT.split("\n"))
+    solve!(
+      "The root monkey yells:",
+      bunch["root"]
+    )
+    solve!(
+      "To make the root monkey happy, you should yell:",
+      bunch.value_for("humn")
+    )

data/data/solutions/github/ahorner/2022/22_1.yml

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

data/data/solutions/github/ahorner/2022/22_2.yml

@@ -0,0 +1,214 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    class Board
+      MOVEMENT = {
+        right: Vector[1, 0],
+        down: Vector[0, 1],
+        left: Vector[-1, 0],
+        up: Vector[0, -1]
+      }
+      DIRECTIONS = MOVEMENT.keys
+
+      attr_reader :map, :width, :height
+
+      def initialize(diagram)
+        @map = diagram.split("\n").each_with_index.each_with_object({}) do |(row, y), map|
+          row.chars.each_with_index do |tile, x|
+            next if tile == " "
+            map[Vector[x + 1, y + 1]] = tile == "."
+          end
+        end
+
+        @width = @map.keys.map { |p| p[0] }.max
+        @height = @map.keys.map { |p| p[1] }.max
+      end
+
+      def move(position, facing, steps)
+        steps.times do
+          test = position + MOVEMENT[facing]
+          direction = facing
+
+          test, direction = wrap_to(position, facing) unless @map.key?(test)
+
+          if @map[test]
+            position = test
+            facing = direction
+          else
+            break [position, facing]
+          end
+        end
+
+        [position, facing]
+      end
+
+      def wrap_to(position, facing)
+        search_from =
+          case facing
+          when :right then Vector[1, position[1]]
+          when :down then Vector[position[0], 1]
+          when :left then Vector[width, position[1]]
+          when :up then Vector[position[0], height]
+          end
+
+        loop do
+          break [search_from, facing] if map.key?(search_from)
+          search_from += MOVEMENT[facing]
+        end
+      end
+
+      def start
+        wrap_to(Vector[width, 1], :right)
+      end
+    end
+
+    class Cube < Board
+      MOVEMENT = {
+        right: Vector[1, 0, 0],
+        down: Vector[0, 1, 0],
+        left: Vector[-1, 0, 0],
+        up: Vector[0, -1, 0]
+      }
+
+      Orientation = Struct.new(:u, :v, :w)
+
+      def initialize(diagram, size)
+        super(diagram)
+        @size = size
+      end
+
+      def regions
+        @regions ||= (1...height).step(CUBE_SIZE).each_with_object({}) do |row, regions|
+          (1...width).step(CUBE_SIZE).each do |column|
+            corner = Vector[column, row]
+            next unless map.key?(corner)
+
+            regions[corner] = region_vector(corner)
+          end
+        end
+      end
+
+      def faces
+        return @faces if defined?(@faces)
+
+        @faces = {}
+
+        corner = regions.keys.first
+        @faces[corner] = Orientation.new(Vector[1, 0, 0], Vector[0, 1, 0], Vector[0, 0, 1])
+
+        queue = [[corner, @faces[corner]]]
+
+        loop do
+          break @faces if queue.empty?
+
+          corner, face = queue.pop
+          neighbors(corner).each do |neighbor, adjacency|
+            next if @faces.key?(neighbor)
+
+            @faces[neighbor] = Orientation.new(
+              *case adjacency
+               when :right then [-face.w, face.v, face.u]
+               when :down then [face.u, -face.w, face.v]
+               when :left then [face.w, face.v, -face.u]
+               when :up then [face.u, face.w, -face.v]
+               end
+            )
+
+            queue << [neighbor, @faces[neighbor]]
+          end
+        end
+      end
+
+      def start
+        [regions.keys.first, :right]
+      end
+
+      private
+
+      def wrap_to(position, facing)
+        corner = regions.key(region_vector(position))
+        face = faces[corner]
+
+        adjacent = faces.values.find { |test| direction_to(face, test) == facing }
+        reflection = direction_to(adjacent, face)
+
+        normalized = position - faces.key(face)
+        mapped =
+          case [facing, reflection]
+          when [:right, :right], [:down, :up], [:left, :left], [:up, :down]
+            Vector[normalized[0], @size - 1 - normalized[1]]
+          when [:right, :down], [:down, :right], [:left, :up], [:up, :left]
+            Vector[normalized[1], normalized[0]]
+          when [:right, :left], [:left, :right]
+            normalized
+          when [:right, :up], [:down, :left], [:left, :down], [:up, :right]
+            Vector[@size - 1 - normalized[1], @size - 1 - normalized[0]]
+          when [:down, :down], [:up, :up]
+            Vector[@size - 1 - normalized[0], normalized[1]]
+          end
+
+        [mapped + faces.key(adjacent), DIRECTIONS[(DIRECTIONS.index(reflection) + 2) % DIRECTIONS.size]]
+      end
+
+      def direction_to(from, to)
+        case to.w
+        when from.u then :right
+        when from.v then :down
+        when -from.u then :left
+        when -from.v then :up
+        end
+      end
+
+      def region_vector(position)
+        Vector[(position[0] - 1) / @size, (position[1] - 1) / @size]
+      end
+
+      def neighbors(corner)
+        [
+          [Vector[corner[0] + @size, corner[1]], :right],
+          [Vector[corner[0], corner[1] + @size], :down],
+          [Vector[corner[0] - @size, corner[1]], :left],
+          [Vector[corner[0], corner[1] - @size], :up]
+        ].select { |c, _| regions.key?(c) }
+      end
+    end
+
+    def travel(board)
+      position, facing = board.start
+
+      INSTRUCTIONS.scan(/[0-9]+|L|R/) do |token|
+        case token
+        when "L", "R"
+          turn = (token == "L") ? -1 : 1
+          index = (Board::DIRECTIONS.index(facing) + turn) % Board::DIRECTIONS.size
+          facing = Board::DIRECTIONS[index]
+        else
+          position, facing = board.move(position, facing, token.to_i)
+        end
+      end
+
+      [position, facing]
+    end
+
+    def score_for(position, facing)
+      1000 * position[1] + 4 * position[0] + Board::DIRECTIONS.index(facing)
+    end
+
+    MAP, INSTRUCTIONS = INPUT.split("\n\n")
+    BOARD = Board.new(MAP)
+
+    solve!(
+      "The final password on a simple board is:",
+      score_for(*travel(BOARD))
+    )
+
+    CUBE_SIZE ||= 50
+    CUBE = Cube.new(MAP, CUBE_SIZE)
+
+    solve!(
+      "The final password on a folded cube is:",
+      score_for(*travel(CUBE))
+    )

data/data/solutions/github/ahorner/2022/23_1.yml

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

data/data/solutions/github/ahorner/2022/23_2.yml

@@ -0,0 +1,76 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "set"
+    require "matrix"
+
+    ELVES = INPUT.split("\n").flat_map.with_index do |line, y|
+      line.chars.filter_map.with_index { |c, x| Vector[x, y] if c == "#" }
+    end.to_set
+
+    DIRECTIONS = {
+      north: [Vector[0, -1], Vector[-1, -1], Vector[1, -1]],
+      south: [Vector[0, 1], Vector[-1, 1], Vector[1, 1]],
+      west: [Vector[-1, 0], Vector[-1, -1], Vector[-1, 1]],
+      east: [Vector[1, 0], Vector[1, -1], Vector[1, 1]]
+    }
+    NEIGHBORS = DIRECTIONS.values.flatten.uniq
+    MOVES = DIRECTIONS.to_h { |k, v| [k, v.first] }
+
+    def proposals_for(elves, sequence)
+      elves.each_with_object(Hash.new { |h, k| h[k] = [] }) do |coord, proposals|
+        next if NEIGHBORS.none? { |dv| elves.include?(coord + dv) }
+
+        proposed = sequence.find { |dir| DIRECTIONS[dir].none? { |dv| elves.include?(coord + dv) } }
+        next unless proposed
+
+        proposals[coord + MOVES[proposed]] << coord
+      end
+    end
+
+    def apply(elves, proposals)
+      proposals.each_with_object(elves.dup) do |(coord, candidates), final|
+        next unless candidates.size == 1
+
+        final.delete(candidates.first)
+        final << coord
+      end
+    end
+
+    elves = ELVES
+    sequence = DIRECTIONS.keys
+
+    10.times do
+      proposals = proposals_for(elves, sequence)
+      elves = apply(elves, proposals)
+
+      sequence = sequence.rotate(1)
+    end
+
+    minx, maxx = elves.map { |coord| coord[0] }.minmax
+    miny, maxy = elves.map { |coord| coord[1] }.minmax
+
+    solve!(
+      "The empty ground tile count after 10 rounds is:",
+      (maxx - minx + 1) * (maxy - miny + 1) - elves.count
+    )
+
+    def diffusion_time(elves)
+      sequence = DIRECTIONS.keys
+      rounds = 1
+
+      loop do
+        proposals = proposals_for(elves, sequence)
+        break rounds if proposals.none?
+        elves = apply(elves, proposals)
+
+        sequence = sequence.rotate(1)
+        rounds += 1
+      end
+    end
+
+    solve!(
+      "The first round in which no elves move is:",
+      diffusion_time(ELVES)
+    )

data/data/solutions/github/ahorner/2022/24_1.yml

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