advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,45 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "set"
+
+    UNIVERSE = INPUT.split("\n").flat_map.with_index do |line, y|
+      line.chars.filter_map.with_index { |c, x| [x, y] if c == "#" }
+    end
+
+    def expand(universe, factor: 2)
+      xmax = universe.map(&:first).max
+      ymax = universe.map(&:last).max
+
+      expanded_columns = Set.new((0..xmax).reject { |x| universe.any? { |p| p[0] == x } })
+      expanded_rows = Set.new((0..ymax).reject { |y| universe.any? { |p| p[1] == y } })
+
+      i = 0
+      j = 0
+
+      (0..ymax).each_with_object([]) do |y, planets|
+        (0..xmax).each do |x|
+          planets << [i, j] if universe.any? { |p| p == [x, y] }
+          i += expanded_columns.include?(x) ? factor : 1
+        end
+
+        i = 0
+        j += expanded_rows.include?(y) ? factor : 1
+      end
+    end
+
+    def distance(a, b)
+      (a[1] - b[1]).abs + (a[0] - b[0]).abs
+    end
+
+    def pair_total(universe)
+      universe.combination(2).sum { |a, b| distance(a, b) }
+    end
+
+    universe = expand(UNIVERSE, factor: 2)
+    solve!("The sum of lengths between pairs of planets is:", pair_total(universe))
+
+    EXPANSION_FACTOR ||= 1000000
+    universe = expand(UNIVERSE, factor: EXPANSION_FACTOR)
+    solve!("The sum of lengths between pairs of OLD planets is:", pair_total(universe))

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

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

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

@@ -0,0 +1,55 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    class Spring
+      FOLDING_FACTOR = 5
+      CONDITIONS = {
+        operational: ".",
+        damaged: "#",
+        unknown: "?"
+      }.freeze
+
+      def initialize(record:, damage:)
+        @record = record
+        @damage = damage
+        @arrangements = {}
+      end
+
+      def unfold(factor: FOLDING_FACTOR)
+        record = ([@record] * factor).join(CONDITIONS[:unknown])
+        damage = @damage * factor
+
+        Spring.new(record:, damage:)
+      end
+
+      def arrangements(pattern = @record, splits = @damage)
+        return @arrangements[[pattern, splits]] if @arrangements.key?([pattern, splits])
+        return ((pattern&.chars || []).all? { |p| p != CONDITIONS[:damaged] }) ? 1 : 0 if splits.empty?
+
+        damaged, *rest = splits
+        after = rest.sum + rest.size
+
+        @arrangements[[pattern, splits]] = (pattern.size - after - damaged + 1).times.sum do |before|
+          candidate = [CONDITIONS[:operational]] * before + [CONDITIONS[:damaged]] * damaged + [CONDITIONS[:operational]]
+          consistent?(candidate, pattern) ? arrangements(pattern[candidate.length..], rest) : 0
+        end
+      end
+
+      def consistent?(candidate, pattern = @record)
+        candidate.each_with_index.all? { |c, i| i > (pattern.length - 1) || pattern[i] == c || pattern[i] == CONDITIONS[:unknown] }
+      end
+    end
+
+    SPRINGS = INPUT.split("\n").map do |line|
+      record, damage = line.split(" ")
+      damage = damage.split(",").map(&:to_i)
+
+      Spring.new(record:, damage:)
+    end
+
+    total = SPRINGS.sum(&:arrangements)
+    solve!("The count of possible spring arrangements is:", total)
+
+    total = SPRINGS.map(&:unfold).sum(&:arrangements)
+    solve!("The count of possible unfolded spring arrangements is:", total)

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

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

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

