advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,57 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Node
+      def initialize
+        @sources = {}
+      end
+
+      def give(value)
+        assign(nil, value)
+      end
+
+      def assign(source, method)
+        @sources[source] ||= []
+        @sources[source] << method
+      end
+
+      def values
+        @values ||= @sources.flat_map do |source, methods|
+          methods.map { |method| source ? source.send(method) : method }
+        end.sort
+      end
+
+      def low
+        values.first
+      end
+
+      def high
+        values.last
+      end
+    end
+
+    GRANT_PATTERN = /value (?<value>\d+) goes to (?<bot>bot \d+)/
+    ASSIGN_PATTERN = /(?<bot>bot \d+) gives low to (?<low_output>.+ \d+) and high to (?<high_output>.+ \d+)/
+    TARGET_VALUES ||= [17, 61].freeze
+    TARGET_NODES = ["output 0", "output 1", "output 2"].freeze
+
+    nodes = Hash.new { |h, k| h[k] = Node.new }
+
+    INPUT.split("\n").each do |line|
+      case line
+      when GRANT_PATTERN
+        matches = line.match(GRANT_PATTERN)
+        nodes[matches[:bot]].give(matches[:value].to_i)
+      when ASSIGN_PATTERN
+        matches = line.match(ASSIGN_PATTERN)
+        nodes[matches[:low_output]].assign(nodes[matches[:bot]], :low)
+        nodes[matches[:high_output]].assign(nodes[matches[:bot]], :high)
+      end
+    end
+
+    bot = nodes.keys.find { |id| nodes[id].values == TARGET_VALUES }
+    solve!("The bot responsible for comparing #{TARGET_VALUES} is:", bot)
+
+    product = TARGET_NODES.map { |id| nodes[id].values.first }.inject(:*)
+    solve!("The product of chip numbers in #{TARGET_NODES} is:", product)

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

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

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

@@ -0,0 +1,120 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Item
+      attr_reader :element, :type
+
+      def initialize(element, type)
+        @element = element
+        @type = type
+      end
+
+      def chip?
+        type == :chip
+      end
+    end
+
+    class State
+      attr_reader :steps
+
+      def initialize(floorplan, floor = 0, steps = 0)
+        @floorplan = floorplan
+        @floor = floor
+        @steps = steps
+      end
+
+      def valid_moves
+        destinations = [@floor + 1, @floor - 1].select { |floor| floor >= 0 && floor < @floorplan.length }
+        transfers = [2, 1].flat_map { |load| @floorplan[@floor].combination(load).to_a }
+        destinations.flat_map do |floor|
+          transfers.map { |transfer| move_to(floor, transfer) }
+        end.compact.select(&:valid?)
+      end
+
+      def solved?
+        @floorplan[0].empty? && @floorplan[1].empty? && @floorplan[2].empty?
+      end
+
+      def valid?
+        @floorplan.all? do |items|
+          chips, generators = items.partition(&:chip?)
+          generators.empty? || (chips.map(&:element) - generators.map(&:element)).empty?
+        end
+      end
+
+      def key
+        [@floor, pair_layout]
+      end
+
+      private
+
+      def move_to(new_floor, take)
+        vacated = new_floor == @floorplan.index(&:any?) - 1
+        pair = take.map(&:element).uniq.length < take.length
+
+        return if new_floor < @floor && (vacated || pair)
+
+        floorplan = @floorplan.map.with_index do |items, floor|
+          case floor
+          when @floor then items - take
+          when new_floor then items + take
+          else items
+          end
+        end
+
+        State.new(floorplan, new_floor, @steps + 1)
+      end
+
+      def pair_layout
+        locations = Hash.new { |h, k| h[k] = {generator: nil, chip: nil} }
+
+        @floorplan.each_with_index do |items, floor|
+          items.each { |item| locations[item.element][item.type] = floor }
+        end
+
+        locations.values.map(&:values).sort
+      end
+    end
+
+    def steps(floorplan)
+      @queue = [State.new(floorplan)]
+      @cache = {}
+
+      loop do
+        @queue.shift.valid_moves.each do |move|
+          return move.steps if move.solved?
+          next if @cache.key?(move.key)
+
+          @cache[move.key] = true
+          @queue << move
+        end
+        break if @queue.empty?
+      end
+    end
+
+    FLOOR_MATCHER = /\AThe (?<floor>.+) floor contains (?<contents>.+)\.\z/
+    CHIP_MATCHER = /a (?<element>\w+)-compatible microchip/
+    GENERATOR_MATCHER = /a (?<element>\w+) generator/
+
+    floorplan = INPUT.split("\n").map do |line|
+      floor = line.match(FLOOR_MATCHER)
+
+      items = []
+      floor[:contents].scan(CHIP_MATCHER) { items << Item.new($~[:element], :chip) }
+      floor[:contents].scan(GENERATOR_MATCHER) { items << Item.new($~[:element], :generator) }
+
+      items
+    end
+
+    solve!("You can transport all equipment to the top floor in:", steps(floorplan))
+
+    new_items = [
+      Item.new("elerium", :generator),
+      Item.new("elerium", :chip),
+      Item.new("dilithium", :generator),
+      Item.new("dilithium", :chip)
+    ]
+
+    new_floorplan = [floorplan[0] + new_items, *floorplan[1..]]
+    solve!("You can transport the updated equipment list to the top floor in:", steps(new_floorplan))

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

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

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

