advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,91 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    class Flight
+      attr_reader :reindeer, :distance, :points
+
+      def initialize(reindeer, speed, duration, recovery)
+        @reindeer = reindeer
+        @speed = speed
+        @duration = duration
+        @recovery = recovery
+      end
+
+      def ready_steady!
+        @distance = 0
+        @elapsed = 0
+        @points = 0
+      end
+
+      def go!
+        @distance += @speed if flying?
+        @elapsed += 1
+      end
+
+      def good_job!
+        @points += 1
+      end
+
+      private
+
+      def flying?
+        (@elapsed % (@duration + @recovery)) < @duration
+      end
+    end
+
+    class Race
+      # rubocop:disable Layout/LineLength
+      FLIGHT_PATTERN = %r{(?<reindeer>.+) can fly (?<speed>\d+) km/s for (?<duration>\d+) seconds, but then must rest for (?<recovery>\d+) seconds\.}
+      # rubocop:enable Layout/LineLength
+
+      def initialize
+        @flights = []
+      end
+
+      def enter(contestants)
+        contestants.each do |contestant|
+          matches = FLIGHT_PATTERN.match(contestant)
+
+          @flights << Flight.new(
+            matches[:reindeer],
+            matches[:speed].to_i,
+            matches[:duration].to_i,
+            matches[:recovery].to_i
+          )
+        end
+      end
+
+      def run_for_distance(time)
+        run(time)
+        @flights.max_by(&:distance)
+      end
+
+      def run_for_points(time)
+        run(time)
+        @flights.max_by(&:points)
+      end
+
+      private
+
+      def run(time)
+        @flights.each(&:ready_steady!)
+
+        (1..time).each do |_t|
+          @flights.each(&:go!)
+
+          maximum = @flights.max_by(&:distance).distance
+          @flights.select { |f| f.distance == maximum }.each(&:good_job!)
+        end
+      end
+    end
+
+    race = Race.new
+    race.enter(INPUT.split("\n"))
+
+    TIME ||= 2503
+    winner = race.run_for_distance(TIME)
+    solve!("The winner by distance is:", winner.reindeer, winner.distance)
+
+    winner = race.run_for_points(TIME)
+    solve!("The winner by points is:", winner.reindeer, winner.points)

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

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

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

@@ -0,0 +1,76 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    class Cookie
+      def initialize
+        @qualities = Hash.new(0)
+      end
+
+      def add(ingredient)
+        ingredient.each do |quality, value|
+          @qualities[quality] += value
+        end
+      end
+
+      def score(target_calories = nil)
+        return 0 unless target_calories.nil? || target_calories == score_for(:calories)
+
+        [
+          score_for(:capacity),
+          score_for(:durability),
+          score_for(:flavor),
+          score_for(:texture)
+        ].inject(:*)
+      end
+
+      private
+
+      def score_for(quality)
+        [@qualities[quality], 0].max
+      end
+    end
+
+    class Kitchen
+      INGREDIENT_PATTERN = /^(?<name>.+): (?<attributes>.+)$/
+      ATTRIBUTE_MATCHER = /\b(?<name>\w+) (?<value>-?\d+)\b/
+
+      def initialize
+        @ingredients = {}
+      end
+
+      def stock(ingredients)
+        ingredients.each do |ingredient|
+          ingredient = INGREDIENT_PATTERN.match(ingredient)
+          attributes = ingredient[:attributes].split(", ").map do |attribute|
+            attribute = attribute.match(ATTRIBUTE_MATCHER)
+            [attribute[:name].to_sym, attribute[:value].to_i]
+          end
+
+          @ingredients[ingredient[:name]] = attributes.to_h
+        end
+      end
+
+      def best_cookie(teaspoons, calories = nil)
+        cookies = recipes(teaspoons).map { |ingredients| cookie(ingredients) }
+        cookies.max_by { |cookie| cookie.score(calories) }
+      end
+
+      private
+
+      def cookie(ingredients)
+        Cookie.new.tap do |cookie|
+          ingredients.each { |ingredient| cookie.add(@ingredients[ingredient]) }
+        end
+      end
+
+      def recipes(teaspoons)
+        @ingredients.keys.repeated_combination(teaspoons).to_a
+      end
+    end
+
+    kitchen = Kitchen.new
+    kitchen.stock(INPUT.split("\n"))
+
+    solve!("Best cookie:", kitchen.best_cookie(100).score)
+    solve!("Best cookie (500 cal):", kitchen.best_cookie(100, 500).score)

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

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

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

