advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,95 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    BITS = INPUT.chars.map { |c| format("%04b", c.to_i(16)) }.join
+
+    class Packet
+      def initialize(stream)
+        @stream = stream
+        @cursor = 0
+      end
+
+      def read(length)
+        value = @stream[@cursor, length]
+        @cursor += length
+
+        value
+      end
+
+      def value(length)
+        read(length).to_i(2)
+      end
+
+      def end?
+        @cursor >= @stream.length - 1
+      end
+    end
+
+    class Transmission
+      attr_reader :packet
+
+      Signal = Struct.new(:version, :value)
+
+      CALCULATIONS = {
+        0 => ->(signals) { signals.sum(&:value) },
+        1 => ->(signals) { signals.map(&:value).inject(:*) },
+        2 => ->(signals) { signals.map(&:value).min },
+        3 => ->(signals) { signals.map(&:value).max },
+        5 => ->(signals) { (signals[0].value > signals[1].value) ? 1 : 0 },
+        6 => ->(signals) { (signals[0].value < signals[1].value) ? 1 : 0 },
+        7 => ->(signals) { (signals[0].value == signals[1].value) ? 1 : 0 }
+      }.freeze
+
+      def initialize(packet)
+        @packet = packet
+      end
+
+      def signal
+        version = packet.value(3)
+        type_id = packet.value(3)
+
+        case type_id
+        when 4
+          Signal.new(version, literal)
+        else
+          signals = subpackets
+
+          Signal.new(
+            version + signals.sum(&:version),
+            CALCULATIONS[type_id].call(signals)
+          )
+        end
+      end
+
+      private
+
+      def literal
+        value = ""
+
+        loop do
+          continue = packet.value(1) == 1
+          value << packet.read(4)
+
+          break value.to_i(2) unless continue
+        end
+      end
+
+      def subpackets
+        case packet.value(1)
+        when 0
+          length = packet.value(15)
+          subpacket = Packet.new(packet.read(length))
+
+          collection = []
+          collection << Transmission.new(subpacket).signal until subpacket.end?
+          collection
+        when 1
+          packet.value(11).times.map { signal }
+        end
+      end
+    end
+
+    signal = Transmission.new(Packet.new(BITS)).signal
+    solve!("The version sum of the transmission is:", signal.version)
+    solve!("The outer value of the transmission is:", signal.value)

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

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

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

@@ -0,0 +1,38 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    TARGET_MATCHER = /\Atarget area: x=(?<x>.+), y=(?<y>.+)\z/
+
+    ranges = INPUT.match(TARGET_MATCHER)
+
+    X_RANGE = eval(ranges[:x]).freeze
+    Y_RANGE = eval(ranges[:y]).freeze
+    STARTING_POSITION = [0, 0].freeze
+
+    def hits?(dx, dy)
+      x, y = STARTING_POSITION
+
+      loop do
+        x += dx
+        y += dy
+
+        break true if X_RANGE.include?(x) && Y_RANGE.include?(y)
+        break false if x > X_RANGE.end || y < Y_RANGE.begin
+
+        dx -= 1 if dx > 0
+        dy -= 1
+      end
+    end
+
+    def peak(dy)
+      dy * (dy + 1) / 2
+    end
+
+    POSSIBLE_X = (Math.sqrt(2 * X_RANGE.begin).floor..X_RANGE.end).to_a.freeze
+    POSSIBLE_Y = (Y_RANGE.begin..-Y_RANGE.begin).to_a.freeze
+
+    hits = POSSIBLE_X.product(POSSIBLE_Y).select { |dx, dy| hits?(dx, dy) }
+
+    solve!("The maximum height reached on a successful shot is:", hits.map { |_, dy| peak(dy) }.max)
+    solve!("The total number of unique successful shots is:", hits.count)

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

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

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

