advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,155 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    MAZE = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), maze|
+      line.chars.each_with_index { |cell, x| maze[[x, y]] = cell }
+    end
+
+    class Donut
+      DIRECTIONS = [[0, -1, 0], [0, 1, 0], [-1, 0, 0], [1, 0, 0]].freeze
+      PATH = ".".freeze
+
+      def initialize(map, recursive: false)
+        @map = map
+        @recursive = recursive
+      end
+
+      def entrance
+        [*portals["AA"][0], 0]
+      end
+
+      def exit
+        [*portals["ZZ"][0], 0]
+      end
+
+      def path?(coords)
+        @map[coords] == PATH
+      end
+
+      def estimator(target)
+        if @recursive
+          proc { |(x, y, z)| (target[0] - x).abs + (target[1] - y).abs + ((target[2] - z).abs**3) }
+        else
+          proc { 0 }
+        end
+      end
+
+      def adjacent_coords((x, y, z))
+        adjacent = DIRECTIONS.map { |i, j, k| [x + i, y + j, z + k] }.select { |i, j, _| path?([i, j]) }
+        return adjacent unless warps.key?([x, y])
+
+        i, j, depth = warps[[x, y]]
+        return adjacent if depth < 0 && z == 0
+
+        adjacent + [[i, j, z + depth]]
+      end
+
+      private
+
+      def warps
+        @warps ||= begin
+          walls = @map.select { |_, c| c == "#" }
+          outerx = walls.map { |coords, _| coords[0] }.minmax
+          outery = walls.map { |coords, _| coords[1] }.minmax
+
+          portals.each_with_object({}) do |(_, portals), warps|
+            next if portals.length < 2
+
+            outer, inner = portals.partition do |portal|
+              outerx.include?(portal[0]) || outery.include?(portal[1])
+            end.map(&:first)
+
+            warps[inner] = [*outer, @recursive ? 1 : 0]
+            warps[outer] = [*inner, @recursive ? -1 : 0]
+          end
+        end
+      end
+
+      def portals
+        @portals ||= @map.each_with_object(Hash.new { |h, k| h[k] = [] }) do |((x, y), cell), portals|
+          next unless /[[:alpha:]]/.match?(cell)
+
+          if @map[[x + 1, y]] == PATH
+            portals[@map[[x - 1, y]] + cell] << [x + 1, y]
+          elsif @map[[x - 1, y]] == PATH
+            portals[cell + @map[[x + 1, y]]] << [x - 1, y]
+          elsif @map[[x, y - 1]] == PATH
+            portals[cell + @map[[x, y + 1]]] << [x, y - 1]
+          elsif @map[[x, y + 1]] == PATH
+            portals[@map[[x, y - 1]] + cell] << [x, y + 1]
+          end
+        end
+      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)
+        traverse(start, estimator: @map.estimator(target)) do |spot, path|
+          return path if spot == target
+        end
+      end
+
+      private
+
+      def traverse(start, estimator:)
+        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
+
+    donut = Donut.new(MAZE)
+    pathfinder = Pathfinder.new(donut)
+    path = pathfinder.path(donut.entrance, donut.exit)
+
+    solve!("The minimum path length between portals AA and ZZ is:", path.length)
+
+    donut = Donut.new(MAZE, recursive: true)
+    pathfinder = Pathfinder.new(donut)
+    path = pathfinder.path(donut.entrance, donut.exit)
+
+    solve!("The minimum recursive path length between portals AA and ZZ is:", path.length)

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

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

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

@@ -0,0 +1,46 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    class SpringDroid
+      def initialize(program)
+        @program = program
+      end
+
+      def run(script)
+        instructions = script.flat_map { |line| line.chars.map(&:ord) + [10] }
+        @program.run(inputs: instructions).last
+      end
+    end
+
+    program = Computer.new(INTCODE)
+    droid = SpringDroid.new(program)
+    hull_damage = droid.run(
+      [
+        "NOT C J",
+        "AND D J",
+        "NOT A T",
+        "OR T J",
+        "WALK"
+      ]
+    )
+
+    solve!("The amount of hull damage after walking is:", hull_damage)
+
+    program = Computer.new(INTCODE)
+    droid = SpringDroid.new(program)
+    hull_damage = droid.run(
+      [
+        "NOT H J",
+        "OR C J",
+        "AND B J",
+        "AND A J",
+        "NOT J J",
+        "AND D J",
+        "RUN"
+      ]
+    )
+
+    solve!("The amount of hull damage after running is:", hull_damage)

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

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

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

