advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,137 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    # rubocop:disable Layout/LineLength,Lint/MixedRegexpCaptureTypes
+    MATCHER = /(?<unit_count>\d+) units each with (?<health>\d+) hit points(?<specialties>( \(.+\))?) with an attack that does (?<damage>\d+) (?<damage_type>.+) damage at initiative (?<initiative>\d+)/
+    # rubocop:enable Layout/LineLength,Lint/MixedRegexpCaptureTypes
+    WEAKNESS_MATCHER = /weak to (?<damage_types>[^;)]+)+/
+    IMMUNITY_MATCHER = /immune to (?<damage_types>[^;)]+)+/
+
+    class Group
+      TEAMS = {immune: "Immune System", infection: "Infection"}.freeze
+
+      attr_accessor :size, :damage
+      attr_reader :team, :multipliers, :health, :initiative
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(team, size, health, damage, damage_type, initiative, specialties)
+        @team = team
+        @size = size
+        @health = health
+        @damage = damage
+        @type = damage_type
+        @initiative = initiative
+        @multipliers = Hash.new(1).merge(specialties)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def effective_power
+        size * damage
+      end
+
+      def target(groups)
+        enemies = groups.reject { |g| g.team == team }
+        return nil if enemies.empty?
+
+        enemy = enemies.max_by { |enemy| [damage_to(enemy), enemy.effective_power, enemy.initiative] }
+        (damage_to(enemy) == 0) ? nil : enemy
+      end
+
+      def damage_to(enemy)
+        effective_power * enemy.multipliers[@type]
+      end
+
+      def dead?
+        size <= 0
+      end
+
+      def infection?
+        team == TEAMS[:infection]
+      end
+
+      def immune?
+        team == TEAMS[:immune]
+      end
+    end
+
+    groups = []
+    team = Group::TEAMS[:immune]
+
+    INPUT.split("\n").each do |line|
+      case line
+      when MATCHER
+        data = $~
+
+        multipliers = [[WEAKNESS_MATCHER, 2], [IMMUNITY_MATCHER, 0]].flat_map do |matcher, m|
+          specialty = data[:specialties].match(matcher)
+          next unless specialty
+
+          specialty[:damage_types].split(", ").map { |type| [type.to_sym, m] }
+        end.compact
+
+        groups << Group.new(
+          team,
+          data[:unit_count].to_i,
+          data[:health].to_i,
+          data[:damage].to_i,
+          data[:damage_type].to_sym,
+          data[:initiative].to_i,
+          multipliers.to_h
+        )
+      when "Infection:"
+        team = Group::TEAMS[:infection]
+      end
+    end
+
+    def targets_for(groups)
+      target_order = groups.sort_by { |g| [-g.effective_power, -g.initiative] }
+      target_order.each_with_object({}) do |group, targets|
+        targets[group] = group.target(groups - targets.values)
+      end
+    end
+
+    def fight(groups, immune_boost = 0)
+      groups = groups.map(&:dup)
+      groups.select(&:immune?).each { |group| group.damage += immune_boost }
+
+      loop do
+        targets = targets_for(groups)
+        kill_count = 0
+        groups.sort_by { |group| -group.initiative }.each do |group|
+          next if group.dead?
+
+          target = targets[group]
+          next unless target
+
+          kill_count += kills = group.damage_to(target) / target.health
+          target.size = [0, target.size - kills].max
+        end
+
+        break if kill_count == 0
+
+        groups.reject!(&:dead?)
+        break if groups.all?(&:immune?) || groups.all?(&:infection?)
+      end
+
+      winner =
+        if groups.all?(&:infection?)
+          :infections
+        elsif groups.all?(&:immune?)
+          :immune_system
+        else
+          :neither
+        end
+
+      [winner, groups.map(&:size).sum]
+    end
+
+    _, score = fight(groups)
+    solve!("The number of units remaining for the winning army is:", score)
+
+    final = 1.step do |boost|
+      winner, score = fight(groups, boost)
+      break score if winner == :immune_system
+    end
+
+    solve!("The number of immune system units remaining after a minimal boost is:", final)

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

