advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,121 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    class Communication
+      LOW = 0
+      HIGH = 1
+
+      attr_reader :inputs, :outputs, :pulses
+
+      def initialize(outputs)
+        @outputs = outputs
+        @inputs = []
+        @pulses = []
+      end
+
+      def register!(input)
+        @inputs << input
+      end
+    end
+
+    class Broadcast < Communication
+      def transmit(_input, pulse)
+        @pulses << pulse
+        pulse
+      end
+    end
+
+    class FlipFlop < Communication
+      def transmit(_input, pulse)
+        return if pulse == HIGH
+
+        @active = !@active
+
+        out = @active ? HIGH : LOW
+        @pulses << out
+
+        out
+      end
+    end
+
+    class Conjunction < Communication
+      def transmit(input, pulse)
+        @last_signals ||= Hash.new(LOW)
+        @last_signals[input] = pulse
+
+        out = (inputs.all? { |i| @last_signals[i] == HIGH }) ? LOW : HIGH
+        @pulses << out
+
+        out
+      end
+    end
+
+    MODULE_MATCHER = /\A(?<type>%|&)?(?<name>.+)\z/
+    CONFIGURATION = INPUT.split("\n").each_with_object({}) do |line, config|
+      label, outputs = line.split(" -> ")
+
+      outputs = outputs.split(", ")
+      label_data = MODULE_MATCHER.match(label)
+
+      config[label_data[:name]] =
+        case label_data[:type]
+        when "&" then Conjunction.new(outputs)
+        when "%" then FlipFlop.new(outputs)
+        else Broadcast.new(outputs)
+        end
+    end
+
+    CONFIGURATION.each do |name, comm|
+      comm.outputs.each { |output| CONFIGURATION[output]&.register!(name) }
+    end
+
+    def broadcast!(configuration)
+      transmissions = [[nil, Communication::LOW, "broadcaster"]]
+      pulses = [0, 0]
+
+      loop do
+        break if transmissions.empty?
+
+        sender, pulse, receiver = transmissions.shift
+        pulses[pulse] += 1
+
+        transmitter = configuration[receiver]
+        signal = transmitter&.transmit(sender, pulse)
+        next unless signal
+
+        transmitter.outputs.each { |output| transmissions << [receiver, signal, output] }
+      end
+
+      pulses
+    end
+
+    def deep_clone(configuration)
+      Marshal.load(Marshal.dump(configuration))
+    end
+
+    def press!(configuration, times)
+      configuration = deep_clone(configuration)
+      pulses = times.times.map { broadcast!(configuration) }
+      pulses.reduce { |a, b| a.zip(b).map(&:sum) }.reduce(:*)
+    end
+
+    solve!("The product of high and low pulse counts is:", press!(CONFIGURATION, 1000))
+
+    def presses_to(configuration, name, signal)
+      configuration = deep_clone(configuration)
+      count = 0
+
+      loop do
+        count += 1
+        broadcast!(configuration)
+        break count if configuration[name].pulses.include?(signal)
+      end
+    end
+
+    RECEIVER = "rx"
+
+    transmitter = CONFIGURATION.values.detect { |comm| comm.outputs.include?(RECEIVER) }
+    presses = transmitter.inputs.map { |input| presses_to(CONFIGURATION, input, Communication::HIGH) }.reduce(&:lcm)
+
+    solve!("The minimum number of presses to activate the receiver is:", presses)

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

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

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