@@ -0,0 +1,117 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    OPERATION_MATCHERS = {
+      cut: /\Acut (?<count>.+)\z/,
+      deal: /\Adeal with increment (?<count>.+)\z/,
+      flip: /\Adeal into new stack\z/
+    }.freeze
+
+    OPERATIONS = INPUT.split("\n").map do |operation|
+      case operation
+      when OPERATION_MATCHERS[:cut] then [:cut, $~[:count].to_i]
+      when OPERATION_MATCHERS[:deal] then [:deal, $~[:count].to_i]
+      when OPERATION_MATCHERS[:flip] then [:flip]
+      end
+    end
+
+    class Deck
+      def initialize(size, shuffler)
+        @size = size
+        @shuffler = simplify(shuffler)
+      end
+
+      def shuffle
+        cards = (0...@size).to_a
+
+        @shuffler.each do |operation, argument|
+          cards =
+            case operation
+            when :cut then cards.rotate(argument)
+            when :deal then cards.each_index.map { |i| cards[(i * modular_inverse(argument)) % @size] }
+            when :flip then cards.reverse
+            end
+        end
+
+        cards
+      end
+
+      def card_at(position, shuffles: 1)
+        phases = {}
+        power = 1
+        operations = @shuffler
+
+        until power > shuffles
+          phases[power] = simplify(operations)
+          power <<= 1
+          operations = simplify(operations + operations)
+        end
+
+        operations = phases.flat_map { |power, ops| (shuffles & power == 0) ? [] : ops }
+        simplify(operations).reverse_each do |operation, argument|
+          position =
+            case operation
+            when :cut then (position + argument) % @size
+            when :deal then (position * modular_inverse(argument)) % @size
+            when :flip then @size - 1 - position
+            end
+        end
+
+        position
+      end
+
+      private
+
+      def simplify(operations)
+        steps = operations.dup
+
+        loop do
+          steps.each_index do |i|
+            next unless steps[i] && steps[i + 1]
+
+            first_op, first_arg = steps[i]
+            second_op, second_arg = steps[i + 1]
+
+            steps[i, 2] =
+              case [first_op, second_op]
+              when %i[cut cut] then [[:cut, (first_arg + second_arg) % @size]]
+              when %i[cut deal] then [[:deal, second_arg], [:cut, (first_arg * second_arg) % @size]]
+              when %i[deal deal] then [[:deal, (first_arg * second_arg) % @size]]
+              when %i[flip cut] then [[:cut, -second_arg], [:flip]]
+              when %i[flip deal] then [[:deal, second_arg], [:cut, -second_arg + 1], [:flip]]
+              when %i[flip flip] then []
+              else steps[i, 2]
+              end
+          end
+
+          step_names = steps.map(&:first)
+          break steps if step_names.uniq == step_names
+        end
+      end
+
+      # Apologies to: https://rosettacode.org/wiki/Modular_inverse#Ruby
+      def modular_inverse(value)
+        n = @size
+        inverse = 1
+        x = 0
+
+        while value > 1
+          inverse -= (value / n) * x
+          value, n = n, value % n
+          inverse, x = x, inverse
+        end
+
+        inverse % @size
+      end
+    end
+
+    deck = Deck.new(10_007, OPERATIONS)
+    cards = deck.shuffle
+
+    solve!("The position of card 2019 after shuffling is:", cards.index(2019))
+
+    deck = Deck.new(119_315_717_514_047, OPERATIONS)
+    card = deck.card_at(2020, shuffles: 101_741_582_076_661)
+
+    solve!("The card at position 2020 after shuffling is:", card)

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

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

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

@@ -0,0 +1,30 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    NETWORK = 50.times.map { |id| Computer.new(INTCODE).tap { |c| c.run(inputs: [id]) } }.freeze
+    NAT_ADDRESS = 255
+
+    queues = Hash.new { |h, k| h[k] = [] }
+    nat = []
+    last_y = nil
+
+    loop do
+      NETWORK.each_with_index do |computer, id|
+        outputs = computer.run(inputs: queues[id].shift || [-1])
+        outputs.each_slice(3) do |address, x, y|
+          (address == NAT_ADDRESS) ? nat << [x, y] : queues[address] << [x, y]
+        end
+      end
+
+      next unless queues.values.all?(&:empty?)
+      break if nat.last[1] == last_y
+
+      last_y = nat.last[1]
+      queues[0] << nat.last.dup
+    end
+
+    solve!("The first Y value passed to the NAT is:", nat.first[1])
+    solve!("The first Y value delivered by the NAT twice in a row is:", last_y)

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

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

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