@@ -0,0 +1,27 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MAX_DISTANCE = 3
+
+    def constellation?(a, b)
+      a.zip(b).map { |i, j| (i - j).abs }.sum <= MAX_DISTANCE
+    end
+
+    CONSTELLATIONS = INPUT.split("\n").each_with_object([]) do |line, constellations|
+      point = line.split(",").map(&:to_i)
+      merges = []
+
+      constellations.each_with_index do |constellation, _index|
+        merges << constellation if constellation.any? { |p| constellation?(point, p) }
+      end
+
+      if merges.empty?
+        constellations << [point]
+      else
+        merges.each { |constellation| constellations.delete(constellation) }
+        constellations.push(merges.flatten(1) + [point])
+      end
+    end
+
+    solve!("The number of distinct constellations is:", CONSTELLATIONS.size)

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

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

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

@@ -0,0 +1,22 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    MODULES = INPUT.split("\n").map(&:to_i)
+
+    def fuel_requirement(mass)
+      (mass / 3.0).floor - 2
+    end
+
+    total = MODULES.sum { |mass| fuel_requirement(mass) }
+    solve!("The total fuel requirement is:", total)
+
+    def compounded_fuel_requirement(mass)
+      fuel = 0
+      fuel += mass = [fuel_requirement(mass), 0].max while mass > 0
+
+      fuel
+    end
+
+    total = MODULES.sum { |mass| compounded_fuel_requirement(mass) }
+    solve!("The total fuel requirement (with compounding) is:", total)

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

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

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

@@ -0,0 +1,30 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    def run(noun, verb)
+      program = INTCODE.dup
+      program[1] = noun
+      program[2] = verb
+
+      computer = Computer.new(program)
+      computer.run
+
+      computer[0]
+    end
+
+    SETTING ||= [12, 2].freeze
+    output = run(*SETTING)
+    solve!("The output of the program is:", output)
+
+    TARGET_OUTPUT = 19_690_720
+
+    def search(_intcode, target)
+      100.times { |n| 100.times { |v| return [n, v] if run(n, v) == target } }
+    end
+
+    noun, verb = search(INTCODE, TARGET_OUTPUT)
+
+    solve!("The noun/verb code for the target output is:", (noun * 100) + verb)

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

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

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

@@ -0,0 +1,57 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require "set"
+
+    WIRES = INPUT.split("\n").map { |instructions| instructions.split(",") }.freeze
+
+    class Grid
+      STEPS = {
+        "U" => [0, -1],
+        "D" => [0, 1],
+        "L" => [-1, 0],
+        "R" => [1, 0]
+      }.freeze
+
+      def initialize
+        @grid = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def add(id, steps)
+        x = 0
+        y = 0
+        total = 0
+
+        steps.each do |step|
+          distance = step.scan(/\d+/)[0].to_i
+          vector = STEPS[step[0]]
+
+          distance.times do
+            x += vector[0]
+            y += vector[1]
+            total += 1
+
+            @grid[[x, y]][id] ||= total
+          end
+        end
+      end
+
+      def intersections
+        @grid.keys.select { |position| @grid[position].length > 1 }
+      end
+
+      def combined_steps(intersection)
+        @grid[intersection].map(&:last).sum
+      end
+    end
+
+    grid = Grid.new
+    WIRES.each_with_index { |steps, id| grid.add(id, steps) }
+    intersections = grid.intersections
+
+    closest = intersections.map { |intersection| intersection.map(&:abs).sum }.min
+    solve!("The manhattan distance to the closest intersection is:", closest)
+
+    min_steps = intersections.map { |intersection| grid.combined_steps(intersection) }.min
+    solve!("The minimum number of combined steps to any intersection is:", min_steps)

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

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

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

@@ -0,0 +1,30 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    inputs = INPUT.split("-").map(&:to_i)
+    RANGE = (inputs[0]..inputs[1])
+
+    def valid_password?(number)
+      digits = number.to_s.chars.map(&:to_i)
+      comparisons = digits.each_cons(2)
+
+      digits.count == 6 &&
+        comparisons.none? { |(a, b)| a > b } &&
+        comparisons.any? { |(a, b)| a == b }
+    end
+
+    count = RANGE.count { |number| valid_password?(number) }
+    solve!("The number of valid passwords is:", count)
+
+    def strict_password?(number)
+      digits = number.to_s.chars.map(&:to_i)
+      comparisons = digits.each_cons(2)
+
+      digits.count == 6 &&
+        comparisons.none? { |(a, b)| a > b } &&
+        digits.chunk(&:to_i).any? { |_, group| group.size == 2 }
+    end
+
+    count = RANGE.count { |number| strict_password?(number) }
+    solve!("The number of (strict) valid passwords is:", count)

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

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

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

