advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,49 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require_relative "shared/wrist_device"
+
+    OPCODES = %i[addr addi mulr muli banr bani borr bori setr seti gtir gtri gtrr eqir eqri eqrr].freeze
+
+    SAMPLE_MATCHER = /Before: \[(?<input>.+)\]\n(?<command>.+)\nAfter:  \[(?<output>.+)\]/
+    SAMPLES = INPUT.scan(SAMPLE_MATCHER).map do |input, command, output|
+      {
+        command: command.split.map(&:to_i),
+        input: input.split(", ").map(&:to_i),
+        output: output.split.map(&:to_i)
+      }
+    end.freeze
+
+    device = WristDevice.new
+    behaviors = SAMPLES.each_with_object(Hash.new { |h, k| h[k] = [] }) do |sample, codes|
+      OPCODES.each do |opcode|
+        output = device.execute(sample[:input], opcode, *sample[:command].last(3))
+        codes[sample] << opcode if output == sample[:output]
+      end
+    end
+
+    solve!("The number of samples that behave like 3+ opcodes is:", behaviors.count { |_k, v| v.size >= 3 })
+
+    INSTRUCTION_MATCHER = /\n\n\n\n([0-9 \n]+)/
+    INSTRUCTIONS = INPUT.match(INSTRUCTION_MATCHER)[1].split("\n").map { |i| i.split.map(&:to_i) }.freeze
+    OPCODE_MAPPINGS = begin
+      mappings = {}
+
+      loop do
+        break mappings if OPCODES.all? { |code| mappings.key(code) }
+
+        behaviors.each { |sample, codes| mappings[sample[:command].first] ||= codes.first if codes.size == 1 }
+        behaviors.delete_if { |sample, _| mappings.key?(sample[:command].first) }
+        behaviors.each { |_, codes| mappings.each_value { |code| codes.delete(code) } }
+      end
+    end.freeze
+
+    device = WristDevice.new
+    registers = [0, 0, 0, 0]
+
+    INSTRUCTIONS.each do |instruction|
+      registers = device.execute(registers, OPCODE_MAPPINGS[instruction[0]], *instruction[1..])
+    end
+
+    solve!("The result of register 0 after running all instructions is:", registers[0])

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

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

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

@@ -0,0 +1,62 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /(?<static>x|y)=(?<point>\d+), (?<range>x|y)=(?<min>\d+)..(?<max>\d+)/
+    CLAY = INPUT.split("\n").each_with_object(Hash.new(false)) do |line, clay|
+      data = line.match(MATCHER)
+      (data[:min].to_i..data[:max].to_i).each do |i|
+        point = {data[:static].to_sym => data[:point].to_i, data[:range].to_sym => i}
+        clay[[point[:x], point[:y]]] = true
+      end
+    end
+
+    class Spring
+      RESTING = "~".freeze
+      FLOWING = "|".freeze
+
+      attr_reader :water
+
+      def initialize(clay)
+        @clay = clay
+        @miny, @maxy = clay.keys.map(&:last).minmax
+
+        @water = {}
+      end
+
+      def flow!(x, y = @miny)
+        @water[[x, y]] = FLOWING
+        return if @water[[x, y + 1]]
+
+        depth = y
+        depth += 1 until depth == @maxy || rests?(x, depth)
+
+        depth.downto(y) do |j|
+          @water[[x, j]] = FLOWING
+          fill!(x, j) if rests?(x, j)
+        end
+      end
+
+      def fill!(x, y)
+        left = x
+        right = x
+        left -= 1 until @clay[[left - 1, y]] || !rests?(left, y)
+        right += 1 until @clay[[right + 1, y]] || !rests?(right, y)
+
+        state = (rests?(left, y) && rests?(right, y)) ? RESTING : FLOWING
+        (left..right).each { |i| @water[[i, y]] = state }
+        [left, right].each { |i| flow!(i, y) unless rests?(i, y) }
+      end
+
+      private
+
+      def rests?(x, y)
+        @clay[[x, y + 1]] || @water[[x, y + 1]] == RESTING
+      end
+    end
+
+    spring = Spring.new(CLAY)
+    spring.flow!(500)
+
+    solve!("The water can reach the following number of spaces:", spring.water.count)
+    solve!("The water will rest in the following number of spaces:", spring.water.values.count(Spring::RESTING))

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

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

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