@@ -0,0 +1,81 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    SIZE = 5
+    ADJACENCIES = [[0, -1, 0], [1, 0, 0], [0, 1, 0], [-1, 0, 0]].freeze
+    GRID = INPUT.split("\n").each_with_index.each_with_object(Hash.new(".")) do |(line, y), grid|
+      line.chars.each_with_index { |tile, x| grid[[x, y, 0]] = tile }
+    end
+
+    def tick(grid, neighbors)
+      positions = grid.flat_map { |position, tile| (tile == "#") ? [position] + neighbors.call(position) : [] }.uniq
+      positions.each_with_object(Hash.new(".")) do |position, updated|
+        bugs = neighbors.call(position).count { |neighbor| grid[neighbor] == "#" }
+        updated[position] =
+          case grid[position]
+          when "#" then (bugs == 1) ? "#" : "."
+          when "." then [1, 2].include?(bugs) ? "#" : "."
+          end
+      end
+    end
+
+    def biodiversity(grid)
+      (0...SIZE).sum do |y|
+        (0...SIZE).sum do |x|
+          (grid[[x, y, 0]] == "#") ? 2**((y * SIZE) + x) : 0
+        end
+      end
+    end
+
+    def neighbors(coord)
+      x, y, z = coord
+      ADJACENCIES.map { |i, j, k| [x + i, y + j, z + k] }
+    end
+
+    grid = GRID.dup
+    seen = {}
+    neighbors = proc do |(x, y, z)|
+      ADJACENCIES.map do |i, j, k|
+        next if x + i < 0 || y + j < 0 || x + i >= SIZE || y + j >= SIZE
+
+        [x + i, y + j, z + k]
+      end.compact
+    end
+
+    repeated = loop do
+      grid = tick(grid, neighbors)
+      value = biodiversity(grid)
+
+      break value if seen[value]
+
+      seen[value] = true
+    end
+
+    solve!("The biodiversity of the first layout that appears twice is:", repeated)
+
+    RECURSIVE_ADJACENCIES = {
+      [0, -1, 0] => ->(x) { [x, SIZE - 1] },
+      [1, 0, 0] => ->(y) { [0, y] },
+      [0, 1, 0] => ->(x) { [x, 0] },
+      [-1, 0, 0] => ->(y) { [SIZE - 1, y] }
+    }.freeze
+
+    recursive_neighbors = proc do |(x, y, z)|
+      ADJACENCIES.flat_map do |i, j, k|
+        if x + i == SIZE / 2 && y + j == SIZE / 2
+          SIZE.times.map(&RECURSIVE_ADJACENCIES[[i, j, k]]).map { |m, n| [m, n, z + 1] }
+        elsif x + i < 0 || y + j < 0 || x + i >= SIZE || y + j >= SIZE
+          [[(SIZE / 2) + i, (SIZE / 2) + j, z - 1]]
+        else
+          [[x + i, y + j, z + k]]
+        end
+      end
+    end
+
+    grid = GRID.dup
+
+    MINUTES ||= 200
+    MINUTES.times { grid = tick(grid, recursive_neighbors) }
+
+    solve!("The number of bugs after 200 minutes is:", grid.values.count("#"))

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

