advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ahorner/2018/06_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    class Coordinate
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
+
+      def distance_to(i, j)
+        (x - i).abs + (y - j).abs
+      end
+    end
+
+    coordinates = INPUT.split("\n").map { |line| Coordinate.new(*line.split(", ").map(&:to_i)) }
+    westmost, eastmost = coordinates.minmax_by(&:x)
+    northmost, southmost = coordinates.minmax_by(&:y)
+
+    paranoid_grid = {}
+    friendly_grid = {}
+
+    MAX_DISTANCE ||= 10_000
+
+    (westmost.x..eastmost.x).each do |x|
+      (northmost.y..southmost.y).each do |y|
+        distances = coordinates.map { |c| c.distance_to(x, y) }
+        friendly_grid[[x, y]] = distances.sum < MAX_DISTANCE
+
+        minimum = distances.min
+        next if distances.count(minimum) > 1
+
+        closest = coordinates.detect.with_index { |_, i| distances[i] == minimum }
+        paranoid_grid[[x, y]] = closest
+      end
+    end
+
+    finite_coordinates = coordinates.reject do |c|
+      (westmost.x..eastmost.x).any? { |x| paranoid_grid[[x, southmost.y]] == c || paranoid_grid[[x, northmost.y]] == c } ||
+        (northmost.y..southmost.y).any? { |y| paranoid_grid[[westmost.x, y]] == c || paranoid_grid[[eastmost.x, y]] == c }
+    end
+
+    counts = finite_coordinates.map { |c| paranoid_grid.values.count(c) }
+    solve!("The largest non-infinite area is:", counts.max)
+
+    friendly_region = friendly_grid.values.count(true)
+    solve!("The region of friendly locations has a size of:", friendly_region)

data/data/solutions/github/ahorner/2018/07_1.yml

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

data/data/solutions/github/ahorner/2018/07_2.yml

@@ -0,0 +1,46 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /\AStep (\w+) must be finished before step (\w+) can begin\.\z/
+    RULES = INPUT.split("\n").map do |line|
+      match = line.match(MATCHER)
+      [match[1], match[2]]
+    end
+    TASKS = RULES.flatten.uniq.sort
+
+    TIME_OFFSET ||= 4
+    WORKER_COUNT ||= 5
+
+    def job_for(tasks, rules, starts)
+      task = tasks.detect { |task| rules.none? { |_, s| s == task } }
+      [task, task.ord - TIME_OFFSET + starts] if task
+    end
+
+    def work(tasks, rules, worker_count = 1)
+      workers = [nil] * worker_count
+      sequence = ""
+
+      0.step do |time|
+        workers.each_with_index do |(task, ends), i|
+          next unless ends&.<=(time)
+
+          workers[i] = nil
+          sequence << task
+          rules = rules.reject { |t, _| t == task }
+        end
+
+        workers.each_index do |i|
+          next if workers[i]
+
+          job = job_for(tasks, rules, time)
+          workers[i] = job
+          tasks -= [job&.first]
+        end
+
+        break {sequence: sequence, time: time} if workers.all?(&:nil?)
+      end
+    end
+
+    solve!("The necessary sequence of tasks is:", work(TASKS, RULES)[:sequence])
+    solve!("The time to complete with helpers is:", work(TASKS, RULES, WORKER_COUNT)[:time])

data/data/solutions/github/ahorner/2018/08_1.yml

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

data/data/solutions/github/ahorner/2018/08_2.yml

@@ -0,0 +1,34 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    class Node
+      def initialize(children, metadata)
+        @children = children
+        @metadata = metadata
+      end
+
+      def sum
+        @children.sum(&:sum) + @metadata.sum
+      end
+
+      def value
+        return @metadata.sum if @children.none?
+
+        @metadata.sum { |i| @children[i - 1]&.value.to_i }
+      end
+    end
+
+    def node_for(definition)
+      child_count, metadata_count = definition.shift(2)
+
+      children = child_count.times.map { node_for(definition) }
+      metadata = definition.shift(metadata_count)
+
+      Node.new(children, metadata)
+    end
+
+    root = node_for(INPUT.split.map(&:to_i))
+
+    solve!("The sum of all node metadata is:", root.sum)
+    solve!("The value of the root node is:", root.value)

data/data/solutions/github/ahorner/2018/09_1.yml

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

data/data/solutions/github/ahorner/2018/09_2.yml

