advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,101 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    class Monkey
+      PATTERN = Regexp.new(<<~REGEXP.strip)
+        Monkey (?<id>\\d+):
+          Starting items: (?<items>[0-9 ,]+)
+          Operation: new = old (?<operator>.) (?<value>.+)
+          Test: divisible by (?<test>\\d+)
+            If true: throw to monkey (?<pass>\\d+)
+            If false: throw to monkey (?<fail>\\d+)
+      REGEXP
+
+      attr_reader :id, :inspections, :test
+
+      def initialize(definition)
+        data = PATTERN.match(definition)
+
+        @id = data[:id].to_i
+        @items = data[:items].split(", ").map(&:to_i)
+        @operation = {
+          operator: data[:operator].to_sym,
+          value: data[:value]
+        }
+
+        @test = data[:test].to_i
+        @pass = data[:pass].to_i
+        @fail = data[:fail].to_i
+
+        @inspections = 0
+      end
+
+      def inspect!(limiter = nil)
+        loop do
+          break if @items.empty?
+
+          @inspections += 1
+          item = @items.pop
+
+          value = @operation[:value]
+          value = (value == "old") ? item : value.to_i
+
+          item =
+            case @operation[:operator]
+            when :+ then (item + value)
+            when :* then (item * value)
+            end
+
+          if limiter
+            item %= limiter
+          else
+            item /= 3
+          end
+
+          result = item % @test == 0
+          yield item, (result ? @pass : @fail)
+        end
+      end
+
+      def catch!(item)
+        @items << item
+      end
+
+      def dup
+        Marshal.load(Marshal.dump(self))
+      end
+    end
+
+    MONKEYS = INPUT.split("\n\n").each_with_object({}) do |definition, monkeys|
+      monkey = Monkey.new(definition)
+      monkeys[monkey.id] = monkey
+    end.freeze
+
+    def monkey_business(rounds, limiter = nil)
+      monkeys = MONKEYS.transform_values(&:dup)
+
+      rounds.times do
+        monkeys.each do |_, monkey|
+          monkey.inspect!(limiter) do |item, recipient|
+            monkeys[recipient].catch!(item)
+          end
+        end
+      end
+
+      active = monkeys.values.max_by(2, &:inspections)
+      active.map(&:inspections).reduce(:*)
+    end
+
+    solve!(
+      "The level of monkey business is:",
+      monkey_business(20)
+    )
+
+    # We can reset the worry level of an item via modulo when it exceeds
+    # a value that's perfectly divisible by all monkeys' tests.
+    LIMITER = MONKEYS.values.map(&:test).reduce(:*)
+    solve!(
+      "The level of very worrisome monkey business is:",
+      monkey_business(10_000, LIMITER)
+    )

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

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

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

@@ -0,0 +1,84 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+    require "rb_heap/heap"
+
+    class Hill
+      DIRECTIONS = [Vector[1, 0], Vector[0, 1], Vector[-1, 0], Vector[0, -1]].freeze
+
+      def initialize(map)
+        @map = map
+      end
+
+      def origins_for(destination)
+        DIRECTIONS.filter_map do |move|
+          origin = destination + move
+          next unless @map.key?(origin)
+          next unless height(destination) - height(origin) <= 1
+
+          origin
+        end
+      end
+
+      def height(spot)
+        letter = @map[spot]
+
+        case letter
+        when "S" then "a".ord
+        when "E" then "z".ord
+        else letter.ord
+        end
+      end
+    end
+
+    class Climber
+      def initialize(hill)
+        @hill = hill
+      end
+
+      def steps_to(goal)
+        queue = Heap.new { |a, b| a[0] < b[0] }
+        queue << [0, goal]
+
+        costs = {goal => 0}
+
+        loop do
+          break costs if queue.empty?
+
+          cost, spot = queue.pop
+          @hill.origins_for(spot).each do |new_spot|
+            new_cost = cost + 1
+            next if costs.key?(new_spot) && costs[new_spot] <= new_cost
+
+            costs[new_spot] = new_cost
+            queue << [new_cost, new_spot]
+          end
+        end
+      end
+    end
+
+    MAP = INPUT.split("\n").each_with_object({}).with_index do |(line, map), y|
+      line.chars.each_with_index do |c, x|
+        map[Vector[x, y]] = c
+      end
+    end.freeze
+
+    START = MAP.key("S")
+    GOAL = MAP.key("E")
+
+    hill = Hill.new(MAP)
+    climber = Climber.new(hill)
+    steps = climber.steps_to(GOAL)
+
+    solve!(
+      "The minimum step count from S to E is:",
+      steps[START]
+    )
+
+    trailheads = MAP.filter_map { |spot, elevation| steps[spot] if elevation == "a" }
+    solve!(
+      "The minimum step count from an optimal trailhead is:",
+      trailheads.min
+    )

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

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

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