@@ -0,0 +1,54 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    EXPECTED_READINGS = {
+      children: 3,
+      cats: 7,
+      samoyeds: 2,
+      pomeranians: 3,
+      akitas: 0,
+      vizslas: 0,
+      goldfish: 5,
+      trees: 3,
+      cars: 2,
+      perfumes: 1
+    }.freeze
+
+    def parse(lines)
+      lines.map do |line|
+        readings = line.scan(/(\w+): (\d)/).flat_map do |(reading, value)|
+          [reading.to_sym, value.to_i]
+        end
+
+        Hash[*readings]
+      end
+    end
+
+    def correct_sue(sues, checker)
+      matches = EXPECTED_READINGS.reduce(sues) do |remaining, (reading, value)|
+        remaining.select { |sue| checker.call(reading, value, sue) }
+      end
+
+      sues.index(matches.first) + 1
+    end
+
+    validity = ->(reading, value, sue) { sue[reading].nil? || sue[reading] == value }
+
+    SUES = parse(INPUT.split("\n"))
+    solve!("The number of the correct Sue:", correct_sue(SUES, validity))
+
+    adjusted_validity = lambda do |reading, value, sue|
+      return true if sue[reading].nil?
+
+      case reading
+      when :cats, :trees
+        sue[reading] > value
+      when :pomeranians, :goldfish
+        sue[reading] < value
+      else
+        sue[reading] == value
+      end
+    end
+
+    solve!("The number of the correct Sue (with adjustments):", correct_sue(SUES, adjusted_validity))

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

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

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

@@ -0,0 +1,19 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    LITERS ||= 150
+    containers = INPUT.split("\n").map(&:to_i)
+
+    combos = (1..containers.length).flat_map do |i|
+      containers.combination(i).to_a
+    end
+
+    working = combos.select { |combo| combo.sum == LITERS }
+
+    solve!("Working combinations:", working.size)
+
+    min_length = working.min_by(&:size).size
+    matching = working.count { |combo| combo.size == min_length }
+
+    solve!("Working combinations with minimal container use:", matching)

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

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

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

@@ -0,0 +1,101 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    class Light
+      attr_reader :x, :y, :grid
+
+      def initialize(grid, x, y, on)
+        @grid = grid
+        @x = x
+        @y = y
+        @on = on
+        @set = nil
+      end
+
+      def neighbors
+        @neighbors ||= [
+          grid[x - 1, y - 1],
+          grid[x - 1, y],
+          grid[x - 1, y + 1],
+          grid[x, y - 1],
+          grid[x, y + 1],
+          grid[x + 1, y - 1],
+          grid[x + 1, y],
+          grid[x + 1, y + 1]
+        ].uniq.compact
+      end
+
+      def on?
+        return true if @stuck
+
+        !!@on
+      end
+
+      def check!
+        @set =
+          if on?
+            [2, 3].include?(neighbors.count(&:on?))
+          else
+            neighbors.count(&:on?) == 3
+          end
+      end
+
+      def tick!
+        @on = @set
+        @set = nil
+      end
+
+      def stuck!
+        @stuck = true
+      end
+    end
+
+    class Grid
+      def initialize(instructions)
+        @size = instructions.split("\n").count
+        @lights = {}
+
+        instructions.split("\n").each_with_index do |row, x|
+          row.chars.each_with_index do |state, y|
+            @lights[[x, y]] = Light.new(self, x, y, state == "#")
+          end
+        end
+      end
+
+      def [](x, y)
+        @lights[[x, y]]
+      end
+
+      def tick!
+        @lights.values.each(&:check!).each(&:tick!)
+      end
+
+      def count
+        @lights.values.count(&:on?)
+      end
+
+      def corners
+        [
+          [0, 0],
+          [0, @size - 1],
+          [@size - 1, 0],
+          [@size - 1, @size - 1]
+        ].map do |(x, y)|
+          self[x, y]
+        end
+      end
+    end
+
+    grid = Grid.new(INPUT)
+    STEPS ||= 100
+    STEPS.times { grid.tick! }
+
+    solve!("Lights on:", grid.count)
+
+    grid = Grid.new(INPUT)
+    grid.corners.each(&:stuck!)
+
+    STEPS.times { grid.tick! }
+
+    solve!("Lights on (stuck corners):", grid.count)

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

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

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