@@ -0,0 +1,72 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /(?<players>\d+) players; last marble is worth (?<points>\d+) points/
+
+    class Marble
+      attr_accessor :next, :prev
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        @next = self
+        @prev = self
+      end
+
+      def add(marble)
+        marble.prev = @next
+        marble.next = @next.next
+        @next.next.prev = marble
+        @next.next = marble
+
+        marble
+      end
+
+      def target
+        @prev.prev.prev.prev.prev.prev.prev
+      end
+
+      def remove
+        @next.prev = @prev
+        @prev.next = @next
+
+        @next
+      end
+
+      def special?
+        value % 23 == 0
+      end
+    end
+
+    def play(players, points)
+      current_marble = Marble.new(0)
+      scores = [0] * players
+
+      current_player = 0
+
+      (1..points).each do |value|
+        marble = Marble.new(value)
+
+        if marble.special?
+          taken = current_marble.target
+          current_marble = taken.remove
+
+          scores[current_player] += marble.value + taken.value
+        else
+          current_marble = current_marble.add(marble)
+        end
+
+        current_player += 1
+        current_player %= players
+      end
+
+      scores
+    end
+
+    data = INPUT.match(MATCHER)
+    results = play(data[:players].to_i, data[:points].to_i)
+    solve!("The winning elf's score is: ", results.max)
+
+    results = play(data[:players].to_i, data[:points].to_i * 100)
+    solve!("The winning elf's score in the longer round is:", results.max)

data/data/solutions/github/ahorner/2018/10_1.yml

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

data/data/solutions/github/ahorner/2018/10_2.yml

@@ -0,0 +1,71 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /position=<(?<x>\s*-?\d+),(?<y>\s*-?\d+)> velocity=<(?<dx>\s*-?\d+),(?<dy>\s*-?\d+)>/
+
+    class Photon
+      attr_reader :x, :y
+
+      def initialize(x, y, dx, dy)
+        @x = x
+        @y = y
+        @dx = dx
+        @dy = dy
+      end
+
+      def position
+        [@x, @y]
+      end
+
+      def tick!
+        @x += @dx
+        @y += @dy
+      end
+
+      def untick!
+        @x -= @dx
+        @y -= @dy
+      end
+    end
+
+    def area(photons)
+      minx, maxx = photons.map(&:x).minmax
+      miny, maxy = photons.map(&:y).minmax
+
+      (maxx - minx) * (maxy - miny)
+    end
+
+    def render(photons)
+      map = Hash.new(".")
+      photons.each { |p| map[p.position] = "#" }
+
+      minx, maxx = photons.map(&:x).minmax
+      miny, maxy = photons.map(&:y).minmax
+
+      (miny..maxy).each_with_object("") do |y, output|
+        (minx..maxx).each { |x| output << map[[x, y]] }
+        output << "\n"
+      end
+    end
+
+    photons = INPUT.split("\n").map do |line|
+      data = line.match(MATCHER)
+      Photon.new(data[:x].to_i, data[:y].to_i, data[:dx].to_i, data[:dy].to_i)
+    end
+
+    best = area(photons)
+    time = 0
+
+    loop do
+      photons.each(&:tick!)
+
+      score = area(photons)
+      break photons.each(&:untick!) if score > best
+
+      time += 1
+      best = score
+    end
+
+    solve!("The message that appears is:\n\n", render(photons))
+    solve!("The time the message appears is:", time)

data/data/solutions/github/ahorner/2018/11_1.yml

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

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

@@ -0,0 +1,63 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    SERIAL = INPUT.to_i
+    SIZE = 300
+
+    def power(x, y)
+      rack_id = x + 10
+
+      power = rack_id * y
+      power += SERIAL
+      power *= rack_id
+
+      ((power / 100) % 10) - 5
+    end
+
+    # Compose a grid containing the _sums_ of all powers from the top-left to the
+    # specified cell. This allows us to find the value of any arbitrary rectangular
+    # section using just four points of data. For example, if all cells had a power
+    # of 1, the sums would look like:
+    #
+    #   A |  B    B |  *      1 |  1    1 |  1      1 |  2    3 |  4
+    # ---------------       ---------------       ---------------
+    #   C |  D    D |  *      1 |  1    1 |  1      2 |  4    6 |  8
+    #     |         |    ==     |         |    =>     |         |
+    #   C |  D    D |  *      1 |  1    1 |  1      3 |  6    9 | 12
+    # ---------------       ---------------       ---------------
+    #   *    *    *    *      1    1    1    1      4    8   12   16
+    #
+    # You could then calculate the sum of _just_ region D (the central box in the
+    # diagrams above) by grabbing the bottom-right sums of sections A, B, C, and D
+    # for a calculation of 9 - 3 - 3 + 1 = 4. This doesn't improve the efficiency of
+    # calculating small region sums by much, but greatly reduces the calculations
+    # required to sum large regions.
+    GRID = (0..SIZE).each_with_object(Array.new(SIZE + 1) { Array.new(SIZE + 1) }) do |x, grid|
+      (0..SIZE).each do |y|
+        grid[y][x] =
+          if x < 1 || y < 1
+            0
+          else
+            power(x, y) + grid[y - 1][x] + grid[y][x - 1] - grid[y - 1][x - 1]
+          end
+      end
+    end.freeze
+
+    def best_for(grid, size = 3)
+      best = [0, 0, 0, size]
+
+      (0..(SIZE - size)).each do |x|
+        (0..(SIZE - size)).each do |y|
+          total = grid[y + size][x + size] - grid[y + size][x] - grid[y][x + size] + grid[y][x]
+          best = [total, x + 1, y + 1, size] if total > best[0]
+        end
+      end
+
+      best
+    end
+
+    solve!("The top-left corner of the best 3x3 block is:", best_for(GRID)[1..2].join(","))
+
+    best = (3..SIZE).map { |size| best_for(GRID, size) }.max
+    solve!("The best block of any size is:", best[1..3].join(","))

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

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

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