@@ -0,0 +1,49 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "delegate"
+
+    class Packet < SimpleDelegator
+      include Comparable
+
+      def <=>(other)
+        (0...[size, other.size].max).each do |i|
+          l = self[i]
+          r = other[i]
+
+          return -1 if l.nil?
+          return 1 if r.nil?
+
+          case [l.class, r.class]
+          when [Integer, Integer]
+            return -1 if l < r
+            return 1 if l > r
+          else
+            result = Packet.new(Array(l)) <=> Packet.new(Array(r))
+            return -1 if result < 0
+            return 1 if result > 0
+          end
+        end
+
+        0
+      end
+    end
+
+    PAIRS = INPUT.split("\n\n").map do |pair|
+      l, r = pair.split("\n").map(&method(:eval))
+      [Packet.new(l), Packet.new(r)]
+    end
+
+    solve!(
+      "The sum of ordered pair indices is:",
+      PAIRS.each_with_index.sum { |(l, r), i| (l < r) ? i + 1 : 0 }
+    )
+
+    DIVIDERS = [Packet.new([[2]]), Packet.new([[6]])].freeze
+    PACKETS = (PAIRS.flatten(1) + DIVIDERS).sort
+
+    solve!(
+      "The decoder key for the distress signal is:",
+      DIVIDERS.map { |p| PACKETS.index(p) + 1 }.reduce(:*)
+    )

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

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

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

@@ -0,0 +1,69 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    class Cave
+      SOURCE = Vector[500, 0]
+      TESTS = [Vector[0, 1], Vector[-1, 1], Vector[1, 1]].freeze
+
+      attr_reader :grains
+
+      def initialize(structures)
+        @map = structures.dup
+
+        @bottom = @map.keys.map { |p| p[1] }.max
+        @floor = @bottom + 2
+        @grains = 0
+      end
+
+      def drop!(void: true)
+        grain = SOURCE
+
+        loop do
+          return if void && grain[1] >= @bottom
+          break if !void && grain[1] + 1 >= @floor
+
+          direction = TESTS.find { |test| !@map.key?(grain + test) }
+          break if direction.nil?
+
+          grain += direction
+        end
+
+        @grains += 1
+        @map[grain] = @grains
+
+        grain
+      end
+    end
+
+    MAP = INPUT.split("\n").each_with_object({}) do |line, map|
+      coords = line.scan(/(\d+),(\d+)/).map { |x, y| Vector[x.to_i, y.to_i] }
+      coords.each_cons(2) do |origin, destination|
+        d = destination - origin
+        move = Vector[d[0] <=> 0, d[1] <=> 0]
+        (d.r.to_i + 1).times.map { |i| map[origin + (move * i)] = true }
+      end
+    end
+
+    cave = Cave.new(MAP)
+    loop do
+      grain = cave.drop!
+      break if grain.nil?
+    end
+
+    solve!(
+      "The count of resting grains of sand above the void is:",
+      cave.grains
+    )
+
+    loop do
+      grain = cave.drop!(void: false)
+      break if grain == Cave::SOURCE
+    end
+
+    solve!(
+      "The count of resting grains of sand with a floor is:",
+      cave.grains
+    )

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    POSITION_MATCHER = /x=(?<x>-?\d+), y=(?<y>-?\d+)/
+    ROW ||= 2_000_000
+    SEARCH_SPACE ||= 4_000_000
+    FREQUENCY_KEY = 4_000_000
+
+    pairs = INPUT.split("\n").map do |line|
+      line.scan(POSITION_MATCHER).map { |x, y| Vector[x.to_i, y.to_i] }
+    end
+
+    SENSORS = pairs.map { |sensor, beacon| [sensor, (sensor - beacon).sum(&:abs)] }
+    BEACONS = pairs.map(&:last).uniq
+
+    def merge_ranges(ranges)
+      result = []
+      current = nil
+
+      ranges.sort_by(&:begin).each do |range|
+        next current = range if current.nil?
+        next if range.end <= current.end
+
+        if current.end >= range.begin
+          current = current.begin..range.end
+        else
+          result << current
+          current = range
+        end
+      end
+
+      result << current if current
+      result
+    end
+
+    def coverage_for(row, min: -Float::INFINITY, max: Float::INFINITY)
+      ranges = SENSORS.filter_map do |sensor, range|
+        d = range - (sensor[1] - row).abs
+        next if d <= 0
+
+        x = sensor[0]
+        next if (x + d) < min
+        next if (x - d) > max
+
+        begins = [x - d, min].max
+        ends = [x + d, max].min
+        begins..ends
+      end
+
+      merge_ranges(ranges)
+    end
+
+    def impossible_spaces(row)
+      blocked = coverage_for(row)
+      beacons = BEACONS.filter_map { |b| b[0] if b[1] == row }.uniq
+
+      ignored = beacons.count { |x| blocked.any? { |r| r.include?(x) } }
+
+      blocked.sum(&:size) - ignored
+    end
+
+    solve!(
+      "The number of beacon-less positions is:",
+      impossible_spaces(ROW)
+    )
+
+    x, y =
+      SEARCH_SPACE.times do |row|
+        ranges = coverage_for(row, min: 0, max: SEARCH_SPACE)
+        break [ranges.first.end + 1, row] if ranges.size > 1
+      end
+
+    solve!(
+      "The tuning frequency of the distress beacon is:",
+      (x * FREQUENCY_KEY) + y
+    )

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

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

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

