advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,31 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    LIST = INPUT.split("\n").map(&:to_i)
+
+    def steps(list)
+      cursor = 0
+      count = 0
+
+      while cursor >= 0 && cursor < list.length
+        current = cursor
+        count += 1
+        cursor += list[cursor]
+        yield list, current
+      end
+
+      count
+    end
+
+    count = steps(LIST.dup) do |list, index|
+      list[index] += 1
+    end
+
+    solve!("The number of steps to escape is:", count)
+
+    count = steps(LIST.dup) do |list, index|
+      list[index] += (list[index] >= 3) ? -1 : 1
+    end
+
+    solve!("The number of steps to escape (with decrementing) is:", count)

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    BLOCKS = INPUT.split(/\s+/).map(&:to_i)
+
+    blocks = BLOCKS.dup
+    seen_states = {}
+    count = 0
+
+    until seen_states.key?(blocks)
+      seen_states[blocks.dup] = count
+
+      cursor = blocks.index(blocks.max)
+      remaining = blocks[cursor]
+      blocks[cursor] = 0
+
+      while remaining > 0
+        cursor += 1
+        remaining -= 1
+        blocks[cursor % blocks.length] += 1
+      end
+
+      count += 1
+    end
+
+    solve!("The number of cycles required to find an optimal balance is:", count)
+    solve!("The number of cycles between optimal states is:", count - seen_states[blocks])

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

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

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

@@ -0,0 +1,64 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Program
+      attr_accessor :name, :weight, :children, :subprograms
+
+      def initialize(name, weight, children = [])
+        @name = name
+        @weight = weight
+        @children = children
+        @subprograms = []
+      end
+
+      def total_weight
+        @total_weight ||= @weight + @subprograms.inject(0) { |sum, s| sum + s.total_weight }
+      end
+
+      def corrected_weight
+        weights = @subprograms.map(&:total_weight)
+        outlier = weights.detect { |w| weights.count(w) == 1 }
+        return if outlier.nil?
+
+        faulty = @subprograms[weights.index(outlier)]
+        weight = faulty.corrected_weight
+        return weight if weight
+
+        proper_weight = (weights - [outlier]).first
+        weight_difference = outlier - proper_weight
+        faulty.weight - weight_difference
+      end
+    end
+
+    # rubocop:disable Lint/MixedRegexpCaptureTypes
+    PROGRAM_MATCHER = /(?<name>\w+) \((?<weight>\d+)\)( -> (?<children>.+))?/
+    # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+    def stack(input)
+      programs = {}
+
+      input.split("\n").each do |row|
+        match = row.match(PROGRAM_MATCHER)
+        programs[match[:name]] = Program.new(
+          match[:name],
+          match[:weight].to_i,
+          match[:children]&.split(", ") || []
+        )
+      end
+
+      names = programs.keys
+      programs.each_value do |program|
+        program.children.each do |child|
+          names.delete(child)
+          program.subprograms << programs[child]
+        end
+      end
+
+      programs[names.first]
+    end
+
+    root = stack(INPUT)
+
+    solve!("The root program is:", root.name)
+    solve!("The expected weight for the faulty program is:", root.corrected_weight)

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

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

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

@@ -0,0 +1,27 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    registers = Hash.new { |h, k| h[k] = 0 }
+    maximum = 0
+
+    # rubocop:disable Layout/LineLength
+    LINE_PARSER = /(?<register>\w+) (?<instruction>.+) (?<value>-?\d+) if (?<cregister>\w+) (?<comparison>.+) (?<cvalue>-?\d+)/
+    # rubocop:enable Layout/LineLength
+
+    INPUT.split("\n").each do |row|
+      match = row.match(LINE_PARSER)
+      next unless registers[match[:cregister]].send(match[:comparison], match[:cvalue].to_i)
+
+      case match[:instruction]
+      when "inc"
+        registers[match[:register]] += match[:value].to_i
+      when "dec"
+        registers[match[:register]] -= match[:value].to_i
+      end
+
+      maximum = [maximum, registers[match[:register]]].max
+    end
+
+    solve!("The highest value in a register after runtime is:", registers.values.max)
+    solve!("The highest value ever held in a register was:", maximum)

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

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

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