@@ -0,0 +1,17 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require_relative "shared/assembunny"
+
+    registers = Hash.new(0)
+    computer = Assembunny.new(registers)
+    computer.run(INSTRUCTIONS)
+
+    solve!("Register 'a' contains:", computer.registers["a"])
+
+    registers = Hash.new(0).tap { |h| h["c"] = 1 }
+    computer = Assembunny.new(registers)
+    computer.run(INSTRUCTIONS)
+
+    solve!("After setting register 'c' to 1, register 'a' contains:", computer.registers["a"])

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

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

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

@@ -0,0 +1,105 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Maze
+      def initialize(magic_number)
+        @magic_number = magic_number
+      end
+
+      def wall?((x, y))
+        sum = (x * x) + (3 * x) + (2 * x * y) + y + (y * y)
+        (sum + @magic_number).to_s(2).scan("1").size.odd?
+      end
+
+      def adjacent_spots((x, y))
+        [
+          [x + 1, y],
+          ([x - 1, y] if x - 1 >= 0),
+          [x, y + 1],
+          ([x, y - 1] if y - 1 >= 0)
+        ].compact.reject { |spot| wall?(spot) }
+      end
+    end
+
+    # Apologies to http://branch14.org/snippets/a_star_in_ruby.html
+    class PriorityQueue
+      def initialize
+        @list = []
+      end
+
+      def add(priority, item)
+        @list << [priority, @list.length, item]
+        @list.sort!
+      end
+
+      def next
+        @list.shift[2]
+      end
+
+      def empty?
+        @list.empty?
+      end
+    end
+
+    class Pathfinder
+      def initialize(maze)
+        @maze = maze
+      end
+
+      def path(start, target)
+        estimator = proc { |(x, y)| (target[0] - x).abs + (target[1] - y).abs }
+        traverse(start, estimator: estimator) { |spot, path| return path if spot == target }
+      end
+
+      def reachable(start, maximum_steps)
+        spots = []
+        traverse(start, maximum_steps: maximum_steps) { |spot| spots << spot }
+
+        spots
+      end
+
+      private
+
+      def traverse(start, estimator: proc { 0 }, maximum_steps: 10_000)
+        found = {}
+        queue = PriorityQueue.new
+        queue.add(1, [start, [], 0])
+
+        loop do
+          break if queue.empty?
+
+          spot, path, steps = queue.next
+          next if found[spot]
+          next if steps > maximum_steps
+
+          yield spot, path
+
+          found[spot] = true
+          @maze.adjacent_spots(spot).each do |new_spot|
+            next if found[new_spot]
+
+            new_steps = steps + 1
+
+            queue.add(
+              new_steps + estimator.call(new_spot),
+              [new_spot, [*path, new_spot], new_steps]
+            )
+          end
+        end
+      end
+    end
+
+    NUMBER = INPUT.to_i
+    START = [1, 1].freeze
+    TARGET ||= [31, 39].freeze
+    MAXIMUM_STEPS = 50
+
+    maze = Maze.new(NUMBER)
+    pathfinder = Pathfinder.new(maze)
+
+    path = pathfinder.path(START, TARGET)
+    solve!("The minimal path length from #{START} to #{TARGET} is:", path.length)
+
+    nodes = pathfinder.reachable(START, MAXIMUM_STEPS)
+    solve!("The number of spots reachable within #{MAXIMUM_STEPS} steps is:", nodes.length)

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

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

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