@@ -0,0 +1,130 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+    require "set"
+
+    class Map
+      MOVEMENTS = [Vector[0, -1], Vector[1, 0], Vector[0, 1], Vector[-1, 0]]
+
+      attr_reader :size, :grid
+
+      def initialize
+        @grid = {}
+        @size = 0
+      end
+
+      def start
+        @start ||= @grid.key("S")
+      end
+
+      def [](coord)
+        @grid[coord]
+      end
+
+      def []=(coord, value)
+        @size = [size, coord[0] + 1].max
+        @grid[coord] = value
+      end
+
+      def neighbors(coord)
+        MOVEMENTS.filter_map do |movement|
+          plot = coord + movement
+          plot if self[plot] == "." || self[plot] == "S"
+        end
+      end
+
+      def corners
+        [Vector[0, 0], Vector[0, size - 1], Vector[size - 1, 0], Vector[size - 1, size - 1]]
+      end
+
+      def edges
+        [Vector[start[0], size - 1], Vector[0, start[1]], Vector[start[0], 0], Vector[size - 1, start[1]]]
+      end
+    end
+
+    MAP = INPUT.split("\n").each_with_index.each_with_object(Map.new) do |(line, y), map|
+      line.chars.each_with_index { |c, x| map[Vector[x, y]] = c }
+    end
+
+    def step_map(start, map)
+      queue = [[start, 0]]
+      counts = {}
+
+      loop do
+        break counts if queue.empty?
+        position, steps = queue.shift
+
+        next if counts.key?(position)
+        counts[position] = steps
+
+        map.neighbors(position).each do |plot|
+          queue << [plot, steps + 1]
+        end
+      end
+    end
+
+    def reachable_plots(steps, step)
+      steps.values.count { |s| s <= step && step % 2 == s % 2 }
+    end
+
+    counts = step_map(MAP.start, MAP)
+
+    STEPS ||= 64
+    solve!("The number of reachable plots is:", reachable_plots(counts, STEPS))
+
+    # A general solution here doesn't seem likely. This approach uses a bunch of
+    # assumptions about the input, including: (1) the number of steps we're checking
+    # divides evenly into our map's size, and (2) there are clear paths from the
+    # starting point to the edges. Under these assumptions, the input for the puzzle
+    # creates a diamond pattern that looks like the below, with a few different
+    # plot "tiles" to analyze:
+    #
+    #                               SA TT SA
+    #                            SA LA EE LA SA
+    #                         SA LA EE OO EE LA SA
+    #                      SA LA EE OO EE OO EE LA SA
+    #                      TT EE OO EE OO EE OO EE TT
+    #                      SA LA EE OO EE OO EE LA SA
+    #                         SA LA EE OO EE LA SA
+    #                            SA LA EE LA SA
+    #                               SA TT SA
+    #
+    # OO - An "odd" tile, where the elf has passed through all plots and lands
+    #      on an even step number.
+    # EE - An "even" tile, where the elf has passed through all plots and lands
+    #      on an even step number.
+    # LA - A "large angled" tile, where the elf passes through _most_ of the plots
+    #      starting at one corner.
+    # SA - A "small angled" tile, where the elf passes through _some_ of the plots
+    #      starting at one corner.
+    # TT - A "tip" tile, where the elf navigates from the center of one side to
+    #      all plots reachable within the remaining steps.
+    #
+    # We compute the number of plots by determining how many tiles of each type
+    # will show up in the final grid, and multiplying by the number of plots
+    # reached in those tiles.
+    def reachable_infinite_plots(map, steps)
+      tiles = (steps - map.start[0]) / map.size
+
+      starting_tile = step_map(map.start, map)
+      odds = starting_tile.values.count(&:odd?) * ((tiles - 1)**2)
+      evens = starting_tile.values.count(&:even?) * (tiles**2)
+
+      large_angle_steps = map.size + map.size / 2 - 1
+      small_angle_steps = map.size / 2 - 1
+      tip_steps = map.size - 1
+
+      angled_tiles = map.corners.map { |angle| step_map(angle, map) }
+      tip_tiles = map.edges.map { |tip| step_map(tip, map) }
+
+      large_angled_plots = angled_tiles.sum { |tile| reachable_plots(tile, large_angle_steps) } * (tiles - 1)
+      small_angled_plots = angled_tiles.sum { |tile| reachable_plots(tile, small_angle_steps) } * tiles
+      tip_plots = tip_tiles.sum { |tile| reachable_plots(tile, tip_steps) }
+
+      odds + evens + large_angled_plots + small_angled_plots + tip_plots
+    end
+
+    INFINITE_STEPS ||= 26501365
+    solve!("The number of reachable plots on an infinite grid is:", reachable_infinite_plots(MAP, INFINITE_STEPS))

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

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

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