@@ -0,0 +1,78 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    require "set"
+
+    class Reaction
+      attr_reader :base, :result
+
+      def initialize(base, result)
+        @base = base
+        @result = result
+      end
+
+      def possible_formulas(formula)
+        new_formulas = []
+
+        sequence = formula.scan(/[A-Z][a-z]?/)
+        sequence.each_with_index do |component, position|
+          next unless component == base
+
+          new_sequence = sequence.dup
+          new_sequence[position] = result
+          new_formulas << new_sequence.join
+        end
+
+        new_formulas
+      end
+
+      def can_decompose?(formula)
+        formula.include?(result)
+      end
+
+      def decompose(formula)
+        formula.sub(result, base)
+      end
+    end
+
+    lines = INPUT.split("\n").reject(&:empty?)
+
+    FORMULA = lines.pop
+    REACTIONS = lines.map { |line| Reaction.new(*line.split(" => ")) }
+    ELECTRON = "e".freeze
+
+    all_reactions = REACTIONS.each_with_object(Set.new) do |reaction, set|
+      set.merge(reaction.possible_formulas(FORMULA))
+    end
+
+    solve!("Total possible results:", all_reactions.size)
+
+    def decompose(formula, reactions)
+      steps = 0
+
+      loop do
+        return if reactions.none? { |reaction| reaction.can_decompose?(formula) }
+
+        reactions.each do |reaction|
+          break if reaction.base == "e" && formula.length > reaction.result.length
+          next unless reaction.can_decompose?(formula)
+
+          formula = reaction.decompose(formula)
+          steps += 1
+
+          return steps if formula == ELECTRON
+        end
+      end
+    end
+
+    def decomposition_steps(formula)
+      REACTIONS.permutation.each do |reactions|
+        steps = decompose(formula, reactions)
+        return steps if steps
+      end
+
+      nil
+    end
+
+    solve!("Steps required to compose formula:", decomposition_steps(FORMULA))

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

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

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

@@ -0,0 +1,42 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    require "prime"
+
+    GIFTS = INPUT.to_i
+
+    def elves_for(house)
+      # Apologies to: http://stackoverflow.com/questions/3398159/all-factors-of-a-given-number/3398195
+      primes, powers = Prime.prime_division(house).transpose
+      exponents = powers.map { |i| (0..i).to_a }
+
+      exponents.shift.product(*exponents).map do |powers|
+        primes.zip(powers).map { |prime, power| prime**power }.inject(:*)
+      end
+    end
+
+    def first_house(target, multiplier)
+      house = 1
+      elves = [1]
+
+      loop do
+        total = elves.sum
+        break if total * multiplier >= target
+
+        house += 1
+        elves = elves_for(house)
+        elves = yield(house, elves) if block_given?
+      end
+
+      house
+    end
+
+    door = first_house(GIFTS, 10)
+    solve!("First house to receive #{GIFTS}:", door)
+
+    door = first_house(GIFTS, 11) do |house, elves|
+      cutoff = house / 50
+      elves.reject { |elf| elf < cutoff }
+    end
+    solve!("First house to receive #{GIFTS} (lazy elves):", door)

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

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

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