@@ -0,0 +1,55 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require "digest"
+
+    class ScratchPad
+      TRIPLE_MATCHER = /(\w)\1\1/
+
+      def initialize(salt, stretch = 0)
+        @salt = salt
+        @stretch = stretch
+        @generated = {}
+      end
+
+      def index(count)
+        indices(count).last
+      end
+
+      def indices(count)
+        i = 0
+        found = []
+
+        loop do
+          found << i if valid?(i)
+          i += 1
+          break unless found.length < count
+        end
+
+        found
+      end
+
+      def valid?(value)
+        matches = generate(value).match(TRIPLE_MATCHER)
+        return false unless matches
+
+        matcher = Regexp.new((matches[1]).to_s * 5)
+        (1..1000).any? { |i| generate(value + i) =~ matcher }
+      end
+
+      private
+
+      def generate(value)
+        @generated[value] ||= begin
+          digest = Digest::MD5.hexdigest("#{@salt}#{value}")
+          @stretch.times { digest = Digest::MD5.hexdigest(digest) }
+          digest
+        end
+      end
+    end
+
+    SALT = INPUT
+
+    solve!("The index of the 64th scratch pad value is:", ScratchPad.new(SALT).index(64))
+    solve!("The index of the 64th scratch pad value (with stretching) is:", ScratchPad.new(SALT, 2016).index(64))

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

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

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

@@ -0,0 +1,45 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    # rubocop:disable Layout/LineLength
+    DISC_MATCHER = /Disc #\d+ has (?<position_count>\d+) positions; at time=0, it is at position (?<starting_position>\d+)\./
+    # rubocop:enable Layout/LineLength
+
+    class Disc
+      def initialize(positions, starts_at)
+        @positions = positions
+        @starts_at = starts_at
+      end
+
+      def passable_at?(ticks)
+        (@starts_at + ticks) % @positions == 0
+      end
+    end
+
+    def valid_time(discs)
+      valid = false
+      time = 0
+
+      loop do
+        valid = true
+        time += 1
+
+        discs.each.with_index(1) do |disc, delay|
+          break valid = false unless disc.passable_at?(time + delay)
+        end
+        break if valid
+      end
+
+      time
+    end
+
+    discs = INPUT.split("\n").map do |line|
+      matches = line.match(DISC_MATCHER)
+      Disc.new(matches[:position_count].to_i, matches[:starting_position].to_i)
+    end
+
+    solve!("The first valid drop time is:", valid_time(discs))
+
+    discs << Disc.new(11, 0)
+    solve!("The first valid drop time (with the extra disc) is:", valid_time(discs))

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    def transform(original)
+      modified = original.reverse.gsub(/(0|1)/, "0" => "1", "1" => "0")
+      "#{original}0#{modified}"
+    end
+
+    def checksum(string)
+      hash = ""
+      string.chars.each_slice(2) do |(x, y)|
+        hash << ((x == y) ? "1" : "0")
+      end
+
+      hash.length.even? ? checksum(hash) : hash
+    end
+
+    def checksum_for(length)
+      output = transform(INPUT)
+      output = transform(output) while output.length < length
+
+      checksum(output[0...length])
+    end
+
+    DISK_LENGTH ||= 272
+    solve!("The checksum for length 272 is:", checksum_for(DISK_LENGTH))
+    solve!("The checksum for length 35651584 is:", checksum_for(35_651_584))

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

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

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