@@ -0,0 +1,105 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "rb_heap"
+    require "set"
+
+    class Valve
+      MATCHER = /Valve (?<id>[A-Z]+) has flow rate=(?<flow>\d+); tunnels? leads? to valves? (?<connections>[A-Z, ]+)/
+
+      attr_reader :id, :flow, :connections
+
+      def initialize(description)
+        data = MATCHER.match(description)
+        @id = data[:id]
+        @flow = data[:flow].to_i
+        @connections = data[:connections].split(", ")
+      end
+    end
+
+    VALVES = INPUT.split("\n").to_h do |line|
+      valve = Valve.new(line)
+      [valve.id, valve]
+    end
+
+    class Volcano
+      def initialize(valves)
+        @valves = valves
+      end
+
+      def tunnels
+        return @tunnels if @tunnels
+
+        queue = Heap.new { |a, b| a[0] < b[0] }
+        distances = Hash.new { |h, k| h[k] = Hash.new(Float::INFINITY) }
+
+        @valves.each do |id, valve|
+          valve.connections.each do |conn|
+            distances[id][id] = 0
+            distances[id][conn] = 1
+            queue << [1, @valves[conn], [id, conn]]
+          end
+        end
+
+        @valves.each_key do |midpoint|
+          @valves.each_key do |origin|
+            @valves.each_key do |destination|
+              distance = distances[origin][midpoint] + distances[midpoint][destination]
+              distances[origin][destination] = distance if distances[origin][destination] > distance
+            end
+          end
+        end
+
+        @tunnels = distances
+      end
+
+      def best_pressure(time:, workers: 1)
+        queue = Heap.new { |a, b| a[0] > b[0] }
+        states = {}
+
+        team = workers.times.to_h { |i| [i, ["AA", time]] }
+        queue << [0, team, Set.new]
+
+        loop do
+          break if queue.empty?
+
+          pressure, team, opened = queue.pop
+
+          team.each do |id, (room, remaining)|
+            tunnels[room].each do |valve, distance|
+              next if opened.include?(valve)
+              next if @valves[valve].flow == 0
+
+              new_remaining = remaining - distance - 1
+              next if new_remaining <= 0
+
+              new_pressure = pressure + @valves[valve].flow * new_remaining
+              new_opened = opened + [valve]
+              new_team = team.merge(id => [valve, new_remaining])
+
+              rooms = new_team.values.map(&:first).sort
+
+              state = [rooms, new_opened].hash
+              next if states.key?(state) && states[state] >= new_pressure
+
+              states[state] = new_pressure
+              queue << [new_pressure, new_team, new_opened]
+            end
+          end
+        end
+
+        states.values.max
+      end
+    end
+
+    volcano = Volcano.new(VALVES)
+
+    solve!(
+      "The maximum pressure release after 30 minutes is:",
+      volcano.best_pressure(time: 30)
+    )
+    solve!(
+      "The maximum pressure release with a helper elephant is:",
+      volcano.best_pressure(workers: 2, time: 26)
+    )

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

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

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