@@ -0,0 +1,101 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    WEAPONS = {
+      "Unarmed" => {cost: 0, attack: 0, defense: 0},
+      "Dagger" => {cost: 8, attack: 4, defense: 0},
+      "Shortsword" => {cost: 10, attack: 5, defense: 0},
+      "Warhammer" => {cost: 25, attack: 6, defense: 0},
+      "Longsword" => {cost: 40, attack: 7, defense: 0},
+      "Greataxe" => {cost: 74, attack: 8, defense: 0}
+    }.values
+
+    ARMOR = {
+      "Naked" => {cost: 0, attack: 0, defense: 0},
+      "Leather" => {cost: 13, attack: 0, defense: 1},
+      "Chainmail" => {cost: 31, attack: 0, defense: 2},
+      "Splintmail" => {cost: 53, attack: 0, defense: 3},
+      "Bandedmail" => {cost: 75, attack: 0, defense: 4},
+      "Platemail" => {cost: 102, attack: 0, defense: 5}
+    }.values
+
+    RINGS = {
+      "Damage +1" => {cost: 25, attack: 1, defense: 0},
+      "Damage +2" => {cost: 50, attack: 2, defense: 0},
+      "Damage +3" => {cost: 100, attack: 3, defense: 0},
+      "Defense +1" => {cost: 20, attack: 0, defense: 1},
+      "Defense +2" => {cost: 40, attack: 0, defense: 2},
+      "Defense +3" => {cost: 80, attack: 0, defense: 3}
+    }.values
+
+    class Equipment
+      def initialize(items = [])
+        @items = items
+      end
+
+      def attack
+        @items.map { |i| i[:attack] }.inject(0, :+)
+      end
+
+      def defense
+        @items.map { |i| i[:defense] }.inject(0, :+)
+      end
+
+      def cost
+        @items.map { |i| i[:cost] }.inject(0, :+)
+      end
+    end
+
+    class Character
+      attr_reader :hp
+
+      def initialize(hit_points, attack, defense)
+        @hp = hit_points
+        @attack = attack
+        @defense = defense
+      end
+
+      def equip(equipment)
+        @equipment = equipment
+      end
+
+      def beats?(enemy)
+        turns_to_kill = (enemy.hp.to_f / [(attack - enemy.defense), 1].max).ceil
+        turns_to_die = (hp.to_f / [(enemy.attack - defense), 1].max).ceil
+
+        turns_to_kill <= turns_to_die
+      end
+
+      def attack
+        @attack + equipment.attack
+      end
+
+      def defense
+        @defense + equipment.defense
+      end
+
+      def equipment
+        @equipment || Equipment.new
+      end
+    end
+
+    def loadouts
+      rings = (0..2).flat_map { |i| RINGS.combination(i).to_a }
+      combinations = WEAPONS.product(ARMOR).product(rings).map(&:flatten)
+      combinations.map { |loadout| Equipment.new(loadout) }
+    end
+
+    ENEMY_STATS = INPUT.split("\n").map { |line| line.scan(/\d+/).join.to_i }
+    enemy = Character.new(*ENEMY_STATS)
+
+    HERO_STATS ||= [100, 0, 0].freeze
+    hero = Character.new(*HERO_STATS)
+
+    winning_loadouts, losing_loadouts = loadouts.partition do |equipment|
+      hero.equip(equipment)
+      hero.beats?(enemy)
+    end
+
+    solve!("Cheapest winning loadout:", winning_loadouts.min_by(&:cost).cost)
+    solve!("Most expensive losing loadout:", losing_loadouts.max_by(&:cost).cost)

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

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