advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,50 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    FIELD_MATCHER = /(?<name>.{3}):(?<value>.*)/
+    PASSPORTS = INPUT.split("\n\n").map do |data|
+      data.split(/\n| /).each_with_object({}) do |field, passport|
+        field_data = field.match(FIELD_MATCHER)
+        passport[field_data[:name]] = field_data[:value]
+      end
+    end
+
+    def between?(min, max)
+      ->(value) { value.to_i >= min && value.to_i <= max }
+    end
+
+    REQUIRED_FIELDS = %w[byr iyr eyr hgt hcl ecl pid].freeze
+    VALIDITY_RULES = {
+      "byr" => between?(1920, 2002),
+      "iyr" => between?(2010, 2020),
+      "eyr" => between?(2020, 2030),
+      "hgt" => lambda do |value|
+        data = value.match(/^(?<value>\d+)(?<unit>cm|in)$/)
+
+        case data&.[](:unit)
+        when "in" then between?(59, 76)
+        when "cm" then between?(150, 193)
+        else return false
+        end.call(data[:value])
+      end,
+      "hcl" => /^\#\h{6}$/,
+      "ecl" => /^(amb|blu|brn|gry|grn|hzl|oth)$/,
+      "pid" => /^\d{9}$/,
+      "cid" => ->(_) { true }
+    }.freeze
+
+    def required_fields?(passport)
+      REQUIRED_FIELDS.all? { |field| passport.key?(field) }
+    end
+
+    def valid?(passport)
+      return false unless required_fields?(passport)
+
+      passport.all? { |field, value| VALIDITY_RULES[field] === value }
+    end
+
+    solve!("The count of passports with all required fields is:",
+      PASSPORTS.count { |passport| required_fields?(passport) })
+    solve!("The count of validated passports is:",
+      PASSPORTS.count { |passport| valid?(passport) })

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

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

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

@@ -0,0 +1,27 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    require "set"
+
+    PASS_MATCHER = /^(?<row>[FB]{7})(?<column>[LR]{3})$/
+
+    def seat_id(boarding_pass)
+      row = boarding_pass[:row].tr("FB", "01").to_i(2)
+      column = boarding_pass[:column].tr("LR", "01").to_i(2)
+
+      (row * 8) + column
+    end
+
+    PASSES = INPUT.split("\n").each_with_object(Set.new) do |pass, seat_ids|
+      seat_ids << seat_id(pass.match(PASS_MATCHER))
+    end
+
+    solve!("The maximum seat ID in the list is:", PASSES.max)
+
+    def my_seat?(seat)
+      PASSES.include?(seat - 1) && PASSES.include?(seat + 1)
+    end
+
+    MISSING_PASSES = Set.new(1...PASSES.max).subtract(PASSES)
+    solve!("Your seat ID is:", MISSING_PASSES.detect { |seat| my_seat?(seat) })

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

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

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

@@ -0,0 +1,12 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    GROUPED_ANSWERS = INPUT.split("\n\n").map do |group|
+      group.split("\n").map(&:chars)
+    end
+
+    solve!("The number of positive responses is:",
+      GROUPED_ANSWERS.sum { |group| group.reduce(:|).count })
+    solve!("The number of unanimous positive responses is:",
+      GROUPED_ANSWERS.sum { |group| group.reduce(:&).count })

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

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

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

@@ -0,0 +1,84 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    require "set"
+
+    OUTER_BAG_MATCHER = /^(?<color>.+) bags contain (?<contents>.+)\.$/
+    EMPTY_BAG_MATCHER = /^no other bags$/
+    INNER_BAG_MATCHER = /^(?<count>\d+) (?<color>.+) bags?/
+
+    STARTING_BAG = "shiny gold".freeze
+
+    class Bag
+      attr_reader :color, :contents
+
+      def initialize(color)
+        @color = color
+        @contents = {}
+      end
+
+      def holds!(color, count)
+        @contents[color] = count
+      end
+
+      def holds?(contents)
+        case contents
+        when Bag then @contents.key?(contents.color)
+        when String then @contents.key?(contents)
+        when Array then contents.any? { |bag| holds?(bag) }
+        else false
+        end
+      end
+
+      def empty?
+        @contents.empty?
+      end
+    end
+
+    BAGS = INPUT.split("\n").each_with_object({}) do |line, bags|
+      description = line.match(OUTER_BAG_MATCHER)
+      color = description[:color]
+      bags[color] = Bag.new(color)
+
+      next if description[:contents].match?(EMPTY_BAG_MATCHER)
+
+      description[:contents].split(", ").each do |bag|
+        inner_bag = bag.match(INNER_BAG_MATCHER)
+        bags[color].holds!(inner_bag[:color], inner_bag[:count].to_i)
+      end
+    end
+
+    def valid_containers(starting_bag)
+      containers = Set.new
+      new_bags = [starting_bag]
+
+      loop do
+        new_bags = BAGS.values.select { |bag| bag.holds?(new_bags) }
+        break if new_bags.empty?
+
+        containers += new_bags
+      end
+
+      containers
+    end
+
+    count = valid_containers(STARTING_BAG).count
+    solve!("The number of valid outer bags is:", count)
+
+    def contents_for(bag, memo = {})
+      return memo[bag.color] if memo.key?(bag.color)
+
+      contents = Hash.new(0)
+      bag.contents.each do |color, count|
+        contents[color] += count
+        contents_for(BAGS[color], memo).each do |c, n|
+          contents[c] += n * count
+        end
+      end
+
+      memo[bag.color] = contents
+    end
+
+    count = contents_for(BAGS[STARTING_BAG]).values.sum
+    solve!("The total number of bags in our bag is:", count)

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

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

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

