advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,60 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    TICKET_MATCHER = /your ticket:\n(?<ticket>[0-9,]+)/
+    NEARBY_MATCHER = /nearby tickets:\n(?<tickets>[0-9,\n]+)/
+    FIELD_MATCHER = /^(?<field>.+): (?<ranges>.+)$/
+
+    FIELDS = INPUT.scan(FIELD_MATCHER).to_h.transform_values do |ranges|
+      ranges.split(" or ").map do |range|
+        starts, ends = range.split("-").map(&:to_i)
+        starts..ends
+      end
+    end.freeze
+
+    TICKET = INPUT.match(TICKET_MATCHER)[:ticket].split(",").map(&:to_i)
+    NEARBY_TICKETS = INPUT.match(NEARBY_MATCHER)[:tickets].split("\n").map do |ticket|
+      ticket.split(",").map(&:to_i)
+    end.freeze
+
+    def invalid_scans(ticket)
+      ticket.select do |value|
+        FIELDS.none? { |_, ranges| ranges.any? { |range| range.include?(value) } }
+      end
+    end
+
+    values = NEARBY_TICKETS.flat_map { |ticket| invalid_scans(ticket) }
+    solve!("The sum of invalid scanned values is:", values.sum)
+
+    def possibilities_for(ticket)
+      ticket.map do |value|
+        FIELDS.keys.select do |field|
+          FIELDS[field].any? { |range| range.include?(value) }
+        end
+      end
+    end
+
+    def field_sequence(options)
+      loop do
+        break if options.all? { |possible| possible.length == 1 }
+
+        found = options.select { |possible| possible.length == 1 }.flatten
+        options = options.map { |possible| (possible.length == 1) ? possible : possible - found }
+      end
+
+      options.map(&:first)
+    end
+
+    valid_tickets = NEARBY_TICKETS.reject { |ticket| invalid_scans(ticket).any? }
+    options = valid_tickets.reduce(Array.new(FIELDS.count) { FIELDS.keys }) do |possibilities, ticket|
+      fields = possibilities_for(ticket)
+      possibilities.map.with_index { |possible, i| possible.intersection(fields[i]) }
+    end
+
+    FIELD_IDENTIFIER = "departure".freeze
+    values = field_sequence(options).map.with_index do |field, i|
+      TICKET[i] if field.start_with?(FIELD_IDENTIFIER)
+    end.compact
+
+    solve!("The product of departure values is:", values.inject(:*))

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

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

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

@@ -0,0 +1,53 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    INITIAL = INPUT.split("\n").each_with_object({}).with_index do |(row, grid), y|
+      row.chars.each_with_index { |cube, x| grid[[x, y]] = cube }
+    end
+
+    ACTIVE = "#".freeze
+    INACTIVE = ".".freeze
+
+    def cycle(grid, dimensions: 3)
+      adjacencies = ([-1, 0, 1].repeated_permutation(dimensions).to_a - [[0] * dimensions]).freeze
+
+      grid = grid.each_with_object({}) do |(coord, cube), final|
+        extended_coord = coord + ([0] * (dimensions - coord.length))
+        final[extended_coord] = cube
+      end
+
+      ranges = dimensions.times.map do |i|
+        starts, ends = grid.keys.map { |coords| coords[i] }.minmax
+        (starts - 1..ends + 1).to_a
+      end
+
+      result = Hash.new(INACTIVE)
+
+      ranges[0].product(*ranges[1..]).each do |coord|
+        count = adjacencies.count do |deltas|
+          neighbor = coord.map.with_index { |c, i| c + deltas[i] }
+          grid[neighbor] == ACTIVE
+        end
+
+        result[coord] =
+          case grid[coord]
+          when ACTIVE then [2, 3].include?(count) ? ACTIVE : INACTIVE
+          else (count == 3) ? ACTIVE : INACTIVE
+          end
+      end
+
+      result
+    end
+
+    CYCLES = 6
+
+    grid = INITIAL.dup
+    CYCLES.times { grid = cycle(grid) }
+
+    solve!("The number of active 3-d cubes is:", grid.values.count { |cube| cube == ACTIVE })
+
+    grid = INITIAL.dup
+    CYCLES.times { grid = cycle(grid, dimensions: 4) }
+
+    solve!("The number of active 4-d cubes is:", grid.values.count { |cube| cube == ACTIVE })

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

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

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