@@ -0,0 +1,40 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    class Pattern
+      def initialize(pattern)
+        @horizontal = pattern.split("\n")
+        @vertical = pattern.split("\n").map(&:chars).transpose.map(&:join)
+      end
+
+      def reflection_score(smudges: 0)
+        vertical = (0...@vertical.length).detect { |i| reflects_at?(@vertical, i, smudges:) }
+        return vertical + 1 if vertical
+
+        horizontal = (0...@horizontal.length).detect { |i| reflects_at?(@horizontal, i, smudges:) }
+        (horizontal + 1) * 100
+      end
+
+      def reflects_at?(pattern, row, smudges: 0)
+        return false if row == pattern.length - 1
+
+        i = 0
+        delta = 0
+
+        loop do
+          if pattern[row - i] != pattern[row + i + 1]
+            delta += pattern[0].length.times.count { |c| pattern[row - i][c] != pattern[row + i + 1][c] }
+            break false if delta > smudges
+          end
+
+          i += 1
+
+          break delta == smudges if row - i < 0 || row + i + 1 >= pattern.length
+        end
+      end
+    end
+
+    PATTERNS = INPUT.split("\n\n").map { |pattern| Pattern.new(pattern) }
+    solve!("The mirror line score is:", PATTERNS.sum(&:reflection_score))
+    solve!("The smudge-free mirror line score is:", PATTERNS.sum { |p| p.reflection_score(smudges: 1) })

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

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

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

@@ -0,0 +1,81 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    CUBE = "#"
+    ROUND = "O"
+    EMPTY = "."
+
+    PLATFORM = INPUT.split("\n").map do |(line, y), platform|
+      line.chars.map.with_index do |c, x|
+        (c == EMPTY) ? nil : c
+      end
+    end
+
+    def slide_sequence(width, height, direction)
+      case direction
+      when [0, -1] then (0...height).each { |y| (0...width).each { |x| yield [x, y] } }
+      when [0, 1] then (height - 1).downto(0).each { |y| (0...width).each { |x| yield [x, y] } }
+      when [-1, 0] then (0...width).each { |x| (0...height).each { |y| yield [x, y] } }
+      when [1, 0] then (width - 1).downto(0).each { |x| (0...height).each { |y| yield [x, y] } }
+      end
+    end
+
+    def tilt(platform, (dx, dy))
+      tilted = platform.map(&:dup)
+      width = platform.size
+      height = platform[0].size
+
+      slide_sequence(width, height, [dx, dy]) do |x, y|
+        next unless platform[y][x] == ROUND
+
+        i = x
+        j = y
+
+        loop do
+          break if i + dx < 0 || j + dy < 0 || i + dx >= width || j + dy >= height || tilted[j + dy][i + dx]
+
+          tilted[j + dy][i + dx] = tilted[j][i]
+          tilted[j][i] = nil
+
+          i += dx
+          j += dy
+        end
+      end
+
+      tilted
+    end
+
+    def load_for(platform)
+      ymax = platform.size
+      platform.each_with_index.sum do |row, y|
+        row.sum do |r|
+          (r == ROUND) ? (ymax - y) : 0
+        end
+      end
+    end
+
+    solve!("The load after tilting north is:", load_for(tilt(PLATFORM, [0, -1])))
+
+    CYCLES = 1000000000
+
+    platform = PLATFORM
+    cache = {}
+    cycles = 0
+
+    final = loop do
+      platform = [[0, -1], [-1, 0], [0, 1], [1, 0]].reduce(platform) { |p, d| tilt(p, d) }
+      cycles += 1
+
+      if cache[platform]
+        loops_at = cache[platform]
+        loop_size = cycles - loops_at
+        cycle = (CYCLES - loops_at) % loop_size
+
+        break cache.key(loops_at + cycle)
+      end
+
+      cache[platform] = cycles
+    end
+
+    solve!("The load after #{CYCLES} cycles is:", load_for(final))

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

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

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