@@ -0,0 +1,47 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    require "set"
+
+    INSTRUCTION_MATCHER = /^(?<opcode>\w+) (?<value>\+?-?\d+)$/
+    INSTRUCTIONS = INPUT.split("\n").map { |line| line.match(INSTRUCTION_MATCHER) }
+
+    def run(instructions)
+      pointer = 0
+      accumulator = 0
+      previous = Set.new
+
+      loop do
+        previous << pointer
+
+        instruction = instructions[pointer]
+        case instruction[:opcode]
+        when "acc" then accumulator += instruction[:value].to_i
+        when "jmp" then pointer += instruction[:value].to_i - 1
+        end
+
+        pointer += 1
+
+        break [true, accumulator] if pointer >= instructions.count
+        break [false, accumulator] if previous.include?(pointer)
+      end
+    end
+
+    _success, value = run(INSTRUCTIONS)
+    solve!("The value of the accumulator before looping is:", value)
+
+    TEST_CODES = %w[nop jmp].freeze
+    final = INSTRUCTIONS.each_with_index do |instruction, index|
+      next unless TEST_CODES.include?(instruction[:opcode])
+
+      new_instruction = [{
+        opcode: ((instruction[:opcode] == "nop") ? "jmp" : "nop"),
+        value: instruction[:value]
+      }]
+
+      success, value = run(INSTRUCTIONS[0...index] + new_instruction + INSTRUCTIONS[index + 1..])
+      break value if success
+    end
+
+    solve!("The value of the accumulator after fixing is:", final)

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

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

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

@@ -0,0 +1,38 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    LIST = INPUT.split("\n").map(&:to_i)
+    PREAMBLE ||= 25
+
+    value = LIST.each_cons(PREAMBLE + 1) do |list|
+      number = list[-1]
+      preamble = list[0..-2]
+
+      break number if preamble.combination(2).none? { |combo| combo.sum == number }
+    end
+
+    solve!("The first number that doesn't fit its preamble is:", value)
+
+    def weakness(value)
+      comparison = LIST[0]
+      first = 0
+      last = 0
+
+      loop do
+        if comparison < value
+          last += 1
+          break if last >= LIST.size
+
+          comparison += LIST[last]
+        elsif comparison > value
+          comparison -= LIST[first]
+          first += 1
+        elsif comparison == value
+          range = LIST[first..last]
+          break range.min + range.max
+        end
+      end
+    end
+
+    solve!("The encryption weakness of our list is:", weakness(value))

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

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

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

@@ -0,0 +1,26 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    ADAPTERS = INPUT.split("\n").map(&:to_i).sort
+
+    MAX_RANGE = 3
+    CHARGER_RATING = 0
+    DEVICE_RATING = ADAPTERS.last + MAX_RANGE
+    CHAIN = [CHARGER_RATING] + ADAPTERS + [DEVICE_RATING]
+
+    differences = Hash.new(0)
+    CHAIN.each_cons(2) do |first, second|
+      differences[second - first] += 1
+    end
+
+    solve!("The product of 1-jolt and 3-jolt ranges is:", differences[1] * differences[3])
+
+    options = Hash.new(0)
+    options[CHARGER_RATING] = 1
+
+    CHAIN.drop(1).each do |adapter|
+      options[adapter] = (1..MAX_RANGE).sum { |i| options[adapter - i] }
+    end
+
+    solve!("The number of valid arrangements is:", options[DEVICE_RATING])

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

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

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