@@ -0,0 +1,56 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    LINES = INPUT.split("\n")
+
+    class Expression
+      OPERATIONS = {
+        "+" => ->(a, b) { a + b },
+        "*" => ->(a, b) { a * b }
+      }.freeze
+
+      def initialize(expression, precedence: {"*" => 2, "+" => 1})
+        @expression = expression
+        @precedence = precedence
+      end
+
+      def evaluate
+        expression_stack.each_with_object([]) do |token, stack|
+          stack.push(OPERATIONS.key?(token) ? OPERATIONS[token][*stack.pop(2)] : token)
+        end.first
+      end
+
+      private
+
+      def expression_stack
+        @expression_stack ||= begin
+          stack = []
+          operators = []
+
+          @expression.tr(" ", "").chars.each do |token|
+            case token
+            when *OPERATIONS.keys
+              op2 = operators.last
+              stack << operators.pop if OPERATIONS.key?(op2) && @precedence[token] <= @precedence[op2]
+              operators << token
+            when "("
+              operators << token
+            when ")"
+              stack << operators.pop until operators.last == "("
+              operators.pop
+            else
+              stack << token.to_i
+            end
+          end
+
+          stack + operators.reverse
+        end
+      end
+    end
+
+    values = LINES.map { |line| Expression.new(line, precedence: {"*" => 1, "+" => 1}).evaluate }
+    solve!("The total with neutral-precedence operations is:", values.sum)
+
+    values = LINES.map { |line| Expression.new(line, precedence: {"*" => 1, "+" => 2}).evaluate }
+    solve!("The total with reverse-precedence operations is:", values.sum)

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

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

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