@@ -0,0 +1,81 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+
+    Brick = Data.define(:starts, :ends) do |top|
+      def height
+        (ends[2] - starts[2]).abs + 1
+      end
+
+      def overlaps?(brick)
+        brick.xrange.overlap?(xrange) && brick.yrange.overlap?(yrange)
+      end
+
+      def xrange
+        x1, x2 = [starts[0], ends[0]].minmax
+        x1..x2
+      end
+
+      def yrange
+        y1, y2 = [starts[1], ends[1]].minmax
+        y1..y2
+      end
+    end
+
+    BRICKS = INPUT.split("\n").map do |line|
+      starts, ends = line.split("~").map { |coords| Vector[*coords.split(",").map(&:to_i)] }
+      Brick.new(starts:, ends:)
+    end
+
+    fall_sequence = BRICKS.sort_by { |b| [b.starts[2], b.ends[2]].min }
+
+    STACK = fall_sequence.each_with_object(Hash.new { |h, k| h[k] = [] }) do |brick, stack|
+      stop =
+        if stack.empty?
+          0
+        else
+          stack.keys.max.downto(0).detect do |z|
+            stack[z].any? { |b| b.overlaps?(brick) }
+          end || 0
+        end
+
+      ((stop + 1)..(stop + brick.height)).each do |z|
+        stack[z] << brick
+      end
+    end
+
+    SUPPORTS = BRICKS.each_with_object(Hash.new { |h, k| h[k] = {below: [], above: []} }) do |brick, supports|
+      z = STACK.keys.select { |k| STACK[k].include?(brick) }.max
+      STACK[z + 1].each do |b|
+        next unless b.overlaps?(brick)
+
+        supports[b][:above] << brick
+        supports[brick][:below] << b
+      end
+    end
+
+    def supported(brick, supports, without: [])
+      supports[brick][:below].select { |s| (supports[s][:above] - [brick] - without).empty? }
+    end
+
+    disintegratable = BRICKS.count { |brick| supported(brick, SUPPORTS).empty? }
+    solve!("The number of disintegratable bricks is:", disintegratable)
+
+    def falls_for(brick, supports)
+      supporting = supported(brick, supports)
+      return 0 if supporting.empty?
+
+      fallen = supporting
+      layer = supporting
+
+      loop do
+        break fallen.count if layer.empty?
+
+        layer = layer.flat_map { |b| supported(b, supports, without: fallen) }.uniq
+        fallen += layer
+      end
+    end
+
+    solve!("The sum of potential falling bricks is:", BRICKS.sum { |brick| falls_for(brick, SUPPORTS) })

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

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

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

@@ -0,0 +1,81 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+    require "rb_heap/heap"
+
+    MOVEMENTS = [Vector[0, -1], Vector[1, 0], Vector[0, 1], Vector[-1, 0]]
+    MAP = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), map|
+      line.chars.each_with_index { |c, x| map[Vector[x, y]] = c }
+    end
+
+    x1, x2 = MAP.keys.map { |p| p[0] }.minmax
+    y1, y2 = MAP.keys.map { |p| p[1] }.minmax
+
+    STARTS = (x1..x2).map { |x| Vector[x, y1] }.detect { |p| MAP[p] == "." }
+    ENDS = (x1..x2).map { |x| Vector[x, y2] }.detect { |p| MAP[p] == "." }
+
+    def slope_movements(tile)
+      case tile
+      when ">" then [Vector[1, 0]]
+      when "<" then [Vector[-1, 0]]
+      when "^" then [Vector[0, -1]]
+      when "v" then [Vector[0, 1]]
+      when "." then MOVEMENTS
+      end
+    end
+
+    def compress(map)
+      edges = map.each_with_object({}) do |(position, c), neighbors|
+        next if c == "#"
+
+        movements = yield(c)
+        neighbors[position] = movements.filter_map do |move|
+          coord = position + move
+          next if map[coord].nil? || map[coord] == "#"
+
+          [coord, 1]
+        end.to_h
+      end
+
+      loop do
+        coord, neighbors = edges.detect { |coord, connections| connections.size == 2 }
+        break if coord.nil?
+
+        a, ca, b, cb = neighbors.flatten
+        edges[a].delete(coord)
+        edges[b].delete(coord)
+
+        cost = ca + cb
+
+        edges[a][b] = cost
+        edges[b][a] = cost
+
+        edges.delete(coord)
+      end
+
+      edges
+    end
+
+    def longest_path(edges, from:, to:, seen: {from => true}, cost: 0)
+      return cost if from == to
+
+      edges[from].filter_map do |neighbor, steps|
+        next if seen[neighbor]
+
+        longest_path(
+          edges,
+          from: neighbor,
+          to:,
+          seen: seen.merge(neighbor => true),
+          cost: cost + steps
+        )
+      end.max
+    end
+
+    edges = compress(MAP) { |t| slope_movements(t) }
+    solve!("The longest path to the end is:", longest_path(edges, from: STARTS, to: ENDS))
+
+    edges = compress(MAP) { MOVEMENTS }
+    solve!("The longest path to the end without slopes is:", longest_path(edges, from: STARTS, to: ENDS))

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

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

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