@@ -0,0 +1,75 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    class SnailfishNumber < Struct.new(:pair)
+      EXPLODE_AT = 4
+      SPLIT_AT = 10
+
+      def +(other)
+        number = [pair, other.pair]
+
+        loop do
+          changed, number, = explode(number)
+          next if changed
+
+          changed, number = split(number)
+          break number unless changed
+        end
+
+        SnailfishNumber.new(number)
+      end
+
+      def magnitude(number = pair)
+        number.is_a?(Numeric) ? number : (3 * magnitude(number[0])) + (2 * magnitude(number[1]))
+      end
+
+      private
+
+      def explode(number, depth = 0)
+        return [false, number, nil, nil] if number.is_a?(Numeric)
+        return [true, 0, number[0], number[1]] if depth >= EXPLODE_AT
+
+        changed, n, l, r = explode(number[0], depth + 1)
+        return [true, [n, add_left(number[1], r)], l, nil] if changed
+
+        changed, n, l, r = explode(number[1], depth + 1)
+        return [true, [add_right(number[0], l), n], nil, r] if changed
+
+        [false, number, nil, nil]
+      end
+
+      def split(number)
+        case number
+        when Numeric
+          half = number / 2.0
+          (number >= SPLIT_AT) ? [true, [half.floor, half.ceil]] : [false, number]
+        else
+          changed, n = split(number[0])
+          return [true, [n, number[1]]] if changed
+
+          changed, n = split(number[1])
+          [changed, [number[0], n]]
+        end
+      end
+
+      def add_left(number, v)
+        return number if v.nil?
+
+        number.is_a?(Numeric) ? number + v : [add_left(number[0], v), number[1]]
+      end
+
+      def add_right(number, v)
+        return number if v.nil?
+
+        number.is_a?(Numeric) ? number + v : [number[0], add_right(number[1], v)]
+      end
+    end
+
+    SNAILFISH_NUMBERS = INPUT.split("\n").map { |line| SnailfishNumber.new(eval(line)) }
+
+    solve!("The magnitude of the final sum is:", SNAILFISH_NUMBERS.inject(:+).magnitude)
+    solve!(
+      "The largest magnitude of any sum is:",
+      SNAILFISH_NUMBERS.permutation(2).map { |a, b| (a + b).magnitude }.max
+    )

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

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

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

@@ -0,0 +1,75 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    require "set"
+
+    SCANS = INPUT.split("\n\n").map do |scan|
+      _name, *coords = scan.split("\n")
+      coords.map { |coord| coord.split(",").map(&:to_i) }
+    end.freeze
+
+    class Scanner
+      ROTATIONS = [0, 1, 2].permutation.to_a.freeze
+      INVERSIONS = [1, -1].repeated_permutation(3).to_a.freeze
+
+      def initialize(scan)
+        @scan = scan
+      end
+
+      def test
+        ROTATIONS.each do |(x, y, z)|
+          INVERSIONS.each do |(dx, dy, dz)|
+            yield @scan.map { |beacon| [beacon[x] * dx, beacon[y] * dy, beacon[z] * dz] }
+          end
+        end
+      end
+    end
+
+    def align(a, b)
+      Scanner.new(b).test do |orientation|
+        a.each do |(ax, ay, az)|
+          orientation.each do |(bx, by, bz)|
+            origin = [bx - ax, by - ay, bz - az]
+            beacons = orientation.map { |(x, y, z)| [x - origin[0], y - origin[1], z - origin[2]] }
+
+            return [true, origin, beacons] if beacons.count { |b| a.include?(b) } >= 12
+          end
+        end
+      end
+
+      [false, nil, nil]
+    end
+
+    positions = {0 => [0, 0, 0]}
+    beacons = {0 => Set.new(SCANS[0])}
+    tried = Set.new
+
+    loop do
+      break if positions.count == SCANS.count
+
+      SCANS.each_index do |i|
+        next if positions[i]
+
+        positions.keys.each do |j| # rubocop:disable Style/HashEachMethods
+          tried.include?([i, j]) ? next : tried << [i, j]
+
+          success, position, scan = align(beacons[j], SCANS[i])
+
+          next unless success
+
+          positions[i] = position
+          beacons[i] = Set.new(scan)
+
+          break
+        end
+      end
+    end
+
+    solve!("The total beacon count is:", beacons.values.inject(:+).count)
+
+    distances = positions.values.combination(2).map do |a, b|
+      a.zip(b).sum { |i, j| (i - j).abs }
+    end
+
+    solve!("The maximum distance between beacons is:", distances.max)

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

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

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