@@ -0,0 +1,11 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    outputs = Computer.new(INTCODE).run(inputs: [1])
+    solve!("The diagnostic code for the air conditioner unit is:", outputs.last)
+
+    outputs = Computer.new(INTCODE).run(inputs: [5])
+    solve!("The diagnostic code for the thermal radiator controller is:", outputs.last)

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

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

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

@@ -0,0 +1,42 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    ORBITS = INPUT.split("\n").map { |orbit| orbit.split(")").reverse }.to_h
+
+    class OrbitMap
+      CENTER = "COM".freeze
+
+      def initialize(orbits)
+        @map = orbits
+        @checksums = {}
+      end
+
+      def total_orbits
+        @map.keys.map { |object| orbits_for(object).size }.sum
+      end
+
+      def transfers_between(origin, destination)
+        from_origin = orbits_for(origin)
+        from_destination = orbits_for(destination)
+
+        (from_origin + from_destination - (from_origin & from_destination)).size
+      end
+
+      private
+
+      def orbits_for(object)
+        orbits = []
+
+        until object == CENTER
+          object = @map[object]
+          orbits.push(object)
+        end
+
+        orbits
+      end
+    end
+
+    map = OrbitMap.new(ORBITS)
+    solve!("The total number of direct and indirect orbits is:", map.total_orbits)
+    solve!("The minimum number of orbital transfers to Santa is:", map.transfers_between("YOU", "SAN"))

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

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

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

@@ -0,0 +1,26 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    def amplify(phase_settings)
+      signal = 0
+      amplifiers = phase_settings.map do |setting|
+        Computer.new(INTCODE).tap { |cpu| cpu.run(inputs: [setting]) }
+      end
+
+      loop do
+        amplifiers.each { |amplifier| signal = amplifier.run(inputs: [signal]).last }
+        break if amplifiers.none?(&:running?)
+      end
+
+      signal
+    end
+
+    def optimal_signal(phases)
+      phases.permutation.to_a.map { |phase_settings| amplify(phase_settings) }.max
+    end
+
+    solve!("The maximum thruster signal is:", optimal_signal([0, 1, 2, 3, 4]))
+    solve!("The maximum feedback loop thruster signal is:", optimal_signal([5, 6, 7, 8, 9]))

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    PIXELS = INPUT.chars.map(&:to_i)
+    WIDTH ||= 25
+    HEIGHT ||= 6
+
+    LAYERS = PIXELS.each_slice(WIDTH * HEIGHT).to_a
+
+    min_layer = LAYERS.min_by { |layer| layer.count(0) }
+    solve!("The layer checksum is:", min_layer.count(1) * min_layer.count(2))
+
+    OUTPUTS = {0 => ".", 1 => "#"}.freeze
+    IMAGE = LAYERS.each_with_object(Array.new(WIDTH * HEIGHT)) do |layer, image|
+      layer.each_with_index do |pixel, i|
+        next if pixel == 2
+
+        image[i] ||= pixel
+      end
+    end
+
+    screen = HEIGHT.times.each_with_object("") do |y, output|
+      WIDTH.times { |x| output << OUTPUTS[IMAGE[(WIDTH * y) + x]] }
+      output << "\n"
+    end
+
+    solve!("The final image is:\n\n", screen)

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

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

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

@@ -0,0 +1,8 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    solve!("The BOOST keycode is:", Computer.new(INTCODE).run(inputs: [1]))
+    solve!("The distress signal coordinates are:", Computer.new(INTCODE).run(inputs: [2]))

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

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

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

@@ -0,0 +1,72 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    GRID = INPUT.split("\n").each_with_object({}).with_index do |(line, field), y|
+      line.chars.each_with_index { |c, x| field[[x, y]] = (c == "#") }
+    end
+
+    class AsteroidField
+      def initialize(field)
+        @field = field.dup
+      end
+
+      def asteroids
+        @field.keys.select { |coords| @field[coords] }
+      end
+
+      def visible_from(x, y)
+        asteroids.select { |i, j| !(i == x && j == y) && line_of_sight?(x, y, i, j) }
+      end
+
+      def sweep_from!(x, y)
+        sequence = []
+
+        loop do
+          targets = visible_from(x, y).sort_by { |i, j| angle_for(i - x, j - y) }
+          targets.each { |i, j| @field[[i, j]] = false }
+          sequence += targets
+
+          break sequence if asteroids.count <= 1
+        end
+      end
+
+      private
+
+      def angle_for(dx, dy)
+        Math.atan2(dx, -dy) % (Math::PI * 2)
+      end
+
+      def line_of_sight?(x, y, i, j)
+        cx = x
+        cy = y
+        dx = i - x
+        dy = j - y
+
+        2.upto([dx.abs, dy.abs].max) do |n|
+          while dx % n == 0 && dy % n == 0
+            dx /= n
+            dy /= n
+          end
+        end
+
+        loop do
+          cx += dx
+          cy += dy
+          break if cx == i && cy == j
+          return false if @field[[cx, cy]]
+        end
+
+        true
+      end
+    end
+
+    field = AsteroidField.new(GRID)
+    station = field.asteroids.max_by { |x, y| field.visible_from(x, y).count }
+
+    solve!("The number of detectable asteroids from the station is:", field.visible_from(*station).count)
+
+    TARGET = 200
+    x, y = field.sweep_from!(*station)[TARGET - 1]
+
+    solve!("The number of the 200th vaporized asteroid will be:", (x * 100) + y)

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

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

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

