advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,101 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Tube
+      attr_reader :opening
+
+      def initialize(input)
+        @grid = {}
+        @opening = nil
+
+        input.split("\n").each_with_index do |row, y|
+          row.chars.each_with_index do |cell, x|
+            @grid[[x, y]] =
+              case cell
+              when " "
+                false
+              when /\w/
+                cell
+              else
+                true
+              end
+
+            @opening = [x, y] if @grid[[x, y]] && y == 0
+          end
+        end
+      end
+
+      def valid?(space)
+        !!@grid[space]
+      end
+
+      def letter(space)
+        @grid[space].is_a?(String) ? @grid[space] : nil
+      end
+    end
+
+    class Packet
+      DIRECTIONS = {
+        up: [0, -1],
+        down: [0, 1],
+        left: [-1, 0],
+        right: [1, 0]
+      }.freeze
+
+      attr_reader :collection, :steps
+
+      def initialize(tube)
+        @tube = tube
+      end
+
+      def navigate
+        @position = @tube.opening
+        @collection = []
+        @steps = 0
+
+        @direction = :down
+        @last_position = nil
+
+        loop do
+          @steps += 1
+
+          direction, move_to = next_move
+          break if direction.nil?
+
+          @direction = direction
+          @last_position = @position
+          @position = move_to
+
+          letter = @tube.letter(@position)
+          @collection << letter if letter
+        end
+      end
+
+      private
+
+      def next_move
+        new_direction = ([@direction] + DIRECTIONS.keys).detect do |dir|
+          new_position = move(dir)
+          new_position != @last_position && @tube.valid?(new_position)
+        end
+
+        return [nil, nil] unless new_direction
+
+        [new_direction, move(new_direction)]
+      end
+
+      def move(direction)
+        [
+          @position[0] + DIRECTIONS[direction][0],
+          @position[1] + DIRECTIONS[direction][1]
+        ]
+      end
+    end
+
+    tube = Tube.new(INPUT)
+    packet = Packet.new(tube)
+    packet.navigate
+
+    solve!("The packet collected letters in the order:", packet.collection.join)
+    solve!("The number of steps the packet moved is:", packet.steps)

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

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

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

@@ -0,0 +1,52 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Particle
+      PARTICLE_MATCHER = /p=<(?<position>.+)>, v=<(?<velocity>.+)>, a=<(?<acceleration>.+)>/
+
+      attr_reader :id, :position
+
+      def initialize(id, line)
+        @id = id
+
+        traits = PARTICLE_MATCHER.match(line)
+        @position = traits[:position].split(",").map(&:to_i)
+        @velocity = traits[:velocity].split(",").map(&:to_i)
+        @acceleration = traits[:acceleration].split(",").map(&:to_i)
+      end
+
+      def displacement
+        @position.map(&:abs).sum
+      end
+
+      def acceleration
+        @acceleration.map(&:abs).sum
+      end
+
+      def speed
+        @velocity.map(&:abs).sum
+      end
+
+      def tick!
+        @velocity = @velocity.zip(@acceleration).map(&:sum)
+        @position = @position.zip(@velocity).map(&:sum)
+      end
+    end
+
+    particles = []
+    INPUT.split("\n").each_with_index do |line, i|
+      particles << Particle.new(i, line)
+    end
+
+    closest = particles.min_by { |p| [p.acceleration, p.speed, p.displacement] }
+    solve!("The long-term closest particle is:", closest.id)
+
+    100.times do
+      particles.each(&:tick!)
+
+      counts = particles.each_with_object(Hash.new(0)) { |p, c| c[p.position] += 1 }
+      particles.reject! { |p| counts[p.position] > 1 }
+    end
+
+    solve!("The number of particles remaining after collisions is:", particles.count)

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

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

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