@@ -0,0 +1,75 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    require "set"
+
+    class Coord < Struct.new(:x, :y)
+      GROUP_LOCATIONS = [-1, 0, 1].product([-1, 0, 1]).freeze
+
+      def group
+        @group ||= GROUP_LOCATIONS.map { |dy, dx| Coord.new(x + dx, y + dy) }
+      end
+
+      def hash
+        [x, y].hash
+      end
+    end
+
+    class Image
+      def initialize(grid, algorithm)
+        @grid = grid
+        @algorithm = algorithm
+      end
+
+      def refine
+        default = @grid.default ? @algorithm.last : @algorithm.first
+        refined = (coords + edges).each_with_object(Hash.new(default)) do |coord, refined|
+          refined[coord] = output_for(coord)
+        end
+
+        Image.new(refined, @algorithm)
+      end
+
+      def count
+        @grid.values.count(&:itself)
+      end
+
+      private
+
+      def output_for(coord)
+        value = coord.group.reduce(0) { |v, n| (v * 2) + (@grid[n] ? 1 : 0) }
+        @algorithm[value]
+      end
+
+      def coords
+        @coords ||= Set.new(@grid.keys)
+      end
+
+      def edges
+        minx, maxx = coords.map(&:x).minmax
+        miny, maxy = coords.map(&:y).minmax
+
+        edges =
+          [minx - 1, maxx + 1].product(((miny - 1)..(maxy + 1)).to_a) +
+          (minx..maxx).to_a.product([miny - 1, maxy + 1])
+
+        Set.new(edges.map { |x, y| Coord.new(x, y) })
+      end
+    end
+
+    algorithm, image = INPUT.split("\n\n")
+
+    ALGORITHM = algorithm.chars.map { |c| c == "#" }.freeze
+    IMAGE = image.split("\n").flat_map.with_index do |line, y|
+      line.chars.map.with_index do |c, x|
+        [Coord.new(x, y), c == "#"]
+      end
+    end.to_h
+
+    image = Image.new(IMAGE, ALGORITHM)
+    2.times { image = image.refine }
+    solve!("The number of lit pixels after 2 refinements is:", image.count)
+
+    48.times { image = image.refine }
+    solve!("The number of lit pixels after 50 refinements is:", image.count)

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

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

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