@@ -0,0 +1,52 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    Step = Data.define(:step) do
+      def verification
+        hash_for(step)
+      end
+
+      def label
+        step.scan(/\w+/).first
+      end
+
+      def box
+        hash_for(label)
+      end
+
+      def insert?
+        step.include?("=")
+      end
+
+      def focal_length
+        return nil unless insert?
+
+        step.scan(/\w+/).last.to_i
+      end
+
+      def hash_for(string)
+        string.chars.reduce(0) do |value, c|
+          value += c.ord
+          (value * 17) % 256
+        end
+      end
+    end
+
+    SEQUENCE = INPUT.split(",").map { |step| Step.new(step) }.freeze
+
+    solve!("The verification code for initialization is:", SEQUENCE.sum(&:verification))
+
+    boxes = SEQUENCE.each_with_object(Hash.new { |h, k| h[k] = {} }) do |step, boxes|
+      if step.insert?
+        boxes[step.box][step.label] = step.focal_length
+      else
+        boxes[step.box].delete(step.label)
+      end
+    end
+
+    power = boxes.sum do |box, lenses|
+      lenses.each_with_index.sum { |(_, focal_length), index| (box + 1) * (index + 1) * focal_length }
+    end
+
+    solve!("The focusing power of the lenses after initialization is:", power)

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    DIRECTIONS = {
+      n: [0, -1],
+      e: [1, 0],
+      s: [0, 1],
+      w: [-1, 0]
+    }.freeze
+
+    Beam = Data.define(:direction) do
+      def move((x, y))
+        dx, dy = DIRECTIONS[direction]
+        [x + dx, y + dy]
+      end
+
+      def bounce(mirror)
+        case [direction, mirror]
+        when [:n, "/"], [:s, "\\"] then [Beam.new(:e)]
+        when [:n, "\\"], [:s, "/"] then [Beam.new(:w)]
+        when [:n, "-"], [:s, "-"] then [Beam.new(:e), Beam.new(:w)]
+        when [:e, "/"], [:w, "\\"] then [Beam.new(:n)]
+        when [:e, "\\"], [:w, "/"] then [Beam.new(:s)]
+        when [:e, "|"], [:w, "|"] then [Beam.new(:n), Beam.new(:s)]
+        else
+          [self]
+        end
+      end
+    end
+
+    CONTRAPTION = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), contraption|
+      line.chars.each_with_index do |c, x|
+        contraption[[x, y]] = c
+      end
+    end
+
+    def energy_for(contraption, tile: [-1, 0], beam: Beam.new(:e))
+      width = contraption.keys.map(&:first).max
+      height = contraption.keys.map(&:last).max
+
+      energized = {}
+      seen = {}
+
+      beams = [[tile, beam]]
+
+      loop do
+        break if beams.empty?
+
+        position, beam = beams.shift
+        next if seen[[position, beam]]
+
+        seen[[position, beam]] = true
+        x, y = beam.move(position)
+
+        next if x < 0 || y < 0 || x > width || y > height
+
+        energized[[x, y]] = true
+        beams += beam.bounce(contraption[[x, y]]).map { |b| [[x, y], b] }
+      end
+
+      energized.count
+    end
+
+    solve!("The number of energized tiles is:", energy_for(CONTRAPTION))
+
+    def most_energy(contraption)
+      width = contraption.keys.map(&:first).max
+      height = contraption.keys.map(&:last).max
+
+      north = (0..width).map { |x| energy_for(contraption, tile: [x, height + 1], beam: Beam.new(:n)) }
+      east = (0..height).map { |y| energy_for(contraption, tile: [-1, y], beam: Beam.new(:e)) }
+      south = (0..width).map { |x| energy_for(contraption, tile: [x, -1], beam: Beam.new(:s)) }
+      west = (0..height).map { |y| energy_for(contraption, tile: [width + 1, y], beam: Beam.new(:w)) }
+
+      [north.max, east.max, south.max, west.max].max
+    end
+
+    solve!("The maximum number of energized tiles is:", most_energy(CONTRAPTION))

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

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

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