@@ -0,0 +1,49 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    INITIAL_MATCHER = /initial state: (?<state>.+)/
+    CONVERSION_MATCHER = /(?<pattern>.+) => (?<result>.)/
+
+    RULES = Hash.new(".")
+
+    INPUT.split("\n").each do |line|
+      case line
+      when INITIAL_MATCHER then INITIAL = $~[:state]
+      when CONVERSION_MATCHER then RULES[$~[:pattern]] = $~[:result]
+      end
+    end
+
+    def result(state, offset)
+      final = ""
+      ".....#{state}.....".chars.each_cons(5) { |pot| final << RULES[pot.join] }
+      [final, offset + 3]
+    end
+
+    def score(state, offset)
+      state.chars.map.with_index { |c, i| (c == "#") ? i - offset : 0 }.sum
+    end
+
+    def evolve(state, generations)
+      offset = 0
+      current_score = score(state, offset)
+      score_deltas = []
+
+      generations.times do |gen|
+        state, offset = result(state, offset)
+        new_score = score(state, offset)
+        score_deltas << (new_score - current_score)
+
+        if score_deltas.size >= 3 && score_deltas.last(3).uniq.size == 1
+          current_score += score_deltas.last * (generations - gen)
+          break
+        end
+
+        current_score = new_score
+      end
+
+      current_score
+    end
+
+    solve!("The score after 20 generations is:", evolve(INITIAL, 20))
+    solve!("The score after 50B generations is:", evolve(INITIAL, 50_000_000_000))

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

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

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

@@ -0,0 +1,75 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    class Cart
+      CHOICES = %i[left straight right].freeze
+
+      attr_reader :x, :y
+
+      def initialize(x, y, dx, dy)
+        @x = x
+        @y = y
+        @dx = dx
+        @dy = dy
+        @choices = 0
+      end
+
+      def tick!(grid)
+        @x += @dx
+        @y += @dy
+
+        case grid[@y][@x]
+        when "/" then @dx, @dy = -@dy, -@dx
+        when "\\" then @dx, @dy = @dy, @dx
+        when "+"
+          case CHOICES[@choices % CHOICES.size]
+          when :left then @dx, @dy = @dy, -@dx
+          when :right then @dx, @dy = -@dy, @dx
+          end
+
+          @choices += 1
+        end
+      end
+    end
+
+    ROWS = INPUT.split("\n")
+
+    grid = Array.new(ROWS.size) { Array.new(ROWS.max_by(&:size).size) { " " } }
+    carts = []
+
+    ROWS.each_with_index do |row, y|
+      row.chars.each_with_index do |c, x|
+        grid[y][x], cart =
+          case c
+          when "<" then ["-", Cart.new(x, y, -1, 0)]
+          when ">" then ["-", Cart.new(x, y, 1, 0)]
+          when "^" then ["|", Cart.new(x, y, 0, -1)]
+          when "v" then ["|", Cart.new(x, y, 0, 1)]
+          else [c, nil]
+          end
+        carts << cart if cart
+      end
+    end
+
+    first_crash = nil
+
+    loop do
+      carts.dup.each do |cart|
+        cart.tick!(grid)
+
+        crash = (carts - [cart]).detect { |c| cart.x == c.x && cart.y == c.y }
+        next unless crash
+
+        first_crash ||= cart
+        carts.delete(cart)
+        carts.delete(crash)
+      end
+
+      break if carts.size <= 1
+
+      carts.sort_by! { |cart| [cart.y, cart.x] }
+    end
+
+    solve!("The first collision happens at:", [first_crash.x, first_crash.y].join(","))
+    solve!("The last remaining cart is at:", [carts.last.x, carts.last.y].join(","))

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

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

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