@@ -0,0 +1,135 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    class Rock
+      attr_reader :height, :width
+
+      def initialize(diagram)
+        diagram = diagram.split("\n").map(&:chars)
+
+        @height = diagram.size
+        @width = diagram[0].size
+        @shape = diagram.flat_map.with_index do |r, y|
+          r.filter_map.with_index { |c, x| Vector[x, -y] if c == "#" }
+        end
+      end
+
+      def coords_at(position)
+        @shape.map { |s| s + position }
+      end
+    end
+
+    class Tower
+      TRACK_LAYERS = 7
+      WIDTH = 7
+
+      attr_reader :height
+
+      def initialize
+        @chamber = WIDTH.times.to_h { |i| [Vector[i, 0], true] }
+        @height = 0
+      end
+
+      def add!(rock, position)
+        @height = [position[1], @height].max
+        rock.coords_at(position).each { |v| @chamber[v] = true }
+      end
+
+      def grow!(growth)
+        @height += growth
+        @chamber = @chamber.transform_keys { |v| v + Vector[0, growth] }
+      end
+
+      def valid?(rock, position)
+        return false if position[0] < 0 || position[0] + rock.width > WIDTH
+
+        rock.coords_at(position).none? { |v| @chamber[v] }
+      end
+
+      def hash
+        WIDTH.times.flat_map do |x|
+          ((@height - TRACK_LAYERS)..@height).map { |y| @chamber[Vector[x, y]] }
+        end.hash
+      end
+    end
+
+    DIAGRAMS = <<~ROCKS
+      ####
+
+      .#.
+      ###
+      .#.
+
+      ..#
+      ..#
+      ###
+
+      #
+      #
+      #
+      #
+
+      ##
+      ##
+    ROCKS
+
+    ROCKS = DIAGRAMS.split("\n\n").map { |diagram| Rock.new(diagram) }
+    JETS = INPUT.chars
+    DOWN = Vector[0, -1]
+    RIGHT = Vector[1, 0]
+    LEFT = Vector[-1, 0]
+
+    def height_after(count)
+      tower = Tower.new
+      states = {}
+      jets = 0
+      rocks = 0
+
+      loop do
+        break tower.height if rocks == count
+
+        rock = ROCKS[rocks % ROCKS.size]
+        position = Vector[2, tower.height + rock.height + 3]
+
+        loop do
+          push = (JETS[jets % JETS.size] == "<") ? LEFT : RIGHT
+          jets += 1
+
+          position += push if tower.valid?(rock, position + push)
+
+          if tower.valid?(rock, position + DOWN)
+            position += DOWN
+          else
+            tower.add!(rock, position)
+            break
+          end
+        end
+
+        state = [rocks % ROCKS.size, jets % JETS.size, tower]
+
+        if states.key?(state)
+          previous_rocks, previous_height = states[state]
+          cycles = (count - rocks) / (rocks - previous_rocks)
+          rocks += (rocks - previous_rocks) * cycles
+
+          tower.grow!((tower.height - previous_height) * cycles)
+        else
+          states[state] = [rocks, tower.height]
+        end
+
+        rocks += 1
+      end
+    end
+
+    solve!(
+      "The height after 2022 rocks is:",
+      height_after(2022)
+    )
+
+    solve!(
+      "The height after 1000000000000 rocks is:",
+      height_after(1000000000000)
+    )

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

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