@@ -0,0 +1,105 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+    require "rb_heap/heap"
+
+    class City
+      DIRECTIONS = {
+        n: Vector[0, -1],
+        e: Vector[1, 0],
+        s: Vector[0, 1],
+        w: Vector[-1, 0]
+      }.freeze
+
+      def initialize(map)
+        @map = map
+      end
+
+      def [](block)
+        @map[block]
+      end
+
+      def destinations(origin, turns)
+        turns.filter_map do |direction|
+          destination = origin + DIRECTIONS[direction]
+          next unless @map.key?(destination)
+
+          [destination, direction]
+        end
+      end
+    end
+
+    class Crucible
+      TURNS = {n: %i[e w], e: %i[n s], s: %i[e w], w: %i[n s]}.freeze
+
+      def initialize(city, min: 1, max: 3)
+        @city = city
+        @min = min
+        @max = max
+      end
+
+      def turns_for(path)
+        return %i[n e s w] if path.empty?
+
+        direction = path.last
+
+        if path.size >= @min && path.last(@min).all? { |d| d == direction }
+          turns = TURNS[direction]
+          (path.size >= @max && path.last(@max).all? { |d| d == direction }) ? turns : turns + [direction]
+        else
+          [direction]
+        end
+      end
+
+      def heat_loss(from:, to:)
+        queue = Heap.new { |a, b| a[0] < b[0] }
+        queue << [0, from, []]
+
+        losses = {}
+
+        loop do
+          if queue.empty?
+            goals = losses.select { |k, _| k[0] == to && k[2] >= @min }
+            break goals.map(&:last).min
+          end
+
+          loss, block, path = queue.pop
+          @city.destinations(block, turns_for(path)).each do |dest, dir|
+            new_loss = loss + @city[dest]
+            new_path = path + [dir]
+
+            steps = new_path.reverse.index { |d| d != dir }
+            key = [dest, dir, steps]
+
+            next if losses.key?(key) && losses[key] <= new_loss
+
+            losses[key] = new_loss
+            next if dest == to
+
+            queue << [new_loss, dest, new_path.last(@max)]
+          end
+        end
+      end
+    end
+
+    MAP = INPUT.split("\n").each_with_object({}).with_index do |(line, map), y|
+      line.chars.each_with_index do |c, x|
+        map[Vector[x, y]] = c.to_i
+      end
+    end.freeze
+
+    START = Vector[0, 0]
+    GOAL = MAP.keys.max_by(&:magnitude)
+
+    city = City.new(MAP)
+    crucible = Crucible.new(city)
+    heat_loss = crucible.heat_loss(from: START, to: GOAL)
+
+    solve!("The minimum heat loss on the trip is:", heat_loss)
+
+    ultra_crucible = Crucible.new(city, min: 4, max: 10)
+    heat_loss = ultra_crucible.heat_loss(from: START, to: GOAL)
+
+    solve!("The minimum heat loss for an ultra crucible is:", heat_loss)

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

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

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

@@ -0,0 +1,64 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+
+    DIRECTIONS = {
+      U: Vector[0, -1],
+      R: Vector[1, 0],
+      D: Vector[0, 1],
+      L: Vector[-1, 0]
+    }.freeze
+
+    CODES = %i[R D L U].freeze
+
+    Dig = Data.define(:direction, :meters, :code) do
+      def path
+        DIRECTIONS[direction] * meters
+      end
+
+      def coded_path
+        hex = code.tr("(#)", "")
+        meters = hex[0..4].to_i(16)
+
+        DIRECTIONS[CODES[hex[5].to_i]] * meters
+      end
+    end
+
+    class Lagoon
+      def initialize(trench)
+        @trench = trench
+      end
+
+      def area
+        interior = 0
+        boundary = 0
+
+        @trench.each_cons(2) do |p, q|
+          x, y = p.to_a
+          i, j = q.to_a
+
+          interior += x * j - i * y
+          boundary += (p - q).magnitude
+        end
+
+        (interior.abs / 2 + boundary / 2 + 1).to_i
+      end
+    end
+
+    DIG_PLAN = INPUT.split("\n").map do |line|
+      direction, meters, code = line.split(" ")
+      Dig.new(direction: direction.to_sym, meters: meters.to_i, code:)
+    end
+
+    def trench_for(plan, use: :path)
+      position = Vector[0, 0]
+      [position] + plan.map { |plan| position += plan.public_send(use) }
+    end
+
+    lagoon = Lagoon.new(trench_for(DIG_PLAN))
+    solve!("The total capacity of the lagoon is:", lagoon.area)
+
+    lagoon = Lagoon.new(trench_for(DIG_PLAN, use: :coded_path))
+    solve!("The total capacity of the lagoon (using the coded plan) is:", lagoon.area)

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

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

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