@@ -0,0 +1,50 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    STARTING_RECIPES = [3, 7].freeze
+    COUNT = INPUT.to_i
+
+    class Search
+      attr_reader :previous
+
+      def initialize(term)
+        @term = term
+        @current = []
+        @previous = 0
+      end
+
+      def add(recipes)
+        recipes.each do |r|
+          break if found?
+
+          @current.shift && @previous += 1 if @current.size == @term.size
+          @current << r
+        end
+      end
+
+      def found?
+        @term == @current
+      end
+    end
+
+    recipes = STARTING_RECIPES.dup
+    elves = [0, 1]
+
+    search = Search.new(INPUT.chars.map(&:to_i))
+    search.add(recipes)
+
+    loop do
+      scores = elves.map { |elf| recipes[elf].to_i }
+      new_recipes = scores.sum.digits.reverse
+
+      recipes.concat(new_recipes)
+      search.add(new_recipes)
+
+      break if search.found? && recipes.size >= COUNT + 10
+
+      elves.each_index { |i| elves[i] = (elves[i] + scores[i] + 1) % recipes.size }
+    end
+
+    solve!("The score of the recipes after practice is:", recipes.slice(COUNT, 10).join)
+    solve!("The number of recipes preceding the sequence is:", search.previous)

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

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

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

@@ -0,0 +1,131 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    class Unit
+      TEAMS = {elf: "E", goblin: "G"}.freeze
+
+      attr_reader :team, :attack
+      attr_accessor :hp, :position
+
+      def initialize(team, position)
+        @team = team
+        @position = position
+        @hp = 200
+        @attack = 3
+      end
+
+      def dead?
+        @hp <= 0
+      end
+    end
+
+    class Map
+      def initialize(map)
+        @map = map
+      end
+
+      def move(unit, destination)
+        @map[unit.position] = false
+        unit.position = destination
+        @map[unit.position] = unit
+      end
+
+      def search(start, targets)
+        queue = [[start, 0]]
+        graph = {start => nil}
+        destinations = []
+
+        loop do
+          break if queue.empty?
+
+          spot, steps = queue.shift
+
+          if targets.include?(spot)
+            queue.reject! { |_, s| s > steps }
+            destinations << spot
+          end
+
+          next unless destinations.empty?
+
+          neighbors(spot).each do |neighbor|
+            next if graph.key?(neighbor)
+            next if @map[neighbor]
+
+            graph[neighbor] = spot
+            queue << [neighbor, steps + 1]
+          end
+        end
+
+        return nil unless destinations.any?
+
+        destination = destinations.min
+        destination = graph[destination] while graph[destination] != start
+        destination
+      end
+
+      def neighbors((y, x))
+        [[y - 1, x], [y, x - 1], [y, x + 1], [y + 1, x]]
+      end
+    end
+
+    def combat!(grid, bonuses = {})
+      units = grid.values.select { |u| u.is_a?(Unit) }.compact.map(&:dup)
+
+      map = Map.new(grid)
+      deaths = Hash.new(0)
+      rounds = 0
+
+      loop do
+        round = units.sort_by(&:position).each do |unit|
+          break false if units.uniq(&:team).size == 1
+          next if unit.dead?
+
+          enemies = units.reject { |u| u.team == unit.team }
+          targets = enemies.flat_map { |enemy| map.neighbors(enemy.position) }
+
+          unless targets.include?(unit.position)
+            destination = map.search(unit.position, targets)
+            map.move(unit, destination) if destination
+          end
+
+          nearby = enemies.select { |enemy| map.neighbors(enemy.position).include?(unit.position) }
+          target = nearby.min_by { |enemy| [enemy.hp, enemy.position] }
+          next unless target
+
+          target.hp -= unit.attack + bonuses[unit.team].to_i
+          next unless target.dead?
+
+          deaths[target.team] += 1
+          grid[target.position] = false
+          units.delete(target)
+        end
+
+        break unless round
+
+        rounds += 1
+      end
+
+      [rounds * units.sum(&:hp), deaths]
+    end
+
+    GRID = INPUT.split("\n").each_with_object({}).with_index do |(row, g), y|
+      row.chars.each_with_index do |c, x|
+        g[[y, x]] =
+          case c
+          when *Unit::TEAMS.values then Unit.new(c, [y, x])
+          when "." then false
+          else true
+          end
+      end
+    end
+
+    outcome, = combat!(GRID.dup)
+    solve!("Outcome after standard combat:", outcome)
+
+    outcome = 1.step do |elf_bonus|
+      score, deaths = combat!(GRID.dup, {Unit::TEAMS[:elf] => elf_bonus})
+      break score unless deaths[Unit::TEAMS[:elf]] > 0
+    end
+
+    solve!("Outcome after a decisive elf win:", outcome)

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

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