@@ -0,0 +1,53 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    def variants(string)
+      base = string.split("/").map(&:chars)
+
+      [
+        base,
+        base.map(&:reverse),
+        base.reverse,
+        base.reverse.map(&:reverse),
+        base.transpose,
+        base.transpose.map(&:reverse),
+        base.transpose.reverse,
+        base.transpose.reverse.map(&:reverse)
+      ].uniq.map do |variant|
+        variant.map(&:join).join("/")
+      end
+    end
+
+    RULES = INPUT.split("\n").each_with_object({}) do |line, rules|
+      input, output = line.split(" => ")
+      variants(input).each { |variant| rules[variant] = output }
+    end
+
+    def enhance(grid)
+      section_size = grid.size.even? ? 2 : 3
+
+      grid.each_slice(section_size).flat_map do |lines|
+        portions = lines.map do |line|
+          line.chars.each_slice(section_size).map(&:join)
+        end.inject(&:zip)
+
+        results = portions.map { |p| RULES[p.join("/")].split("/") }
+        (results.size > 1) ? results.inject(&:zip).map(&:join) : results.flatten
+      end
+    end
+
+    STARTING_GRID = [
+      ".#.",
+      "..#",
+      "###"
+    ].freeze
+
+    ITERATIONS ||= 5
+
+    grid = STARTING_GRID.dup
+    ITERATIONS.times { grid = enhance(grid) }
+    solve!("The number of pixels that stay on after 5 enhancements is:", grid.join.count("#"))
+
+    13.times { grid = enhance(grid) }
+    solve!("The number of pixels that stay on after 18 enhancements is:", grid.join.count("#"))

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Network
+      STAGES = %w[. #].freeze
+      EVOLVED_STAGES = %w[. W # F].freeze
+
+      attr_accessor :center
+
+      def initialize(input, evolved: false)
+        @evolved = evolved
+        @nodes = Hash.new(".")
+
+        rows = 0
+        columns = 0
+
+        input.split("\n").each_with_index do |line, y|
+          rows = [rows, y].max
+          line.chars.each_with_index do |c, x|
+            columns = [columns, x].max
+            @nodes[[x, y]] = c
+          end
+        end
+
+        @center = [rows / 2, columns / 2]
+      end
+
+      def [](position)
+        @nodes[position]
+      end
+
+      def advance!(position)
+        stages = @evolved ? EVOLVED_STAGES : STAGES
+        @nodes[position] = stages[(stages.index(@nodes[position]) + 1) % stages.size]
+      end
+    end
+
+    class Carrier
+      DIRECTIONS = %i[u r d l].freeze
+      MOVES = {u: [0, -1], r: [1, 0], d: [0, 1], l: [-1, 0]}.freeze
+      TURNS = {"." => -1, "W" => 0, "#" => 1, "F" => 2}.freeze
+
+      attr_accessor :infections
+
+      def initialize(network)
+        @direction = :u
+        @infections = 0
+
+        @network = network
+        @position = @network.center
+      end
+
+      def burst!
+        turn!(TURNS[@network[@position]])
+
+        result = @network.advance!(@position)
+        @infections += 1 if result == "#"
+
+        @position[0] += MOVES[@direction][0]
+        @position[1] += MOVES[@direction][1]
+      end
+
+      def turn!(amount)
+        @direction = DIRECTIONS[(DIRECTIONS.index(@direction) + amount) % DIRECTIONS.size]
+      end
+    end
+
+    network = Network.new(INPUT)
+    carrier = Carrier.new(network)
+    10_000.times { carrier.burst! }
+
+    solve!("The number of infections caused by the carrier is:", carrier.infections)
+
+    network = Network.new(INPUT, evolved: true)
+    carrier = Carrier.new(network)
+    10_000_000.times { carrier.burst! }
+
+    solve!("The number of evolved infections caused by the carrier is:", carrier.infections)

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

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

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

@@ -0,0 +1,49 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    INSTRUCTIONS = INPUT.split("\n").map(&:split)
+
+    def resolve(registers, value)
+      if value.to_i.to_s == value
+        value.to_i
+      else
+        registers[value]
+      end
+    end
+
+    registers = Hash.new(0)
+    runs = Hash.new(0)
+    cursor = 0
+
+    loop do
+      break if cursor < 0 || cursor >= INSTRUCTIONS.length
+
+      instruction = INSTRUCTIONS[cursor]
+      runs[instruction[0]] += 1
+
+      case instruction[0]
+      when "set"
+        registers[instruction[1]] = resolve(registers, instruction[2])
+      when "sub"
+        registers[instruction[1]] -= resolve(registers, instruction[2])
+      when "mul"
+        registers[instruction[1]] *= resolve(registers, instruction[2])
+      when "jnz"
+        cursor += resolve(registers, instruction[2]) - 1 if resolve(registers, instruction[1]) != 0
+      end
+
+      cursor += 1
+    end
+
+    solve!("The number of `mul` instructions run is:", runs["mul"])
+
+    # We're counting non-prime numbers.
+    require "prime"
+
+    values = INSTRUCTIONS.map { |i| i[2].to_i }
+    starts = (values[0] * values[4]) - values[5]
+    ends = starts - values[7]
+    nonprimes = (starts..ends).step(-values[30]).count { |n| !Prime.prime?(n) }
+
+    solve!("The value of register h is:", nonprimes)

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

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

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

@@ -0,0 +1,46 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Bridge
+      COMPONENTS = INPUT.split("\n").map { |l| l.split("/").map(&:to_i) }
+
+      def initialize(components = [], open_port = 0)
+        @components = components
+        @open = open_port
+      end
+
+      def extended_with(component)
+        Bridge.new(
+          @components + [component],
+          (component[0] == @open) ? component[1] : component[0]
+        )
+      end
+
+      def extended_by?(component)
+        component.include?(@open)
+      end
+
+      def strength
+        @components.map(&:sum).sum
+      end
+
+      def length
+        @components.size
+      end
+
+      def possibilities(components = COMPONENTS)
+        valid_components = components.select { |c| extended_by?(c) }
+        return [self] unless valid_components.any?
+
+        valid_components.flat_map do |c|
+          extended_with(c).possibilities(components - [c])
+        end
+      end
+    end
+
+    bridges = Bridge.new.possibilities
+    solve!("The maximum bridge strength is:", bridges.max_by(&:strength).strength)
+
+    _max_length, long_bridges = bridges.group_by(&:length).max
+    solve!("The strength of the longest bridge is:", long_bridges.max_by(&:strength).strength)

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

@@ -0,0 +1,38 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    START_MATCHER = /Begin in state (?<state>\w)\./
+    STEPS_MATCHER = /Perform a diagnostic checksum after (?<steps>\d+) steps\./
+
+    # rubocop:disable Layout/LineLength
+    RULE_MATCHER = /In state (?<state>\w):\n  If the current value is 0:\n    - Write the value (?<zero_value>\d)\.\n    - Move one slot to the (?<zero_direction>\w+)\.\n    - Continue with state (?<zero_state>\w)\.\n  If the current value is 1:\n    - Write the value (?<one_value>\d)\.\n    - Move one slot to the (?<one_direction>\w+)\.\n    - Continue with state (?<one_state>\w)\./
+    # rubocop:enable Layout/LineLength
+
+    rules = {}
+    INPUT.scan(RULE_MATCHER) do
+      rules[[$~[:state], 0]] = {
+        value: $~[:zero_value].to_i,
+        move: ($~[:zero_direction] == "left") ? -1 : 1,
+        state: $~[:zero_state]
+      }
+      rules[[$~[:state], 1]] = {
+        value: $~[:one_value].to_i,
+        move: ($~[:one_direction] == "left") ? -1 : 1,
+        state: $~[:one_state]
+      }
+    end
+
+    state = INPUT.match(START_MATCHER)[:state]
+    steps = INPUT.match(STEPS_MATCHER)[:steps].to_i
+    cursor = 0
+    slots = Hash.new(0)
+
+    steps.times do
+      rule = rules[[state, slots[cursor]]]
+      slots[cursor] = rule[:value]
+      cursor += rule[:move]
+      state = rule[:state]
+    end
+
+    solve!("The number of 1s in the checksum is:", slots.values.count(1))

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

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

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

@@ -0,0 +1,21 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    CHANGES = INPUT.split("\n").map(&:to_i)
+
+    solve!("The final total frequency is:", CHANGES.sum)
+
+    require "set"
+    frequencies = Set.new
+    frequency = 0
+
+    loop do
+      change = CHANGES[frequencies.size % CHANGES.size]
+      frequencies << frequency
+      frequency += change
+
+      break if frequencies.include?(frequency)
+    end
+
+    solve!("The first frequency achieved twice is:", frequency)

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

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

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

@@ -0,0 +1,41 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    IDS = INPUT.split("\n")
+
+    twos = 0
+    threes = 0
+
+    IDS.each do |id|
+      letters = id.chars.uniq
+      twos += 1 if letters.any? { |l| id.count(l) == 2 }
+      threes += 1 if letters.any? { |l| id.count(l) == 3 }
+    end
+
+    solve!("The final checksum is:", twos * threes)
+
+    def match?(first, second)
+      matched_chars(first, second).size == first.size - 1
+    end
+
+    def matched_chars(first, second)
+      matches = []
+
+      first.chars.each_with_index do |c, i|
+        matches << c if c == second[i]
+      end
+
+      matches.join
+    end
+
+    in_common = IDS.detect.with_index do |first, i|
+      code = IDS.detect.with_index do |second, j|
+        next if i >= j
+        break matched_chars(first, second) if match?(first, second)
+      end
+
+      break code if code
+    end
+
+    solve!("The letters in common for the matching IDs are:", in_common)

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

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

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

@@ -0,0 +1,75 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require "set"
+
+    MATCHER = /\#(?<id>\d+) @ (?<x>\d+),(?<y>\d+): (?<width>\d+)x(?<height>\d+)/
+
+    Range.class_eval do
+      def overlaps?(other)
+        cover?(other.first) || other.cover?(first)
+      end
+
+      def intersection(other)
+        return nil if max < other.begin || other.max < self.begin
+
+        [self.begin, other.begin].max..[max, other.max].min
+      end
+      alias_method :&, :intersection
+    end
+
+    class Claim
+      attr_reader :id
+
+      def initialize(id:, x:, y:, width:, height:)
+        @id = id
+        @x = x
+        @y = y
+        @width = width
+        @height = height
+      end
+
+      def horizontal
+        @horizontal ||= @x..(@x + @width - 1)
+      end
+
+      def vertical
+        @vertical ||= @y..(@y + @height - 1)
+      end
+
+      def overlap_with(other)
+        return [] unless horizontal.overlaps?(other.horizontal) && vertical.overlaps?(other.vertical)
+
+        [*(horizontal & other.horizontal)].product([*(vertical & other.vertical)])
+      end
+    end
+
+    claims = INPUT.split("\n").map do |line|
+      matches = line.match(MATCHER)
+
+      Claim.new(
+        id: matches[:id],
+        x: matches[:x].to_i,
+        y: matches[:y].to_i,
+        width: matches[:width].to_i,
+        height: matches[:height].to_i
+      )
+    end
+
+    overlaps = Set.new
+    overlapping = Set.new
+
+    claims.combination(2) do |(first, second)|
+      overlap = first.overlap_with(second)
+      next unless overlap.any?
+
+      overlaps.merge(first.overlap_with(second))
+      overlapping << first
+      overlapping << second
+    end
+
+    solve!("The number of overlapping inches is:", overlaps.size)
+
+    claim = claims.detect { |c| !overlapping.include?(c) }
+    solve!("The only non-overlapping claim is:", claim.id)

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

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

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

@@ -0,0 +1,72 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /\A\[(?<year>\d+)-(?<month>\d+)-(?<date>\d+) (?<hour>\d+):(?<minute>\d+)\] (?<activity>.+)\z/
+    SHIFT_MATCHER = /Guard #(?<id>\d+) begins shift/
+
+    class Guard
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @status = Hash.new(0)
+        @sleep = nil
+      end
+
+      def sleep!(minute)
+        @start_time = minute
+      end
+
+      def wake!(minute)
+        (@start_time...minute).each do |i|
+          @status[i] += 1
+        end
+
+        @start_time = nil
+      end
+
+      def time_asleep
+        @status.values.sum
+      end
+
+      def likeliest_nap
+        @status.max_by { |(_, naps)| naps }.first
+      end
+
+      def max_naps
+        return 0 unless @status.any?
+
+        @status.values.max
+      end
+    end
+
+    LOG = INPUT.split("\n").sort_by do |l|
+      data = l.match(MATCHER)
+      [data[:year].to_i, data[:month].to_i, data[:date].to_i, data[:hour].to_i, data[:minute].to_i]
+    end
+
+    guards = {}
+    current_guard = nil
+
+    LOG.each do |line|
+      data = line.match(MATCHER)
+
+      case data[:activity]
+      when SHIFT_MATCHER
+        guards[$~[:id]] ||= Guard.new($~[:id].to_i)
+        current_guard = guards[$~[:id]]
+      when "falls asleep"
+        current_guard.sleep!(data[:minute].to_i)
+      when "wakes up"
+        current_guard.wake!(data[:minute].to_i)
+      end
+    end
+
+    most_likely = guards.values.max_by(&:time_asleep)
+    solve!("Guard ##{most_likely.id} naps most often, at minute #{most_likely.likeliest_nap}:",
+      most_likely.id * most_likely.likeliest_nap)
+
+    most_likely = guards.values.max_by(&:max_naps)
+    solve!("Guard ##{most_likely.id} naps most consistently, at minute #{most_likely.likeliest_nap}:",
+      most_likely.id * most_likely.likeliest_nap)

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

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

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

@@ -0,0 +1,21 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    OPPOSITE_INDICATOR = ("A".ord - "a".ord).abs
+
+    def opposite?(first, second)
+      (first - second).abs == OPPOSITE_INDICATOR
+    end
+
+    def reduce(polymer)
+      polymer.bytes.each_with_object([]) do |c, result|
+        (result.empty? || !opposite?(result.last, c)) ? result << c : result.pop
+      end.pack("c*")
+    end
+
+    polymer = reduce(INPUT)
+    solve!("The polymer size after reduction is:", polymer.size)
+
+    sizes = ("a".."z").map { |c| reduce(polymer.gsub(/#{c}/i, "")).size }
+    solve!("The minimum polymer size (with removal) is:", sizes.min)

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

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