@@ -0,0 +1,58 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    require_relative "shared/intcode"
+
+    VECTORS = {
+      up: [0, -1],
+      left: [-1, 0],
+      down: [0, 1],
+      right: [1, 0]
+    }.freeze
+    DIRECTIONS = %i[up right down left].freeze
+
+    def rotate_by(direction, rotate)
+      rotation = (rotate == 0) ? -1 : 1
+      (direction + rotation) % DIRECTIONS.size
+    end
+
+    def move_by(x, y, direction)
+      vector = VECTORS[DIRECTIONS[direction]]
+      [x + vector[0], y + vector[1]]
+    end
+
+    def run!(hull)
+      robot = Computer.new(INTCODE)
+      x = 0
+      y = 0
+      direction = 0
+
+      loop do
+        color, rotate = robot.run(inputs: [hull[[x, y]]])
+
+        hull[[x, y]] = color
+        direction = rotate_by(direction, rotate)
+        x, y = move_by(x, y, direction)
+
+        break unless robot.running?
+      end
+    end
+
+    hull = Hash.new(0)
+    run!(hull)
+    solve!("The number of painted panels is:", hull.count)
+
+    hull = Hash.new(0)
+    hull[[0, 0]] = 1
+    run!(hull)
+
+    minx, maxx = hull.keys.map(&:first).minmax
+    miny, maxy = hull.keys.map(&:last).minmax
+
+    screen = (miny..maxy).each_with_object("") do |j, output|
+      (minx..maxx).each { |i| output << ((hull[[i, j]] == 0) ? " " : "#") }
+      output << "\n"
+    end
+
+    solve!("The registration identifier is:\n\n", screen)

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

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

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

@@ -0,0 +1,71 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2019
+  :solution: |-
+    MATCHER = /<x=(?<x>-?\d+), y=(?<y>-?\d+), z=(?<z>-?\d+)>/
+    MOONS = INPUT.split("\n").map { |line| line.match(MATCHER).captures.map(&:to_i) }.freeze
+
+    class Moon
+      attr_reader :position
+
+      def initialize(position)
+        @position = position
+        @velocity = [0, 0, 0]
+      end
+
+      def pull!(moon)
+        @position.each_with_index do |coord, i|
+          @velocity[i] += moon.position[i] <=> coord
+        end
+      end
+
+      def move!
+        @position = @position.zip(@velocity).map(&:sum)
+      end
+
+      def energy
+        potential_energy * kinetic_energy
+      end
+
+      def potential_energy
+        @position.map(&:abs).sum
+      end
+
+      def kinetic_energy
+        @velocity.map(&:abs).sum
+      end
+    end
+
+    def tick!(moons)
+      moons.combination(2) do |first, second|
+        first.pull!(second)
+        second.pull!(first)
+      end
+
+      moons.each(&:move!)
+    end
+
+    moons = MOONS.map { |position| Moon.new(position) }
+
+    STEPS ||= 1_000
+    STEPS.times { tick!(moons) }
+
+    solve!("The total energy after 1000 steps is:", moons.sum(&:energy))
+
+    moons = MOONS.map { |position| Moon.new(position) }
+    cycles = [nil, nil, nil]
+    ticks = 1
+
+    loop do
+      tick!(moons)
+      ticks += 1
+
+      3.times do |axis|
+        cycled = MOONS.each_with_index.all? { |pos, i| pos[axis] == moons[i].position[axis] }
+        cycles[axis] ||= ticks if cycled
+      end
+
+      break if cycles.all?
+    end
+
+    solve!("The minimum number of steps to repeat the cycle is:", cycles.reduce(1, :lcm))

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

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