@@ -0,0 +1,42 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    STREAM = INPUT.chars
+
+    group_score = 0
+    garbage_score = 0
+
+    open_groups = 0
+    garbage = false
+    ignore = false
+
+    STREAM.each do |c|
+      if garbage && ignore
+        ignore = false
+        next
+      end
+
+      garbage_score += 1 if garbage && !%w[> !].include?(c)
+
+      case c
+      when "<"
+        garbage = true
+      when ">"
+        garbage = false
+      when "!"
+        ignore = true if garbage
+      when "{"
+        next if garbage
+
+        open_groups += 1
+        group_score += open_groups
+      when "}"
+        next if garbage
+
+        open_groups -= 1 if open_groups > 0
+      end
+    end
+
+    solve!("The number of points from groups is:", group_score)
+    solve!("The number of garbage characters is:", garbage_score)

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

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

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

@@ -0,0 +1,34 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    LIST_SIZE ||= 256
+
+    def tie_knot(lengths, rounds = 1)
+      list = (0...LIST_SIZE).to_a
+      skip = 0
+      rotations = 0
+
+      rounds.times do
+        lengths.each do |length|
+          list[0...length] = list[0...length].reverse
+
+          list = list.rotate(length + skip)
+          rotations += length + skip
+          skip += 1
+        end
+      end
+
+      list.rotate(-rotations)
+    end
+
+    result = tie_knot(INPUT.split(",").map(&:to_i))
+    knot_value = result[0] * result[1]
+
+    solve!("The check value of the knot is:", knot_value)
+
+    MAGIC_NUMBERS = [17, 31, 73, 47, 23].freeze
+    result = tie_knot(INPUT.bytes + MAGIC_NUMBERS, 64)
+    knot_hash = result.each_slice(16).map { |block| format("%02x", block.inject(:^)) }.join
+
+    solve!("The Knot Hash for the input is:", knot_hash)

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

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

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

@@ -0,0 +1,31 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    MOVEMENTS = INPUT.split(",")
+    VECTORS = {
+      "n" => [0, 1, -1],
+      "ne" => [1, 0, -1],
+      "se" => [1, -1, 0],
+      "s" => [0, -1, 1],
+      "sw" => [-1, 0, 1],
+      "nw" => [-1, 1, 0]
+    }.freeze
+
+    def distance(x, y, z)
+      (x.abs + y.abs + z.abs) / 2
+    end
+
+    x = 0
+    y = 0
+    z = 0
+    max = 0
+
+    MOVEMENTS.each do |movement|
+      motion = VECTORS[movement]
+      x, y, z = [x, y, z].zip(motion).map { |c1, c2| c1 + c2 }
+      max = [max, distance(x, y, z)].max
+    end
+
+    solve!("The distance to the child's final tile is:", distance(x, y, z))
+    solve!("The furthest distance at any point was:", max)

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

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

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

@@ -0,0 +1,39 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    programs = Hash.new { |h, k| h[k] = [] }
+
+    INPUT.split("\n").each do |row|
+      program, friends = row.split(" <-> ")
+      friends = friends.split(", ")
+
+      posse = ([program] + friends)
+      posse.each do |item|
+        programs[item] = programs[item].concat(posse).uniq
+      end
+    end
+
+    def group(programs, index, seen = [])
+      seen = seen.dup
+
+      friends = programs[index] - seen
+
+      # rubocop:disable Style/CombinableLoops
+      friends.each { |program| seen << program }
+      friends.each { |program| seen = group(programs, program, seen) }
+      # rubocop:enable Style/CombinableLoops
+
+      seen
+    end
+
+    solve!("The number of programs in 0's group is:", group(programs, "0").count)
+
+    groups = []
+
+    while programs.count > 0
+      groups << group(programs, programs.keys.first)
+      programs = programs.except(*groups.last)
+    end
+
+    solve!("The total number of groups is:", groups.count)

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

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

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