@@ -0,0 +1,61 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require "set"
+
+    COLLECTION_AREA = INPUT.split("\n").map(&:chars).freeze
+    SIZE = COLLECTION_AREA.size
+
+    NEIGHBORS = [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]].freeze
+    ACRES = {open: ".", forest: "|", lumberyard: "#"}.freeze
+    TRANSITIONS = {
+      ACRES[:open] => ->(n) { (n.count(ACRES[:forest]) >= 3) ? ACRES[:forest] : ACRES[:open] },
+      ACRES[:forest] => ->(n) { (n.count(ACRES[:lumberyard]) >= 3) ? ACRES[:lumberyard] : ACRES[:forest] },
+      ACRES[:lumberyard] => lambda do |n|
+        (n.count(ACRES[:forest]) > 0 && n.count(ACRES[:lumberyard]) > 0) ? ACRES[:lumberyard] : ACRES[:open]
+      end
+    }.freeze
+
+    def next_state(area)
+      new_area = Array.new(SIZE) { Array.new(SIZE) }
+
+      area.each_with_index do |row, y|
+        row.each_with_index do |acre, x|
+          neighbors = NEIGHBORS.map do |dx, dy|
+            next if x + dx >= SIZE || x + dx < 0
+            next if y + dy >= SIZE || y + dy < 0
+
+            area[y + dy][x + dx]
+          end.compact
+
+          new_area[y][x] = TRANSITIONS[acre].call(neighbors)
+        end
+      end
+
+      new_area
+    end
+
+    def iterate(area, minutes)
+      seen = []
+
+      minutes.times do |_i|
+        area = next_state(area)
+        seen.include?(area) ? break : seen << area
+      end
+
+      starts_at = seen.index(area)
+      looped = seen[starts_at..]
+      looped[(minutes - starts_at - 1) % looped.size]
+    end
+
+    def resource_value(area)
+      tiles = area.flatten
+      tiles.count(ACRES[:forest]) * tiles.count(ACRES[:lumberyard])
+    end
+
+    area = iterate(COLLECTION_AREA, 10)
+    solve!("The resource value after 10 minutes is:", resource_value(area))
+
+    area = iterate(COLLECTION_AREA, 1_000_000_000)
+    solve!("The resource value after 1B minutes is:", resource_value(area))

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

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

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