@@ -0,0 +1,49 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    FLOORPLAN = INPUT.split("\n").each_with_object({}).with_index do |(line, grid), y|
+      line.chars.each_with_index { |seat, x| grid[[x, y]] = seat }
+    end
+
+    ADJACENCIES = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]].freeze
+    EMPTY = "L".freeze
+    OCCUPIED = "#".freeze
+    FLOOR = ".".freeze
+
+    def stabilize(grid, tolerance, neighbors)
+      loop do
+        result = grid.each_with_object({}) do |((x, y), seat), updated|
+          updated[[x, y]] =
+            case seat
+            when EMPTY then (neighbors.call(grid, x, y) == 0) ? OCCUPIED : EMPTY
+            when OCCUPIED then (neighbors.call(grid, x, y) >= tolerance) ? EMPTY : OCCUPIED
+            else seat
+            end
+        end
+
+        break grid if result == grid
+
+        grid = result
+      end
+    end
+
+    def total_occupied(grid)
+      grid.values.count { |seat| seat == OCCUPIED }
+    end
+
+    neighbors = lambda do |grid, x, y|
+      ADJACENCIES.count { |dx, dy| grid[[x + dx, y + dy]] == OCCUPIED }
+    end
+
+    solve!("The stable occupied seat count is:", total_occupied(stabilize(FLOORPLAN, 4, neighbors)))
+
+    neighbors = lambda do |grid, x, y|
+      ADJACENCIES.count do |(dx, dy)|
+        vector = [x + dx, y + dy]
+        vector = [vector[0] + dx, vector[1] + dy] until grid[vector] != FLOOR
+        grid[vector] == OCCUPIED
+      end
+    end
+
+    solve!("The stable occupied seat count with new rules is:", total_occupied(stabilize(FLOORPLAN, 5, neighbors)))

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

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

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

@@ -0,0 +1,78 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    INSTRUCTION_MATCHER = /^(?<direction>[A-Z])(?<count>\d+)$/
+    INSTRUCTIONS = INPUT.split("\n").map { |line| line.match(INSTRUCTION_MATCHER) }.freeze
+
+    class Ship
+      COMPASS = {
+        "N" => [0, -1],
+        "E" => [1, 0],
+        "S" => [0, 1],
+        "W" => [-1, 0]
+      }.freeze
+
+      def initialize(origin: [0, 0], direction: [1, 0])
+        @x = origin[0]
+        @y = origin[1]
+        @dx = direction[0]
+        @dy = direction[1]
+      end
+
+      def distance
+        @x.abs + @y.abs
+      end
+
+      def follow!(direction, amount)
+        case direction
+        when "F" then amount.times { forward! }
+        when "R" then turn!(amount)
+        when "L" then turn!(-amount)
+        else amount.times { move!(*COMPASS[direction]) }
+        end
+      end
+
+      def turn!(amount)
+        (amount.abs / 90).times do
+          @dx, @dy = (amount > 0) ? [-@dy, @dx] : [@dy, -@dx]
+        end
+      end
+
+      def forward!
+        @x += @dx
+        @y += @dy
+      end
+
+      def move!(dx, dy)
+        @x += dx
+        @y += dy
+      end
+    end
+
+    def navigate!(ship)
+      INSTRUCTIONS.each do |instruction|
+        ship.follow!(instruction[:direction], instruction[:count].to_i)
+      end
+    end
+
+    ship = Ship.new
+    navigate!(ship)
+
+    solve!("The distance to the final location is:", ship.distance)
+
+    class WaypointShip < Ship
+      def initialize(origin: [0, 0], waypoint: [10, -1])
+        super(origin: origin, direction: waypoint)
+      end
+
+      def move!(dx, dy)
+        @dx += dx
+        @dy += dy
+      end
+    end
+
+    ship = WaypointShip.new
+    navigate!(ship)
+
+    solve!("The distance to the final waypointed location is:", ship.distance)

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

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

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