@@ -0,0 +1,63 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "matrix"
+    require "z3"
+
+    Hailstone = Data.define(:position, :velocity) do
+      def intersection(other)
+        x, y = position.to_a
+        dx, dy = velocity.to_a
+        ox, oy = other.position.to_a
+        odx, ody = other.velocity.to_a
+
+        determinant = ody * dx - odx * dy
+        return nil if determinant == 0
+
+        t = (odx * (y - oy) - ody * (x - ox)) / determinant.to_f
+        nx = x + t * dx
+        ny = y + t * dy
+
+        return nil if (nx - x) * dx < 0 || (nx - ox) * odx < 0
+
+        Vector[nx, ny]
+      end
+    end
+
+    HAILSTONES = INPUT.split("\n").map do |line|
+      position, velocity = line.split(" @ ")
+
+      position = Vector[*position.tr(" ", "").split(",").map(&:to_i)]
+      velocity = Vector[*velocity.tr(" ", "").split(",").map(&:to_i)]
+
+      Hailstone.new(position:, velocity:)
+    end
+
+    RANGE ||= 200000000000000..400000000000000
+
+    count = HAILSTONES.combination(2).count do |a, b|
+      intersection = a.intersection(b)
+      next false if intersection.nil?
+
+      RANGE.cover?(intersection[0]) && RANGE.cover?(intersection[1])
+    end
+
+    solve!("The number of overlapping trajectories is:", count)
+
+    # I don't love pulling in Z3 here, but this is incredibly non-trivial to solve
+    # algorithmically.
+    x, y, z, dx, dy, dz = %w[x y z dx dy dz].map { |c| Z3::Int(c) }
+    solver = HAILSTONES.first(3).each_with_object(Z3::Solver.new) do |hailstone, solver|
+      i, j, k = hailstone.position.to_a
+      di, dj, dk = hailstone.velocity.to_a
+
+      time = Z3::Int("t#{i}")
+      solver.assert(time > 0)
+      solver.assert(x + dx * time == i + di * time)
+      solver.assert(y + dy * time == j + dj * time)
+      solver.assert(z + dz * time == k + dk * time)
+    end
+
+    raise "Not all stones can be hit by a single rock" unless solver.satisfiable?
+    solve!("The sum of your rock's coordinates should be:", [x, y, z].sum { |p| solver.model[p].to_i })

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

@@ -0,0 +1,28 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    require "set"
+
+    WIRES = INPUT.split("\n").each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |line, wires|
+      component, connections = line.split(": ")
+      components = connections.split(" ")
+
+      wires[component] += components
+      components.each { |c| wires[c] << component }
+    end
+
+    def split(wires)
+      remaining = wires.keys.to_set
+
+      loop do
+        external = 0
+        extract = remaining.max_by { |node| (wires[node].to_set - remaining).size.tap { |c| external += c } }
+
+        break [remaining, wires.keys.to_set - remaining] if external == 3
+        remaining.delete(extract)
+      end
+    end
+
+    a, b = split(WIRES)
+    solve!("The product of group sizes is:", a.size * b.size)

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

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

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