@@ -0,0 +1,104 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    class Room
+      NAME_MATCHER = /^== (?<name>.+) ==$/
+      DIRECTIONS = %w[north east south west].freeze
+      TRAPS = ["escape pod", "giant electromagnet", "infinite loop", "molten lava", "photons"].freeze
+      CHECKPOINT = "Security Checkpoint".freeze
+
+      def initialize(description)
+        @description = description
+      end
+
+      def name
+        @description.match(NAME_MATCHER)[:name]
+      end
+
+      def doors
+        @description.scan(/^- (#{Regexp.union(DIRECTIONS)})$/).flatten
+      end
+
+      def items
+        @description.scan(/^- (.+)$/).flatten.reject do |item|
+          DIRECTIONS.include?(item) || TRAPS.include?(item)
+        end
+      end
+    end
+
+    class Droid
+      # rubocop:disable Layout/LineLength
+      PASSWORD_MATCHER = /You should be able to get in by typing (?<password>\d+) on the keypad at the main airlock\./
+      # rubocop:enable Layout/LineLength
+      OVERWEIGHT_MATCHER = /lighter/
+
+      def initialize(intcode)
+        @computer = Computer.new(intcode)
+      end
+
+      def password
+        checkpoint, inventory = explore!
+
+        checkpoint.each { |direction| run!(direction) }
+        inventory.each { |item| run!("drop #{item}") }
+
+        inventory = inventory.reject { |item| test_combination([item], checkpoint.last).match?(OVERWEIGHT_MATCHER) }
+
+        (2..inventory.size).each do |size|
+          inventory.combination(size).each do |items|
+            description = test_combination(items, checkpoint.last)
+            return description.match(PASSWORD_MATCHER)[:password] if description.match?(PASSWORD_MATCHER)
+          end
+        end
+      end
+
+      private
+
+      def explore!
+        queue = Hash.new { |h, k| h[k] = [] }
+        path = []
+        inventory = []
+        checkpoint = nil
+
+        room = Room.new(run!)
+        queue[room.name] = room.doors
+
+        loop do
+          break if queue.values.all?(&:empty?) && path.empty?
+          (room = Room.new(run!(reverse(path.pop)))) && next if queue[room.name].empty?
+
+          direction = queue[room.name].shift
+          room = Room.new(run!(direction))
+          path.push(direction)
+
+          inventory += room.items.each { |item| run!("take #{item}") }
+          (checkpoint = path.dup) && next if room.name == Room::CHECKPOINT
+
+          queue[room.name] = room.doors - [reverse(direction)]
+        end
+
+        [checkpoint, inventory]
+      end
+
+      def run!(command = "")
+        @computer.run(inputs: "#{command}\n".chars.map(&:ord) + [10]).map(&:chr).join
+      end
+
+      def reverse(direction)
+        Room::DIRECTIONS[(Room::DIRECTIONS.index(direction) + 2) % Room::DIRECTIONS.count]
+      end
+
+      def test_combination(items, direction)
+        items.each { |item| run!("take #{item}") }
+        description = run!(direction)
+        items.each { |item| run!("drop #{item}") }
+
+        description
+      end
+    end
+
+    droid = Droid.new(INTCODE)
+    solve!("The password for the main airlock is:", droid.password)

data/data/solutions/github/ahorner/2020/01_1.yml

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

data/data/solutions/github/ahorner/2020/01_2.yml

@@ -0,0 +1,14 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    NUMBERS = INPUT.split("\n").map(&:to_i)
+    TARGET = 2020
+
+    def entry_product(count)
+      entries = NUMBERS.combination(count).detect { |combo| combo.sum == TARGET }
+      entries.inject(:*)
+    end
+
+    solve!("The product of the two entries is:", entry_product(2))
+    solve!("The product of the three entries is:", entry_product(3))

data/data/solutions/github/ahorner/2020/02_1.yml

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

data/data/solutions/github/ahorner/2020/02_2.yml

@@ -0,0 +1,21 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    POLICY_MATCHER = /(?<minimum>\d+)-(?<maximum>\d+) (?<char>\w): (?<password>\w+)/
+    LINES = INPUT.split("\n").map { |line| line.match(POLICY_MATCHER) }
+
+    def valid_by_count?(line)
+      count = line[:password].count(line[:char])
+      count >= line[:minimum].to_i && count <= line[:maximum].to_i
+    end
+
+    def valid_by_position?(line)
+      (line[:password][line[:minimum].to_i - 1] == line[:char]) ^
+        (line[:password][line[:maximum].to_i - 1] == line[:char])
+    end
+
+    solve!("The number of valid passwords is:",
+      LINES.count { |line| valid_by_count?(line) })
+    solve!("The number of valid passwords with the new interpretation is:",
+      LINES.count { |line| valid_by_position?(line) })

data/data/solutions/github/ahorner/2020/03_1.yml

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

data/data/solutions/github/ahorner/2020/03_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    PATTERN = INPUT.split("\n").map(&:chars)
+    SLOPES = [
+      [1, 1],
+      [3, 1],
+      [5, 1],
+      [7, 1],
+      [1, 2]
+    ].freeze
+
+    class Map
+      TREE = "#".freeze
+
+      def initialize(pattern)
+        @pattern = pattern
+        @width = pattern.first.size
+      end
+
+      def [](x, y)
+        @pattern[y]&.[](x % @width)
+      end
+
+      def collisions(dx, dy)
+        x = 0
+        y = 0
+        count = 0
+
+        loop do
+          x += dx
+          y += dy
+
+          case self[x, y]
+          when TREE then count += 1
+          when nil then break
+          end
+        end
+
+        count
+      end
+    end
+
+    map = Map.new(PATTERN)
+
+    solve!("The number of trees hit is:", map.collisions(3, 1))
+    solve!("The product of trees hit on all test slopes is:",
+      SLOPES.map { |(dx, dy)| map.collisions(dx, dy) }.inject(:*))

data/data/solutions/github/ahorner/2020/04_1.yml

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