@@ -0,0 +1,64 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    timestamp, bus_ids = INPUT.split("\n")
+
+    TIMESTAMP = timestamp.to_i
+    BUS_IDS = bus_ids.split(",").map { |id| (id == "x") ? nil : id.to_i }.freeze
+
+    def wait_for(bus_ids, timestamp)
+      loop do
+        bus = bus_ids.compact.detect { |id| timestamp % id == 0 }
+        break bus, timestamp if bus
+
+        timestamp += 1
+      end
+    end
+
+    bus, at = wait_for(BUS_IDS, TIMESTAMP)
+    solve!("The next bus's combined ID and wait time is:", bus * (at - TIMESTAMP))
+
+    # No clever coding here. Just shoehorning in an implementation of a mathematical
+    # theorem that I definitely had to look up.
+    class ScheduleSolver
+      def initialize(ids)
+        @ids = ids
+      end
+
+      def timestamp
+        remainders = @ids.map.with_index { |id, n| id ? -n % id : nil }
+        chinese_remainder(@ids.compact, remainders.compact)
+      end
+
+      private
+
+      # Apologies to https://rosettacode.org/wiki/Chinese_remainder_theorem#Ruby
+      def chinese_remainder(moduli, remainders)
+        max = moduli.inject(:*)
+
+        series = remainders.zip(moduli).map do |remainder, modulus|
+          remainder * max / modulus * modular_inverse(max / modulus, modulus)
+        end
+
+        series.inject(:+) % max
+      end
+
+      def modular_inverse(e, et)
+        gcd, = extended_gcd(e, et)
+        gcd % et
+      end
+
+      # Apologies to https://gist.github.com/gpfeiffer/4013925
+      def extended_gcd(a, b)
+        return 1, 0 if b == 0
+
+        quotient, remainder = a.divmod(b)
+        s, t = extended_gcd(b, remainder)
+
+        [t, s - (quotient * t)]
+      end
+    end
+
+    solver = ScheduleSolver.new(BUS_IDS)
+    solve!("The first timestamp for offset departures is:", solver.timestamp)

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

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

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

@@ -0,0 +1,97 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    LINES = INPUT.split("\n")
+
+    MASK_MATCHER = /^mask = (?<mask>[01X]+)$/
+    INPUT_MATCHER = /^mem\[(?<address>\d+)\] = (?<value>\d+)$/
+
+    class InputMask
+      def initialize(mask_string)
+        @mask_string = mask_string
+      end
+
+      def apply(value)
+        (value & zeroes) | ones
+      end
+
+      private
+
+      def ones
+        @ones ||= @mask_string.tr("X", "0").to_i(2)
+      end
+
+      def zeroes
+        @zeroes ||= @mask_string.tr("X", "1").to_i(2)
+      end
+    end
+
+    class AddressMask
+      def initialize(mask_string)
+        @mask_string = mask_string
+      end
+
+      def apply(address)
+        address &= address_base
+        address_masks.map { |address_mask| address | address_mask }
+      end
+
+      private
+
+      def mask
+        @mask ||= @mask_string.reverse.chars
+      end
+
+      def base_for(n)
+        mask.each_with_index.reduce(0) { |base, (c, i)| (c == n) ? base | (1 << i) : base }
+      end
+
+      def address_base
+        @address_base ||= base_for("0")
+      end
+
+      def mask_base
+        @mask_base ||= base_for("1")
+      end
+
+      def address_masks
+        @address_masks ||= begin
+          floating_bits = mask.map.with_index { |c, i| i if c == "X" }.compact
+
+          (0..(2**floating_bits.size)).map do |template|
+            floating_bits.each_with_index.reduce(mask_base) do |address, (bit, index)|
+              address | ((template & (1 << index)) << (bit - index))
+            end
+          end
+        end
+      end
+    end
+
+    def apply_masking(masker)
+      memory = Hash.new(0)
+      mask = nil
+
+      LINES.each do |line|
+        case line
+        when MASK_MATCHER
+          mask = masker.new($~[:mask])
+        when INPUT_MATCHER
+          yield memory, mask, $~
+        end
+      end
+
+      memory
+    end
+
+    final = apply_masking(InputMask) do |memory, mask, data|
+      memory[data[:address].to_i] = mask.apply(data[:value].to_i)
+    end
+
+    solve!("The sum of values in memory after input masking is:", final.values.sum)
+
+    final = apply_masking(AddressMask) do |memory, mask, data|
+      mask.apply(data[:address].to_i).each { |address| memory[address] = data[:value].to_i }
+    end
+
+    solve!("The sum of values in memory after address masking is:", final.values.sum)

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

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

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

@@ -0,0 +1,31 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    STARTING_NUMBERS = INPUT.split(",").map(&:to_i).freeze
+
+    def speak(starting_numbers, rounds)
+      indices = Hash.new { |h, k| h[k] = [] }
+      starting_numbers.each_with_index { |n, i| indices[n] << i }
+      last_num = starting_numbers.last
+
+      (starting_numbers.size...rounds).each do |i|
+        number =
+          if indices[last_num].length > 1
+            indices[last_num][-1] - indices[last_num][-2]
+          else
+            0
+          end
+
+        last_num = number
+        indices[number] << i
+      end
+
+      last_num
+    end
+
+    ROUNDS = 2_020
+    solve!("The #{ROUNDS}th number spoken is:", speak(STARTING_NUMBERS, ROUNDS))
+
+    NEW_ROUNDS = 30_000_000
+    solve!("The #{NEW_ROUNDS}th number spoken is:", speak(STARTING_NUMBERS, NEW_ROUNDS))

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

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