@@ -0,0 +1,125 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require "digest"
+
+    class Maze
+      OPEN_MATCHER = /[b-f]/
+
+      def initialize(width = 4, height = 4)
+        @grid = {}
+        @width = width
+        @height = height
+      end
+
+      def adjacent_spots((x, y, _), string)
+        [
+          [x, y - 1, :U],
+          [x, y + 1, :D],
+          [x - 1, y, :L],
+          [x + 1, y, :R]
+        ].select do |(i, j, direction)|
+          open?(string, direction) &&
+            i >= 0 && i < @width &&
+            j >= 0 && j < @height
+        end
+      end
+
+      def open?(string, direction)
+        @grid[string] ||= begin
+          digest = Digest::MD5.hexdigest(string)
+
+          {
+            U: digest[0] =~ OPEN_MATCHER,
+            D: digest[1] =~ OPEN_MATCHER,
+            L: digest[2] =~ OPEN_MATCHER,
+            R: digest[3] =~ OPEN_MATCHER
+          }
+        end
+
+        @grid[string][direction]
+      end
+    end
+
+    # Apologies to http://branch14.org/snippets/a_star_in_ruby.html
+    class PriorityQueue
+      def initialize
+        @list = []
+      end
+
+      def add(priority, item)
+        @list << [priority, @list.length, item]
+        @list.sort!
+      end
+
+      def next
+        @list.shift[2]
+      end
+
+      def empty?
+        @list.empty?
+      end
+    end
+
+    class Pathfinder
+      def initialize(maze)
+        @maze = maze
+      end
+
+      def min_path(start, target)
+        min = traverse(start, target) { |path| break path }
+        path_string(min).delete(start.last)
+      end
+
+      def max_path(start, target)
+        max = nil
+
+        traverse(start, target) do |path|
+          max = [max, path].compact.max_by(&:length)
+        end
+
+        path_string(max).delete(start.last)
+      end
+
+      private
+
+      def path_string(path)
+        path.map(&:last).join
+      end
+
+      def traverse(start, target, maximum_steps: 1_000)
+        queue = PriorityQueue.new
+        queue.add(1, [start, [start], 0])
+
+        until queue.empty?
+          spot, path, steps = queue.next
+          if target == [spot[0], spot[1]]
+            yield path
+            next
+          end
+
+          @maze.adjacent_spots(spot, path_string(path)).each do |new_spot|
+            new_steps = steps + 1
+            next if new_steps > maximum_steps
+
+            queue.add(
+              new_steps,
+              [new_spot, [*path, new_spot], new_steps]
+            )
+          end
+        end
+      end
+    end
+
+    START = [0, 0].freeze
+    TARGET = [3, 3].freeze
+
+    maze = Maze.new
+    pathfinder = Pathfinder.new(maze)
+
+    min_path = pathfinder.min_path([*START, INPUT], TARGET)
+    solve!("The minimum path is:", min_path)
+
+    max_path = pathfinder.max_path([*START, INPUT], TARGET)
+    solve!("The maximum path length is:", max_path.length)

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

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

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

@@ -0,0 +1,60 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Row
+      TRAP_SETUPS = [
+        [true, false, false],
+        [true, true, false],
+        [false, true, true],
+        [false, false, true]
+      ].freeze
+
+      def initialize
+        @traps = []
+      end
+
+      def <<(trap)
+        @traps << trap
+      end
+
+      def next
+        new_row = Row.new
+
+        new_row << trapped?([false, @traps[0], @traps[1]])
+        @traps.each_cons(3) { |tiles| new_row << trapped?(tiles) }
+        new_row << trapped?([@traps[-2], @traps[-1], false])
+
+        new_row
+      end
+
+      def trapped?(tiles)
+        TRAP_SETUPS.include?(tiles)
+      end
+
+      def safe_tiles
+        @traps.count(&:!)
+      end
+
+      def to_s
+        @traps.map { |trap| trap ? "^" : "." }.join
+      end
+    end
+
+    def grid_for(input, size)
+      first_row = Row.new
+      input.chars.each { |char| first_row << (char == "^") }
+
+      current_row = first_row
+      grid = (size - 1).times.map { current_row = current_row.next }
+      grid.unshift(first_row)
+
+      grid
+    end
+
+    ROW_COUNT ||= 40
+    grid = grid_for(INPUT, ROW_COUNT)
+    solve!("The number of safe tiles in 40 rows is:", grid.sum(&:safe_tiles))
+
+    grid = grid_for(INPUT, 400_000)
+    solve!("The number of safe tiles in 400,000 rows is:", grid.sum(&:safe_tiles))

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

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