@@ -0,0 +1,50 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Firewall
+      def initialize(_input)
+        @layers = Hash.new(0)
+        INPUT.split("\n").each do |layer|
+          depth, range = layer.split(": ").map(&:to_i)
+          @layers[depth] = range
+        end
+      end
+
+      def traverse(delay = 0)
+        depth = 0
+        while depth <= max_depth
+          yield depth, @layers[depth] if scanned?(depth, depth + delay)
+          depth += 1
+        end
+
+        true
+      end
+
+      def scanned?(depth, time)
+        return false unless @layers.key?(depth)
+
+        time % ((@layers[depth] * 2) - 2) == 0
+      end
+
+      def max_depth
+        @max_depth ||= @layers.keys.max
+      end
+    end
+
+    firewall = Firewall.new(INPUT)
+
+    severity = 0
+    firewall.traverse { |depth, range| severity += depth * range }
+
+    solve!("The severity of traversing the firewall immediately is:", severity)
+
+    delay = 0
+
+    loop do
+      delay += 1
+      success = firewall.traverse(delay) { break false }
+      break if success
+    end
+
+    solve!("The minimum delay to traverse the firewall undetected is:", delay)

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class KnotHash
+      MAGIC_NUMBERS = [17, 31, 73, 47, 23].freeze
+
+      def initialize(input)
+        @lengths = input.bytes + MAGIC_NUMBERS
+      end
+
+      def hash
+        tie_knot(64).each_slice(16).map do |block|
+          format("%02x", block.inject(:^))
+        end.join
+      end
+
+      private
+
+      def tie_knot(rounds = 1)
+        list = (0..255).to_a
+        skip = 0
+        rotations = 0
+
+        rounds.times do
+          @lengths.each do |length|
+            list[0...length] = list[0...length].reverse
+
+            list = list.rotate(length + skip)
+            rotations += length + skip
+            skip += 1
+          end
+        end
+
+        list.rotate(-rotations)
+      end
+    end
+
+    GRID_SIZE = 128
+
+    def hash_row(row)
+      KnotHash.new("#{INPUT}-#{row}").hash.hex.to_s(2).rjust(GRID_SIZE, "0").chars
+    end
+
+    MAP = (0...GRID_SIZE).each_with_object({}) do |i, grid|
+      hash_row(i).each_with_index { |c, j| grid[[i, j]] = c }
+    end.freeze
+
+    used = MAP.values.count("1")
+    solve!("The number of used squares is:", used)
+
+    def group_members(x, y, members = [])
+      [
+        [x, y + 1],
+        [x + 1, y],
+        [x, y - 1],
+        [x - 1, y]
+      ].each do |i, j|
+        next unless MAP[[i, j]] == "1"
+        next if members.include?([i, j])
+
+        members = group_members(i, j, members + [[i, j]])
+      end
+
+      members
+    end
+
+    regions = {}
+    region_count = 0
+
+    MAP.each do |(x, y), c|
+      next unless c == "1" && !regions[[x, y]]
+
+      region_count += 1
+      regions[[x, y]] = region_count
+      group_members(x, y).each { |i, j| regions[[i, j]] = region_count }
+    end
+
+    solve!("The number of distinct regions is:", region_count)

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

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

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

@@ -0,0 +1,56 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Generator
+      DIVISOR = 2_147_483_647
+
+      def initialize(start, factor, check = 1)
+        @current = start
+        @factor = factor
+        @check = check
+      end
+
+      def next
+        loop do
+          @current = (@current * @factor) % DIVISOR
+          break @current if @current % @check == 0
+        end
+      end
+    end
+
+    FACTORS = {
+      a: 16_807,
+      b: 48_271
+    }.freeze
+
+    CHECK_MASK = (1 << 16) - 1
+
+    start_values = {}
+    INPUT.split("\n").each do |line|
+      match = line.match(/^Generator (?<name>.) starts with (?<start>\d+)$/)
+      start_values[match[:name].downcase.to_sym] = match[:start].to_i
+    end
+
+    def match?(a, b)
+      a & CHECK_MASK == b & CHECK_MASK
+    end
+
+    def match_count(a, b, checks)
+      count = 0
+      checks.times do
+        count += 1 if match?(a.next, b.next)
+      end
+      count
+    end
+
+    a = Generator.new(start_values[:a], FACTORS[:a])
+    b = Generator.new(start_values[:b], FACTORS[:b])
+
+    CHECKS ||= 40_000_000
+    solve!("The judge's count after 40,000,000 checks is:", match_count(a, b, CHECKS))
+
+    a = Generator.new(start_values[:a], FACTORS[:a], 4)
+    b = Generator.new(start_values[:b], FACTORS[:b], 8)
+
+    solve!("The judge's count after 5,000,000 picky checks is:", match_count(a, b, 5_000_000))

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

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

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