@@ -0,0 +1,88 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    PLAYER_MATCHER = /\APlayer \d+ starting position: (?<position>\d+)\z/
+    STARTING_POSITIONS = INPUT.split("\n").map do |line|
+      match = line.match(PLAYER_MATCHER)
+      match[:position].to_i - 1
+    end
+
+    class Game
+      ROLLS = (1..100).to_a
+
+      WINNING_SCORE = 1_000
+      POSITION_COUNT = 10
+      ROLL_COUNT = 3
+
+      attr_reader :rolls
+
+      def initialize
+        @rolls = 0
+      end
+
+      def play(positions)
+        scores = positions.map { 0 }
+
+        loop do
+          positions = positions.map.with_index do |position, i|
+            position = (position + roll!) % POSITION_COUNT
+            scores[i] += position + 1
+
+            break false if scores[i] >= WINNING_SCORE
+
+            position
+          end
+
+          break scores unless positions
+        end
+      end
+
+      private
+
+      def roll!
+        roll = ROLL_COUNT.times.sum { |r| ROLLS[(@rolls + r) % ROLLS.count] }
+        @rolls += ROLL_COUNT
+
+        roll
+      end
+    end
+
+    class QuantumGame
+      SIDES = [1, 2, 3].freeze
+      POSSIBILITIES = SIDES.product(SIDES, SIDES).map(&:sum).freeze
+
+      WINNING_SCORE = 21
+      POSITION_COUNT = 10
+
+      def initialize
+        @universes = {}
+      end
+
+      def play(positions, scores = positions.map { 0 }, player = 0)
+        @universes[[positions, scores, player]] ||= begin
+          winner = scores.any? { |score| score >= WINNING_SCORE }
+          return scores.map { |s| (s >= WINNING_SCORE) ? 1 : 0 } if winner # rubocop:disable Lint/NoReturnInBeginEndBlocks
+
+          POSSIBILITIES.map do |roll|
+            position = positions[player]
+            position = (position + roll) % POSITION_COUNT
+
+            position_quanta = positions.dup
+            score_quanta = scores.dup
+
+            position_quanta[player] = position
+            score_quanta[player] += position + 1
+
+            play(position_quanta, score_quanta, (player + 1) % positions.count)
+          end.transpose.map(&:sum)
+        end
+      end
+    end
+
+    game = Game.new
+    scores = game.play(STARTING_POSITIONS)
+    solve!("The final state of the dice game is:", scores.min * game.rolls)
+
+    scores = QuantumGame.new.play(STARTING_POSITIONS)
+    solve!("The largest number of wins across all universes is:", scores.max)

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

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

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

@@ -0,0 +1,82 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    class Cuboid
+      attr_reader :x, :y, :z
+
+      def initialize(x:, y:, z:)
+        @x = x
+        @y = y
+        @z = z
+      end
+
+      def size
+        @x.size * @y.size * @z.size
+      end
+
+      def &(other)
+        xint = intersection(x, other.x)
+        yint = intersection(y, other.y)
+        zint = intersection(z, other.z)
+
+        return nil unless xint && yint && zint
+
+        Cuboid.new(x: xint, y: yint, z: zint)
+      end
+
+      private
+
+      def intersection(first, second)
+        return nil if first.end < second.begin || second.end < first.begin
+
+        [first.begin, second.begin].max..[first.end, second.end].min
+      end
+    end
+
+    def unique_cubes(cuboid, overlays)
+      overwrites = overlays.filter_map { |overlay| cuboid & overlay }
+      overwritten = overwrites.each_index.sum { |i| unique_cubes(overwrites[i], overwrites.drop(i + 1)) }
+
+      cuboid.size - overwritten
+    end
+
+    def active_cubes(steps)
+      cuboids = steps.map(&:last)
+      steps.each_with_index.sum do |(state, cuboid), i|
+        next 0 unless state
+
+        unique_cubes(cuboid, cuboids.drop(i + 1))
+      end
+    end
+
+    STEP_MATCHER = /
+      (?<state>on|off)\s
+      x=(?<x>-?\d+\.\.-?\d+),
+      y=(?<y>-?\d+\.\.-?\d+),
+      z=(?<z>-?\d+\.\.-?\d+)
+    /x
+
+    STEPS = INPUT.split("\n").map do |line|
+      match = line.match(STEP_MATCHER)
+
+      [
+        match[:state] == "on",
+        Cuboid.new(
+          x: eval(match[:x]),
+          y: eval(match[:y]),
+          z: eval(match[:z])
+        )
+      ]
+    end.freeze
+
+    INITIALIZATION_REGION = Cuboid.new(x: -50..50, y: -50..50, z: -50..50).freeze
+    INITIALIZATION_STEPS = STEPS.filter_map do |state, cuboid|
+      initializer = cuboid & INITIALIZATION_REGION
+      next unless initializer
+
+      [state, initializer]
+    end
+
+    solve!("The number of cubes on after initialization is:", active_cubes(INITIALIZATION_STEPS))
+    solve!("The number of cubes on after a full reboot is:", active_cubes(STEPS))

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

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