@@ -0,0 +1,44 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    RULE_MATCHER = /^(\d+): (.+)$/
+    MESSAGES = INPUT.scan(/^\w+$/).freeze
+
+    class RuleSet
+      CHAR_MATCHER = /\A"(?<chars>\w+)"\z/
+
+      attr_reader :rules
+
+      def initialize(patterns)
+        @patterns = patterns
+        @rules = {}
+      end
+
+      def match?(message)
+        message.match?(/\A#{self["0"]}\z/)
+      end
+
+      def [](index)
+        return rules[index] if rules[index]
+
+        pattern = @patterns[index]
+        rules[index] =
+          case pattern
+          when CHAR_MATCHER
+            $~[:chars]
+          else
+            pattern = pattern.scan(/\d+/).reduce(pattern) { |r, t| r.gsub(/\b#{t}\b/, self[t]) }
+            "(#{pattern.delete(" ")})"
+          end
+      end
+    end
+
+    RULESET = RuleSet.new(INPUT.scan(RULE_MATCHER).to_h)
+    solve!("The number of matching messages is:", MESSAGES.count { |message| RULESET.match?(message) })
+
+    RULESET.rules["8"] = "(#{RULESET["42"]}+)" # 8: 42 | 42 8
+    RULESET.rules["11"] = "(?<l>#{RULESET["42"]}\\g<l>?#{RULESET["31"]})" # 11: 42 31 | 42 11 31
+    RULESET.rules["0"] = nil
+
+    solve!("The number of matching looped messages is:", MESSAGES.count { |message| RULESET.match?(message) })

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

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

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

@@ -0,0 +1,133 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    require "delegate"
+
+    class Image < SimpleDelegator
+      def variants
+        base = __getobj__
+
+        [
+          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 { |grid| Image.new(grid) }
+      end
+    end
+
+    class Tile
+      attr_reader :id, :image
+
+      def initialize(image, id: nil)
+        @image = image
+        @id = id
+      end
+
+      def content
+        image[1...-1].map { |row| row[1...-1] }
+      end
+
+      def fits?(tile, direction)
+        return true unless tile
+
+        case direction
+        when :right then image.each_index.all? { |y| image[y][-1] == tile.image[y][0] }
+        when :bottom then image[-1] == tile.image[0]
+        end
+      end
+
+      def variants
+        @variants ||= image.variants.map { |variant| Tile.new(variant, id: id) }
+      end
+    end
+
+    TILE_MATCHER = /Tile (\d+):\n([.#\n]+)/
+    TILES = INPUT.scan(TILE_MATCHER).map do |id, grid|
+      grid = Image.new(grid.split("\n").map(&:chars))
+      Tile.new(grid, id: id.to_i)
+    end.freeze
+
+    SIZE = Math.sqrt(TILES.count).to_i
+
+    def arrangement_for(tiles, x, y, layout = Array.new(SIZE) { Array.new(SIZE) })
+      return layout if x >= SIZE || y >= SIZE
+
+      tiles.each do |tile|
+        next if layout.any? { |row| row.compact.any? { |t| t.id == tile.id } }
+
+        tile.variants.each do |variant|
+          fits =
+            (x == 0 || layout[y][x - 1].fits?(variant, :right)) &&
+            (y == 0 || layout[y - 1][x].fits?(variant, :bottom))
+
+          next unless fits
+
+          updated = layout.dup.tap { |l| l[y][x] = variant }
+          i = (x + 1) % SIZE
+          j = (i == 0) ? y + 1 : y
+
+          arrangement = arrangement_for(tiles, i, j, updated)
+          return arrangement if arrangement
+        end
+      end
+
+      nil
+    end
+
+    arrangement = arrangement_for(TILES, 0, 0)
+    corner_ids = [0, SIZE - 1].repeated_permutation(2).map { |x, y| arrangement[x][y].id }
+
+    solve!("The product of corner tile IDs is:", corner_ids.inject(:*))
+
+    class MonsterScanner
+      def initialize(monster)
+        @monster_mask = mask_for(monster)
+
+        @height = monster.size
+        @width = monster[0].size
+      end
+
+      def count_for(image)
+        image.variants.detect do |variant|
+          count = scan(variant)
+          break count if count > 0
+        end
+      end
+
+      private
+
+      def scan(image)
+        image.each_cons(@height).sum do |layer|
+          scanlines = layer.map { |line| line.each_cons(@width) }
+          regions = scanlines[0].zip(*scanlines[1..])
+
+          regions.count { |region| mask_for(region) & @monster_mask == @monster_mask }
+        end
+      end
+
+      def mask_for(image)
+        image.map(&:join).join.tr(".#", "01").to_i(2)
+      end
+    end
+
+    MONSTER = <<~TXT.split("\n").map(&:chars).freeze
+      ..................#.
+      #....##....##....###
+      .#..#..#..#..#..#...
+    TXT
+
+    IMAGE = Image.new(arrangement.flat_map do |tiles|
+      contents = tiles.map(&:content)
+      contents[0].zip(*contents[1..]).map { |row| row.inject(:+) }
+    end)
+
+    monsters = MonsterScanner.new(MONSTER).count_for(IMAGE)
+    roughness = IMAGE.flatten.count("#") - (MONSTER.flatten.count("#") * monsters)
+
+    solve!("The water roughness of the sea monster habitat is:", roughness)

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

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

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

@@ -0,0 +1,34 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    RECIPE_MATCHER = /^(?<ingredients>.+) \(contains (?<allergens>.+)\)$/
+
+    allergens = {}
+
+    RECIPES = INPUT.split("\n").each_with_object([]) do |recipe, recipes|
+      data = RECIPE_MATCHER.match(recipe)
+
+      ingredients = data[:ingredients].split
+      recipes << ingredients
+
+      data[:allergens].split(", ").each do |allergen|
+        allergens[allergen] ||= ingredients
+        allergens[allergen] &= ingredients
+      end
+    end
+
+    ALLERGENS =
+      loop do
+        known, unknown = allergens.partition { |_, options| options.length == 1 }
+        break allergens.transform_values(&:first).freeze if unknown.empty?
+
+        known = known.map(&:last).reduce(:|)
+        unknown.each { |allergen, _| allergens[allergen] -= known }
+      end
+
+    solve!("The quantity of inert ingredients is:",
+      RECIPES.sum { |ingredients| (ingredients - ALLERGENS.values).count })
+
+    solve!("The canonical dangerous ingredient list is:",
+      ALLERGENS.sort_by(&:first).map(&:last).join(","))

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

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

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

@@ -0,0 +1,38 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    require "set"
+
+    DECKS = INPUT.scan(/Player \d+:\n([\d\n]+)/).map { |(deck)| deck.split("\n").map(&:to_i) }.freeze
+
+    def combat(decks, recursive: false)
+      rounds = Set.new
+
+      loop do
+        break [0, decks[0]] if rounds.include?(decks.hash)
+
+        rounds << decks.hash
+        cards = decks.map(&:shift)
+
+        if recursive && decks.each_index.all? { |i| decks[i].size >= cards[i] }
+          winner, = combat(decks.map.with_index { |deck, i| deck.take(cards[i]) }, recursive: true)
+          loser = (winner + 1) % decks.size
+        else
+          winner, loser = cards.each_with_index.sort_by(&:first).reverse.map(&:last)
+        end
+
+        decks[winner] += cards.values_at(winner, loser)
+        break [winner, decks[winner]] if decks[loser].empty?
+      end
+    end
+
+    def score_for(deck)
+      deck.each_index.sum { |i| deck[i] * (deck.size - i) }
+    end
+
+    _, deck = combat(DECKS.map(&:dup))
+    solve!("The winning score after combat is:", score_for(deck))
+
+    _, deck = combat(DECKS.map(&:dup), recursive: true)
+    solve!("The winning score after recursive combat is:", score_for(deck))

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

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

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

@@ -0,0 +1,61 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    LABELS = INPUT.chars.map(&:to_i).freeze
+
+    class Cup
+      attr_reader :label
+      attr_accessor :next
+
+      def initialize(label)
+        @label = label
+        @next = self
+      end
+
+      def insert!(cup)
+        cup.next = @next
+        @next = cup
+      end
+    end
+
+    def move!(cups, current)
+      taken = [current.next, current.next.next, current.next.next.next]
+      current.next = taken[-1].next
+
+      target = current.label
+
+      loop do
+        target = (target == 1) ? cups.count : target - 1
+        break if taken.none? { |cup| cup.label == target }
+      end
+
+      taken[-1].next = cups[target].next
+      cups[target].next = taken[0]
+    end
+
+    def play(labels, moves)
+      current = nil
+      cups = labels.each_with_object({}) do |label, cups|
+        cups[label] = Cup.new(label)
+
+        current&.insert!(cups[label])
+        current = cups[label]
+      end
+
+      moves.times { move!(cups, current = current.next) }
+
+      cups
+    end
+
+    result = play(LABELS, 100)
+
+    current = result[1]
+    labels = (result.count - 1).times.map { (current = current.next).label }
+    solve!("The labels clockwise from 1 after 100 rounds are:", labels.join)
+
+    new_labels = LABELS + ((LABELS.count + 1)..1_000_000).to_a
+    result = play(new_labels, 10_000_000)
+
+    product = result[1].next.label * result[1].next.next.label
+    solve!("The product of the two labels clockwise from 1 is:", product)

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

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

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

@@ -0,0 +1,45 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    NEIGHBORS = {
+      "ne" => [0, -1, 1],
+      "nw" => [-1, 0, 1],
+      "se" => [1, 0, -1],
+      "sw" => [0, 1, -1],
+      "e" => [1, -1, 0],
+      "w" => [-1, 1, 0]
+    }.freeze
+
+    DIRECTIONS = INPUT.split("\n").map { |line| line.scan(Regexp.union(NEIGHBORS.keys)).to_a }.freeze
+    FLOOR = DIRECTIONS.each_with_object({}) do |instructions, floor|
+      steps = instructions.map { |step| NEIGHBORS[step] }
+      coords = [0, 0, 0].zip(*steps).map(&:sum)
+
+      floor[coords] = !floor[coords]
+    end.freeze
+
+    solve!("The initial number of black tiles is:", FLOOR.values.count(true))
+
+    def neighbors_for(coords)
+      NEIGHBORS.map { |_, change| coords.zip(change).map(&:sum) }
+    end
+
+    def flipped(floor)
+      floor.each_with_object({}) do |(coords, value), updated|
+        next unless value
+
+        count = neighbors_for(coords).count do |neighbor|
+          next true if floor[neighbor]
+
+          updated[neighbor] = neighbors_for(neighbor).count { |n| floor[n] } == 2
+          false
+        end
+
+        updated[coords] = count > 0 && count <= 2
+      end
+    end
+
+    floor = FLOOR
+    100.times { floor = flipped(floor) }
+    solve!("The number of black tiles after 100 days is:", floor.values.count(true))

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

@@ -0,0 +1,15 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2020
+  :solution: |-
+    INITIAL_SUBJECT = 7
+    MODULUS = 20_201_227
+    CARD_KEY, DOOR_KEY = INPUT.split("\n").map(&:to_i)
+    CARD_SECRET = (0..).reduce(1) do |value, loops|
+      break loops if value == CARD_KEY # rubocop:disable Lint/UnmodifiedReduceAccumulator
+
+      value * INITIAL_SUBJECT % MODULUS
+    end
+
+    encryption_key = CARD_SECRET.times.reduce(1) { |key, _| key * DOOR_KEY % MODULUS }
+    solve!("The encryption key is:", encryption_key)

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

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

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

@@ -0,0 +1,14 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    SWEEPS = INPUT.split("\n").map(&:to_i)
+
+    def increases_for(measurements)
+      measurements.each_cons(2).count { |i, j| i < j }
+    end
+
+    solve!("The number of depth increases is:", increases_for(SWEEPS))
+
+    window_sums = SWEEPS.each_cons(3).map(&:sum)
+    solve!("The number of 3-measurement depth increases is:", increases_for(window_sums))

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

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

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

@@ -0,0 +1,40 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    INSTRUCTION_MATCHER = /(?<instruction>\w+) (?<value>\d+)/
+    INSTRUCTIONS = INPUT.split("\n").map do |line|
+      match = line.match(INSTRUCTION_MATCHER)
+      [match[:instruction].to_sym, match[:value].to_i]
+    end.freeze
+
+    x = 0
+    y = 0
+
+    INSTRUCTIONS.each do |instruction, value|
+      case instruction
+      when :forward then x += value
+      when :down then y += value
+      when :up then y -= value
+      end
+    end
+
+    solve!("The combined depth/position value is:", x * y)
+
+    aim = 0
+    x = 0
+    y = 0
+
+    INSTRUCTIONS.each do |instruction, value|
+      case instruction
+      when :forward
+        x += value
+        y += aim * value
+      when :down
+        aim += value
+      when :up
+        aim -= value
+      end
+    end
+
+    solve!("The combined aimed depth/position value is:", x * y)

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

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

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

@@ -0,0 +1,41 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    NUMBERS = INPUT.split("\n").map { |number| number.chars.map(&:to_i) }
+    LENGTH = NUMBERS.first.length
+
+    def most_common_for(numbers)
+      LENGTH.times.map do |i|
+        ones = numbers.count { |n| n[i] == 1 }
+        zeroes = numbers.length - ones
+
+        (ones >= zeroes) ? 1 : 0
+      end
+    end
+
+    def value_for(digits)
+      digits.join.to_i(2)
+    end
+
+    epsilon = most_common_for(NUMBERS)
+    gamma = epsilon.map { |i| (i == 1) ? 0 : 1 }
+
+    solve!("The system's power consumption is:", value_for(epsilon) * value_for(gamma))
+
+    def filtered_value(numbers, operator)
+      LENGTH.times.each do |i|
+        ones = numbers.count { |n| n[i] == 1 }
+        zeroes = numbers.length - ones
+        filter_by = ones.public_send(operator, zeroes) ? 1 : 0
+
+        numbers = numbers.select { |n| n[i] == filter_by }
+
+        break numbers.first if numbers.one?
+      end
+    end
+
+    oxygen_generator = filtered_value(NUMBERS, :>=)
+    co2_scrubber = filtered_value(NUMBERS, :<)
+
+    solve!("The system's life support rating is:", value_for(oxygen_generator) * value_for(co2_scrubber))

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

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