@@ -0,0 +1,39 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    MOVES = INPUT.split(",")
+    DANCERS ||= %w[a b c d e f g h i j k l m n o p].freeze
+
+    def dance(performances = 1)
+      dancers = DANCERS.dup
+      positions = []
+      positions << dancers.dup
+
+      performances.times do
+        MOVES.each do |move|
+          case move
+          when /s(\d+)/
+            steps = Regexp.last_match[1].to_i
+            dancers = dancers.rotate(-steps)
+          when %r{x(\d+)/(\d+)}
+            first = Regexp.last_match[1].to_i
+            second = Regexp.last_match[2].to_i
+            dancers[first], dancers[second] = dancers[second], dancers[first]
+          when %r{p(.+)/(.+)}
+            first = dancers.index(Regexp.last_match[1])
+            second = dancers.index(Regexp.last_match[2])
+            dancers[first], dancers[second] = dancers[second], dancers[first]
+          end
+        end
+
+        break if positions.include?(dancers)
+
+        positions << dancers.dup
+      end
+
+      positions[performances % positions.length].join
+    end
+
+    solve!("The order of dancers after their performance is:", dance)
+    solve!("The order of dancers after one billion performances is:", dance(1_000_000_000))

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    STEPS = INPUT.to_i
+    LAST_VALUE = 2017
+
+    buffer = [0]
+    cursor = 0
+
+    LAST_VALUE.times do |i|
+      cursor += STEPS
+      cursor %= buffer.length
+      buffer.insert(cursor + 1, i + 1)
+      cursor += 1
+    end
+
+    solve!("The value after 2017 is:", buffer[buffer.index(LAST_VALUE) + 1])
+
+    value = 0
+    cursor = 0
+    50_000_000.times do |i|
+      cursor += STEPS
+      cursor %= i + 1
+      value = i + 1 if cursor == 0
+      cursor += 1
+    end
+
+    solve!("The value after 0 (after 50 million inserts) is:", value)

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

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

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

@@ -0,0 +1,84 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    class Program
+      INSTRUCTIONS = INPUT.split("\n").map do |line|
+        action, *args = line.split
+        [action.to_sym, args.map { |i| /-?\d+/.match?(i) ? i.to_i : i }]
+      end.freeze
+
+      attr_accessor :outputs, :sent
+
+      def initialize(id = 0)
+        @registers = Hash.new(0)
+        @registers["p"] = id
+
+        @outputs = []
+        @waiting = nil
+        @sent = 0
+        @cursor = 0
+      end
+
+      def run
+        loop do
+          break if @waiting
+          break if @cursor < 0 || @cursor >= INSTRUCTIONS.length
+
+          action, args = INSTRUCTIONS[@cursor]
+
+          case action
+          when :snd
+            @sent += 1
+            @outputs << value_for(args[0])
+          when :set
+            @registers[args[0]] = value_for(args[1])
+          when :add
+            @registers[args[0]] += value_for(args[1])
+          when :mul
+            @registers[args[0]] *= value_for(args[1])
+          when :mod
+            @registers[args[0]] %= value_for(args[1])
+          when :rcv
+            @waiting = args[0]
+          when :jgz
+            @cursor += (value_for(args[1]) - 1) if value_for(args[0]) > 0
+          end
+
+          @cursor += 1
+        end
+      end
+
+      def resume(value)
+        @registers[@waiting] = value
+        @waiting = nil
+
+        run
+      end
+
+      private
+
+      def value_for(n)
+        n.is_a?(String) ? @registers[n] : n
+      end
+    end
+
+    program = Program.new
+    program.run
+
+    solve!("The last value output by the program was:", program.outputs.last)
+
+    program0 = Program.new(0)
+    program1 = Program.new(1)
+
+    program0.run
+    program1.run
+
+    loop do
+      break if program0.outputs.empty? && program1.outputs.empty?
+
+      program0.resume(program1.outputs.shift) if program1.outputs.any?
+      program1.resume(program0.outputs.shift) if program0.outputs.any?
+    end
+
+    solve!("The number of outputs sent by Program 1 was:", program1.sent)

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

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