@@ -0,0 +1,11 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    numbers = INPUT.split("\n").map { |line| line.split(/\s+/) }
+
+    FIRST = numbers.map(&:first).map(&:to_i)
+    SECOND = numbers.map(&:last).map(&:to_i)
+
+    solve! "The total of distances is:", FIRST.sort.zip(SECOND.sort).sum { |a, b| (b - a).abs }
+    solve! "The total of similarity scores is:", FIRST.sum { |number| number * SECOND.count(number) }

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    REPORTS = INPUT.split("\n").map { |line| line.split.map(&:to_i) }
+
+    def safe?(report, tolerance: 0)
+      variants = (tolerance > 0) ? report.combination(report.length - 1) : []
+
+      unless report == report.sort || report == report.sort.reverse
+        return variants.any? { |variant| safe?(variant, tolerance: tolerance - 1) }
+      end
+
+      min = Float::INFINITY
+      max = -Float::INFINITY
+
+      report.each_cons(2) do |a, b|
+        gap = (a - b).abs
+        min = [gap, min].min
+        max = [gap, max].max
+      end
+
+      return variants.any? { |variant| safe?(variant, tolerance: tolerance - 1) } unless min >= 1 && max <= 3
+
+      true
+    end
+
+    solve!(REPORTS.count { |report| safe?(report) })
+    solve!(REPORTS.count { |report| safe?(report, tolerance: 1) })

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

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

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

@@ -0,0 +1,33 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    MUL_MATCHER = /mul\((\d+),(\d+)\)/
+    DO_MATCHER = /do\(\)/
+    DONT_MATCHER = /don't\(\)/
+    COMMAND_MATCHER = /(#{MUL_MATCHER}|#{DO_MATCHER}|#{DONT_MATCHER})/
+
+    solve!(
+      "The sum of `mul` instruction values is:",
+      INPUT.scan(MUL_MATCHER).sum { |a, b| a.to_i * b.to_i }
+    )
+
+    def scan(input)
+      enable = true
+      enabled = input.scan(COMMAND_MATCHER).filter_map do |match,|
+        case match
+        when MUL_MATCHER
+          match.scan(MUL_MATCHER)[0] if enable
+        when DO_MATCHER
+          enable = true
+          nil
+        when DONT_MATCHER
+          enable = false
+          nil
+        end
+      end
+
+      enabled.sum { |a, b| a.to_i * b.to_i }
+    end
+
+    solve!("The sum of only enabled `mul` instruction values is:", scan(input))

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

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

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

@@ -0,0 +1,42 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    ADJACENCIES = ([-1, 0, 1].repeated_permutation(2).to_a - [[0, 0]]).map { |x, y| Vector[x, y] }
+    GRID = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), grid|
+      line.chars.each_with_index do |cell, x|
+        grid[Vector[x, y]] = cell
+      end
+    end
+
+    def search_for(grid, target)
+      search = target.chars
+
+      coords = grid.filter_map { |(position, value)| position if value == search[0] }
+      searches = coords.flat_map do |c|
+        ADJACENCIES.filter_map do |a|
+          test = c + a
+          [test, a] if grid[test] == search[1]
+        end
+      end
+
+      search.drop(2).inject(searches) do |matches, query|
+        matches.filter_map do |(c, d)|
+          test = c + d
+          [test, d] if grid[test] == query
+        end
+      end
+    end
+
+    solve!("The XMAS count is:", search_for(GRID, "XMAS").count)
+
+    diagonal_centers = search_for(GRID, "MAS").each_with_object(Hash.new { |h, k| h[k] = [] }) do |(c, d), results|
+      results[c - d] << d if d[0].abs == d[1].abs
+    end
+    x_mases = diagonal_centers.select { |_, vectors| vectors.length > 1 }.count do |c, vectors|
+      vectors.combination(2).count { |da, db| da.inner_product(db) == 0 }
+    end
+
+    solve!("The X-MAS count is:", x_mases)

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

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