@@ -0,0 +1,102 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    WORKFLOW_MATCHER = /\A(?<name>\w+)\{(?<rules>.+)\}\z/
+    RULE_MATCHER = /\A(?<rating>\w)(?<operation><|>)(?<value>\d+):(?<output>\w+)\z/
+    RATING_MATCHER = /\A(?<rating>\w)=(?<value>\d+)\z/
+
+    ACCEPTANCE_FLOW = "A"
+    REJECTION_FLOW = "R"
+    STARTING_FLOW = "in"
+
+    Rule = Data.define(:rating, :operation, :value, :output) do
+      def passes?(part)
+        (operation == "<") ? part[rating] < value : part[rating] > value
+      end
+
+      def partition(ratings)
+        passed = ratings.dup
+        failed = ratings.dup
+        range = ratings[rating]
+
+        passed[rating] = (operation == "<") ? range.begin..(value - 1) : (value + 1)..range.end
+        failed[rating] = (operation == "<") ? value..range.end : range.begin..value
+
+        [passed, failed]
+      end
+    end
+
+    Fallback = Data.define(:output) do
+      def passes?(_)
+        true
+      end
+    end
+
+    Workflow = Data.define(:rules) do
+      def output(part)
+        rules.detect { |rule| rule.passes?(part) }.output
+      end
+    end
+
+    workflows, parts = INPUT.split("\n\n")
+
+    WORKFLOWS = workflows.split("\n").each_with_object({}) do |line, flows|
+      data = WORKFLOW_MATCHER.match(line)
+      rules = data[:rules].split(",").map do |rule|
+        rule_data = RULE_MATCHER.match(rule)
+
+        if rule_data
+          Rule.new(
+            rating: rule_data[:rating],
+            operation: rule_data[:operation],
+            value: rule_data[:value].to_i,
+            output: rule_data[:output]
+          )
+        else
+          Fallback.new(output: rule)
+        end
+      end
+
+      flows[data[:name]] = Workflow.new(rules:)
+    end
+
+    PARTS = parts.split("\n").map do |part|
+      part.tr("{}", "").split(",").each_with_object({}) do |rating, ratings|
+        rating_data = RATING_MATCHER.match(rating)
+        ratings[rating_data[:rating]] = rating_data[:value].to_i
+      end
+    end
+
+    def accepted?(part)
+      flow = STARTING_FLOW
+
+      loop do
+        flow = WORKFLOWS[flow].output(part)
+
+        break true if flow == ACCEPTANCE_FLOW
+        break false if flow == REJECTION_FLOW
+      end
+    end
+
+    accepted = PARTS.select { |part| accepted?(part) }
+    solve!("The sum of acceptable parts' ratings is:", accepted.sum { |part| part.values.sum })
+
+    def valid_combinations(ratings, flow = STARTING_FLOW)
+      sizes = ratings.values.map(&:size)
+
+      return 0 if flow == REJECTION_FLOW || sizes.any?(&:zero?)
+      return sizes.reduce(:*) if flow == ACCEPTANCE_FLOW
+
+      WORKFLOWS[flow].rules.sum do |rule|
+        if rule.is_a?(Fallback)
+          valid_combinations(ratings, rule.output)
+        else
+          passed, ratings = rule.partition(ratings)
+          valid_combinations(passed, rule.output)
+        end
+      end
+    end
+
+    RANGES = {"x" => 1..4000, "m" => 1..4000, "a" => 1..4000, "s" => 1..4000}
+    solve!("The total number of valid combinations is:", valid_combinations(RANGES))

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

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