@@ -0,0 +1,55 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require_relative "shared/wrist_device"
+    require "prime"
+
+    ip, instructions = INPUT.split("\n").partition.with_index { |_, i| i == 0 }
+
+    POINTER = ip.first.match(/\#ip (?<ip>\d+)/)[:ip].to_i
+    INSTRUCTIONS = instructions.map do |line|
+      line = line.split
+      [line.shift.to_sym, *line.map(&:to_i)]
+    end
+
+    device = WristDevice.new(POINTER, [0, 0, 0, 0, 0, 0])
+    registers = device.run(INSTRUCTIONS)
+
+    solve!("The value of register 0 is:", registers[0])
+
+    # NOTE: Part 2 of this puzzle takes an unrealistically long amount of time to
+    # run, so a reasonable solution requires analyzing the code in the input to
+    # determine what it's actually doing. The instructions boil down to "sum the
+    # factors of N", where N is some arbitrary large number. I've left the
+    # calculation for N semi-dynamic, so it will hopefully work for other inputs,
+    # based on the assumption that every input shares the same general structure.
+    def total_for(registers)
+      device = WristDevice.new(POINTER, registers)
+      jump_to = INSTRUCTIONS.first[2]
+      registers[POINTER] = jump_to + 1
+
+      loop do
+        pointer = registers[POINTER]
+        break if pointer < jump_to
+
+        registers = device.execute(registers, *INSTRUCTIONS[pointer])
+        registers[POINTER] += 1
+      end
+
+      registers.max
+    end
+
+    def factors_of(number)
+      primes, powers = number.prime_division.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 run!(registers)
+      factors_of(total_for(registers)).sum
+    end
+
+    solve!("The value of register 0 (starting at 1) is:", run!([1, 0, 0, 0, 0, 0]))

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

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

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

@@ -0,0 +1,88 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require "set"
+
+    class Room
+      attr_accessor :neighbors
+      attr_reader :position
+
+      def initialize(position)
+        @position = position
+        @neighbors = []
+      end
+
+      def move(vector)
+        @position.zip(vector).map(&:sum)
+      end
+    end
+
+    class Base
+      DIRECTIONS = {
+        "N" => [0, -1],
+        "E" => [1, 0],
+        "S" => [0, 1],
+        "W" => [-1, 0]
+      }.freeze
+
+      attr_accessor :rooms
+
+      def initialize
+        @rooms = {}
+      end
+
+      def [](position)
+        @rooms[position]
+      end
+
+      def add_room(position)
+        @rooms[position] ||= Room.new(position)
+      end
+
+      def add_door(room, direction)
+        next_room = add_room(room.move(DIRECTIONS[direction]))
+        room.neighbors << next_room
+        next_room.neighbors << room
+
+        next_room
+      end
+
+      def explore_from(room)
+        explored = {room => 0}
+        queue = [[room, 0]]
+
+        loop do
+          break if queue.empty?
+
+          room, steps = queue.shift
+          room.neighbors.each do |neighbor|
+            next if explored.key?(neighbor) && explored[neighbor] <= steps + 1
+
+            explored[neighbor] = steps + 1
+            queue << [neighbor, steps + 1]
+          end
+        end
+
+        explored
+      end
+    end
+
+    base = Base.new
+    origin = base.add_room([0, 0])
+    current = origin
+    branches = []
+
+    INPUT.chars.each do |step|
+      case step
+      when "N", "E", "S", "W" then current = base.add_door(current, step)
+      when "(" then branches << current
+      when "|" then current = branches.last
+      when ")" then current = branches.pop
+      end
+    end
+
+    distances = base.explore_from(origin)
+
+    solve!("The shortest path to the furthest room is:", distances.values.max)
+    solve!("The number of rooms 1000 steps or more away is:", distances.values.count { |i| i >= 1000 })

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

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

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

@@ -0,0 +1,56 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    require_relative "shared/wrist_device"
+    require "set"
+
+    ip, instructions = INPUT.split("\n").partition.with_index { |_, i| i == 0 }
+
+    POINTER = ip.first.match(/\#ip (?<ip>\d+)/)[:ip].to_i
+    INSTRUCTIONS = instructions.map do |line|
+      line = line.split
+      [line.shift.to_sym, *line.map(&:to_i)]
+    end
+
+    # The instructions only perform a check against register 0 at one specific
+    # point, comparing it to the contents of a different register.
+    COMPARISON_LINE = INSTRUCTIONS.index { |i| i[0] == :eqrr && i[2] == 0 }
+    COMPARISON_POINTER = INSTRUCTIONS[COMPARISON_LINE][1]
+
+    device = WristDevice.new(POINTER, [0, 0, 0, 0, 0, 0])
+    value = device.run(INSTRUCTIONS) do |registers|
+      break registers[COMPARISON_POINTER] if registers[POINTER] == COMPARISON_LINE
+    end
+
+    solve!("The earliest halting value for register 0 is:", value)
+
+    # We can avoid a bunch of extraneous looping by overriding a few separate sets
+    # of instructions to condense each inner loop pass down to one or two
+    # operations (from several hundred).
+    MASK_LINE = INSTRUCTIONS.index { |i| i[0] == :bani && i[2] == 255 }
+    MASK_POINTER = INSTRUCTIONS[MASK_LINE][1]
+    RESET_LINE = INSTRUCTIONS.index { |i| i[0] == :setr && i[3] == MASK_POINTER }
+    RESET_POINTER = INSTRUCTIONS[MASK_LINE][3]
+
+    LOOP_POINTER = INSTRUCTIONS.detect { |i| i[0] == :muli && i[2] == 256 }[3]
+    LOOP_LINE = INSTRUCTIONS.index { |i| i[0] == :addr && i[1] == LOOP_POINTER && i[3] == POINTER }
+
+    seen = Set.new
+    last = nil
+
+    value = device.run(INSTRUCTIONS) do |registers|
+      case registers[POINTER]
+      when COMPARISON_LINE
+        break last if seen.include?(registers[COMPARISON_POINTER])
+
+        last = registers[COMPARISON_POINTER]
+        seen << last
+      when RESET_LINE
+        registers[RESET_POINTER] = registers[MASK_POINTER] / 256
+      when LOOP_LINE
+        registers[LOOP_POINTER] = 1
+      end
+    end
+
+    solve!("The last unique halting value for register 0 is:", value)

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

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

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

@@ -0,0 +1,110 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    MATCHER = /depth: (?<depth>\d+)\ntarget: (?<x>\d+),(?<y>\d+)/
+
+    class Cave
+      EROSION_MOD = 20_183
+      X_MULTIPLIER = 16_807
+      Y_MULTIPLIER = 48_271
+
+      def initialize(depth, target)
+        @depth = depth
+        @target = target
+
+        @geologic_indices = {}
+        @erosion_levels = {}
+        @risk_levels = {}
+      end
+
+      def geologic_index(region)
+        @geologic_indices[region] ||=
+          if [[0, 0], @target].include?(region)
+            0
+          elsif region[1] == 0
+            region[0] * X_MULTIPLIER
+          elsif region[0] == 0
+            region[1] * Y_MULTIPLIER
+          else
+            erosion_level([region[0] - 1, region[1]]) *
+              erosion_level([region[0], region[1] - 1])
+          end
+      end
+
+      def erosion_level(region)
+        @erosion_levels[region] ||= (geologic_index(region) + @depth) % EROSION_MOD
+      end
+
+      def risk_level(region)
+        @risk_levels[region] ||= erosion_level(region) % 3
+      end
+    end
+
+    data = INPUT.match(MATCHER)
+    TARGET = [data[:x].to_i, data[:y].to_i].freeze
+    CAVE = Cave.new(data[:depth].to_i, TARGET)
+
+    total_risk = (0..data[:y].to_i).sum do |y|
+      (0..data[:x].to_i).sum { |x| CAVE.risk_level([x, y]) }
+    end
+
+    solve!("The total risk level of the rectangle from 0,0 to the target is:", total_risk)
+
+    class PriorityQueue
+      def initialize
+        @list = []
+      end
+
+      def add(*item)
+        @list << item
+        @list.sort_by!(&:first)
+      end
+
+      def next
+        @list.shift
+      end
+
+      def empty?
+        @list.empty?
+      end
+    end
+
+    EQUIPMENT = {
+      neither: 0,
+      torch: 1,
+      gear: 2
+    }.freeze
+
+    queue = PriorityQueue.new
+    queue.add(0, 0, 0, EQUIPMENT[:torch])
+    times = Hash.new(Float::INFINITY)
+
+    time = loop do
+      break nil if queue.empty?
+
+      minutes, x, y, equip = queue.next
+      next if times[[x, y, equip]] <= minutes
+      break minutes if [x, y, equip] == [*TARGET, EQUIPMENT[:torch]]
+
+      times[[x, y, equip]] = minutes
+
+      EQUIPMENT.each_value do |e|
+        next if e == equip || e == CAVE.risk_level([x, y])
+        next if times[[x, y, e]] <= minutes + 7
+
+        queue.add(minutes + 7, x, y, e)
+      end
+
+      [[-1, 0], [1, 0], [0, -1], [0, 1]].each do |dx, dy|
+        nx = x + dx
+        ny = y + dy
+        next if nx < 0 || nx > TARGET[0] * 4 || ny < 0 || ny > TARGET[1] * 4
+        next if CAVE.risk_level([nx, ny]) == equip
+        next if times[[nx, ny, equip]] <= minutes + 1
+
+        queue.add(minutes + 1, nx, ny, equip)
+      end
+    end
+
+    solve!("The minimal time to find our friend is:", time)

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

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

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

@@ -0,0 +1,80 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2018
+  :solution: |-
+    class Nanobot
+      attr_reader :x, :y, :z, :range
+
+      def initialize(x, y, z, range)
+        @x = x
+        @y = y
+        @z = z
+        @range = range
+      end
+
+      def position
+        [x, y, z]
+      end
+
+      def reaches?(position)
+        (x - position[0]).abs + (y - position[1]).abs + (z - position[2]).abs <= range
+      end
+    end
+
+    MATCHER = /pos=<(?<x>-?\d+),(?<y>-?\d+),(?<z>-?\d+)>, r=(?<range>\d+)/
+    NANOBOTS = INPUT.split("\n").map do |line|
+      data = line.match(MATCHER)
+      Nanobot.new(
+        data[:x].to_i,
+        data[:y].to_i,
+        data[:z].to_i,
+        data[:range].to_i
+      )
+    end
+
+    signal = NANOBOTS.max_by(&:range)
+    solve!("The strongest signal reaches N nanobots:", NANOBOTS.count { |n| signal.reaches?(n.position) })
+
+    def distance_to(x, y, z)
+      x.abs + y.abs + z.abs
+    end
+
+    # We can figure out the general area by downsampling, picking an optimal block,
+    # then zooming in on that block and refining the search area further.
+    RESOLUTION = 2
+    downsample = RESOLUTION
+    downsample *= RESOLUTION until downsample > signal.range
+
+    ranges = [
+      NANOBOTS.map { |n| n.x / downsample }.minmax,
+      NANOBOTS.map { |n| n.y / downsample }.minmax,
+      NANOBOTS.map { |n| n.z / downsample }.minmax
+    ]
+
+    distance = loop do
+      downsampled = NANOBOTS.map { |n| [n.x / downsample, n.y / downsample, n.z / downsample, n.range / downsample] }
+
+      position = [0, 0, 0]
+      best = 0
+
+      (ranges[0][0]..ranges[0][1]).each do |x|
+        (ranges[1][0]..ranges[1][1]).each do |y|
+          (ranges[2][0]..ranges[2][1]).each do |z|
+            count = downsampled.count { |d| distance_to(d[0] - x, d[1] - y, d[2] - z) <= d[3] }
+
+            next if count < best
+            next if count == best && distance_to(x, y, z) > distance_to(*position)
+
+            position = [x, y, z]
+            best = count
+          end
+        end
+      end
+
+      break distance_to(*position) if downsample == 1
+
+      downsample /= RESOLUTION
+      ranges = position.map { |i| [(i - 1) * RESOLUTION, (i + 1) * RESOLUTION] }
+    end
+
+    solve!("The distance from 0,0 to the optimal teleport location is:", distance)

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

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