advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,167 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    require "rb_heap/heap"
+
+    class Amphipod
+      COSTS = {A: 1, B: 10, C: 100, D: 1_000}.freeze
+      ROOMS = {A: 0, B: 1, C: 2, D: 3}.freeze
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type.to_sym
+      end
+
+      def cost
+        COSTS[@type]
+      end
+
+      def target
+        ROOMS[@type]
+      end
+    end
+
+    class Burrow
+      ROOM_COORDS = [2, 4, 6, 8].freeze
+
+      attr_reader :rooms, :hallway
+
+      def initialize(rooms, hallway = Array.new(11))
+        @rooms = rooms
+        @hallway = hallway
+      end
+
+      def solved?
+        rooms.each_with_index.all? { |room, i| room.all? { |amphipod| amphipod&.target == i } }
+      end
+
+      def enter(hall:, room:)
+        a = hallway[hall]
+        return if a.nil?
+
+        r = rooms[room]
+        return if r.any? { |x| !x.nil? && x.type != a.type }
+        return unless possible?(hall: hall, room: room)
+
+        cost = energy_needed(hall: hall, room: room)
+
+        i = r.count(&:nil?) - 1
+
+        new_rooms = rooms.map(&:dup)
+        new_hallway = hallway.dup
+
+        new_rooms[room][i] = a
+        new_hallway[hall] = nil
+
+        enter_cost = i + 1
+
+        [(cost + enter_cost) * a.cost, Burrow.new(new_rooms, new_hallway)]
+      end
+
+      def leave(hall:, room:)
+        return unless hallway[hall].nil?
+        return unless possible?(hall: hall, room: room)
+
+        r = rooms[room]
+        return if r.all?(&:nil?)
+
+        cost = energy_needed(hall: hall, room: room)
+
+        a, i = r.each_with_index.detect { |a, _| !a.nil? }
+        return if a.nil?
+        return if a.target == room && r.all? { |x| x.nil? || x.type == a.type }
+
+        new_rooms = rooms.map(&:dup)
+        new_hallway = hallway.dup
+
+        new_hallway[hall] = a
+        new_rooms[room][i] = nil
+
+        leave_cost = i + 1
+
+        [(cost + leave_cost) * a.cost, Burrow.new(new_rooms, new_hallway)]
+      end
+
+      def eql?(other)
+        hash == other.hash
+      end
+
+      def hash
+        [hallway, rooms].hash
+      end
+
+      private
+
+      def energy_needed(hall:, room:)
+        (ROOM_COORDS[room] - hall).abs
+      end
+
+      def possible?(hall:, room:)
+        room = ROOM_COORDS[room]
+        left = hall <= room
+        range = left ? (hall + 1)..(room - 1) : (room + 1)..(hall - 1)
+
+        hallway[range].all?(&:nil?)
+      end
+    end
+
+    def organize(rooms)
+      burrow = Burrow.new(rooms)
+
+      queue = Heap.new { |a, b| a[0] < b[0] }
+      queue << [0, burrow, [burrow]]
+
+      costs = {}
+      costs[burrow] = 0
+
+      loop do
+        energy, burrow = queue.pop
+        break energy if burrow.solved?
+
+        next if energy > costs[burrow]
+
+        costs[burrow] = energy
+
+        burrow.hallway.each_with_index do |a, i|
+          next if Burrow::ROOM_COORDS.include?(i)
+
+          if a.nil?
+            exits = burrow.rooms.each_index.filter_map { |j| burrow.leave(hall: i, room: j) }
+            exits.each do |exit_cost, exit_burrow|
+              cost = energy + exit_cost
+              next if costs.key?(exit_burrow) && cost >= costs[exit_burrow]
+
+              costs[exit_burrow] = cost
+              queue << [cost, exit_burrow]
+            end
+          else
+            entry = burrow.enter(hall: i, room: a.target)
+            next if entry.nil?
+
+            entry_cost, entry_burrow = entry
+            cost = energy + entry_cost
+            next if costs.key?(entry_burrow) && cost >= costs[entry_burrow]
+
+            costs[entry_burrow] = cost
+            queue << [cost, entry_burrow]
+          end
+        end
+      end
+    end
+
+    ROOMS = INPUT.scan(/\w/).each_slice(4).each_with_object(Array.new(4) { [] }) do |types, rooms|
+      types.each_with_index { |t, i| rooms[i] << Amphipod.new(t) }
+    end
+
+    energy = organize(ROOMS)
+    solve!("The minimum energy to organize the amphipods is:", energy)
+
+    INSERTIONS = [%w[D D], %w[C B], %w[B A], %w[A C]].freeze
+    UPDATED_ROOMS = ROOMS.map.with_index do |r, i|
+      r.dup.insert(1, *INSERTIONS[i].map { |c| Amphipod.new(c) })
+    end.freeze
+
+    energy = organize(UPDATED_ROOMS)
+    solve!("The minimum energy to organize the full set of amphipods is:", energy)

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

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

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

@@ -0,0 +1,65 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    # NOTE: I wanted to write an ALU class, but since this problem is set up to
+    # rely on extremely specific details of the input, and the problem space as
+    # defined is basically impossible to brute-force, there's no point.
+    #
+    # You _could_ write something to detect the underlying behavior and identify
+    # pairs dynamically by testing the effect of various digit combinations on the
+    # magnitude of the final output, but that sounds like a lot of work when we
+    # already know what the input does.
+    #
+    # Instead, I've just hard-coded something to run through the input handler
+    # chunks, detecting whether the chunk describes a "head" or a "tail" input, and
+    # pushing and popping indices to create matched pairs as a result. I'm assuming
+    # that other inputs have the same characteristics, but different values.
+
+    HANDLERS = INPUT.split("inp w\n").drop(1).freeze
+    DIVISOR_MATCHER = /^div z (?<divisor>\d+)$/
+    HEAD_MATCHER = /\Aadd y -?\d+\z/
+    TAIL_MATCHER = /\Aadd x -?\d+\z/
+
+    PAIRS = begin
+      pairs = {}
+      heads = []
+
+      HANDLERS.each_with_index do |handler, i|
+        divisor = handler.match(DIVISOR_MATCHER)[:divisor].to_i
+        lines = handler.split("\n")
+
+        case divisor
+        when 1
+          head = lines.grep(HEAD_MATCHER).last
+          head_diff = head.split.last.to_i
+
+          heads << [i, head_diff]
+        else
+          tail = lines.grep(TAIL_MATCHER).first
+          tail_diff = tail.split.last.to_i
+
+          head, head_diff = heads.pop
+          pairs[[head, i]] = head_diff + tail_diff
+        end
+      end
+
+      pairs
+    end.freeze
+
+    def max_for(pairs)
+      pairs.each_with_object(Array.new(pairs.length * 2)) do |((i, j), diff), value|
+        value[i] = (diff < 0) ? 9 : 9 - diff
+        value[j] = (diff < 0) ? 9 + diff : 9
+      end.join
+    end
+
+    def min_for(pairs)
+      pairs.each_with_object(Array.new(pairs.length * 2)) do |((i, j), diff), value|
+        value[i] = (diff < 0) ? 1 - diff : 1
+        value[j] = (diff < 0) ? 1 : 1 + diff
+      end.join
+    end
+
+    solve!("The largest accepted model number is:", max_for(pairs))
+    solve!("The smallest accepted model number is:", min_for(pairs))

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

@@ -0,0 +1,43 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    CUCUMBERS = INPUT.split("\n").map(&:chars).freeze
+    HEIGHT = CUCUMBERS.size
+    WIDTH = CUCUMBERS[0].size
+
+    HERDS = %w[> v].freeze
+    EMPTY = ".".freeze
+    MOVEMENTS = {">" => [1, 0], "v" => [0, 1]}.freeze
+
+    def step(cucumbers)
+      HERDS.each_with_object(Array.new(HEIGHT) { Array.new(WIDTH) { "." } }) do |herd, updated|
+        cucumbers.each_with_index do |row, y|
+          row.each_with_index do |cucumber, x|
+            next unless cucumber == herd
+
+            dx, dy = MOVEMENTS[cucumber]
+            nx = (x + dx) % WIDTH
+            ny = (y + dy) % HEIGHT
+
+            move = (herd == ">") ? cucumbers[ny][nx] == "." : cucumbers[ny][nx] != herd && updated[ny][nx] == "."
+
+            fx, fy = move ? [nx, ny] : [x, y]
+            updated[fy][fx] = cucumber
+          end
+        end
+      end
+    end
+
+    cucumbers = CUCUMBERS
+    steps = 0
+
+    loop do
+      steps += 1
+      updated = step(cucumbers)
+      break steps if cucumbers == updated
+
+      cucumbers = updated
+    end
+
+    solve!("The first step on which no sea cucumbers move is:", steps)

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

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

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

@@ -0,0 +1,15 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    ELVES = INPUT.split("\n\n").map { |rows| rows.split("\n").map(&:to_i) }
+
+    solve!(
+      "The maximum calorie count carried by any elf is:",
+      ELVES.map(&:sum).max
+    )
+
+    solve!(
+      "The total calorie count of the top three elves is:",
+      ELVES.map(&:sum).sort.last(3).sum
+    )

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

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

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

@@ -0,0 +1,42 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    ROUNDS = INPUT.split("\n").map(&:split).freeze
+
+    SHAPE_SCORES = {rock: 1, paper: 2, scissors: 3}.freeze
+    OUTCOME_SCORES = {win: 6, draw: 3, loss: 0}.freeze
+
+    PLAYS = {"A" => :rock, "B" => :paper, "C" => :scissors}.freeze
+    RESPONSES = {"X" => :rock, "Y" => :paper, "Z" => :scissors}.freeze
+    OUTCOMES = {"X" => :loss, "Y" => :draw, "Z" => :win}.freeze
+
+    RESULTS = {
+      rock: {rock: :draw, paper: :win, scissors: :loss},
+      paper: {rock: :loss, paper: :draw, scissors: :win},
+      scissors: {rock: :win, paper: :loss, scissors: :draw}
+    }.freeze
+
+    def response_score_for((play, response))
+      response = RESPONSES[response]
+      outcome = RESULTS[PLAYS[play]][response]
+
+      OUTCOME_SCORES[outcome] + SHAPE_SCORES[response]
+    end
+
+    solve!(
+      "Your total score following the move-based strategy guide is:",
+      ROUNDS.sum { |round| response_score_for(round) }
+    )
+
+    def outcome_score_for((play, outcome))
+      outcome = OUTCOMES[outcome]
+      response = RESULTS[PLAYS[play]].key(outcome)
+
+      OUTCOME_SCORES[outcome] + SHAPE_SCORES[response]
+    end
+
+    solve!(
+      "Your total score following the outcome-based strategy guide is:",
+      ROUNDS.sum { |round| outcome_score_for(round) }
+    )

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    RUCKSACKS = INPUT.split("\n").map do |row|
+      items = row.chars.to_a
+      items.each_slice(items.size / 2).to_a
+    end
+
+    def score_for(item)
+      case item
+      when /[A-Z]/ then item.ord - "A".ord + 27
+      when /[a-z]/ then item.ord - "a".ord + 1
+      end
+    end
+
+    shared = RUCKSACKS.flat_map { |rucksack| rucksack.reduce(&:&) }
+
+    solve!(
+      "The sum of shared item priorities is:",
+      shared.sum { |item| score_for(item) }
+    )
+
+    badges = RUCKSACKS.each_slice(3).map { |elves| elves.map(&:flatten).reduce(&:&)[0] }
+
+    solve!(
+      "The sum of badge priorities is:",
+      badges.sum { |item| score_for(item) }
+    )

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

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

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

@@ -0,0 +1,20 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    RANGES = INPUT.split("\n").map do |pair|
+      pair.split(",").map do |range|
+        begins, ends = range.split("-").map(&:to_i)
+        begins..ends
+      end
+    end
+
+    solve!(
+      "The number of pairs where one range fully contains the other is:",
+      RANGES.count { |a, b| a.cover?(b) || b.cover?(a) }
+    )
+
+    solve!(
+      "The number of pairs with any overlap in their ranges is:",
+      RANGES.count { |a, b| a.begin <= b.end && a.end >= b.begin }
+    )

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

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

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

@@ -0,0 +1,37 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    drawing, procedure = INPUT.split("\n\n")
+
+    STACKS =
+      drawing.split("\n")[...-1].reverse.map do |row|
+        row.chars.each_slice(4).map { |stack| stack[1] }
+      end.reduce(:zip).map do |stack|
+        stack.flatten.compact.reject { |crate| crate == " " }
+      end
+
+    STEP_MATCHER = /move (?<count>\d+) from (?<from>\d+) to (?<to>\d+)/
+    PROCEDURE = procedure.enum_for(:scan, STEP_MATCHER).map { Regexp.last_match }
+
+    def rearrange(stacks, step, multiple: false)
+      stacks = stacks.map(&:dup)
+
+      moved = stacks[step[:from].to_i - 1].pop(step[:count].to_i)
+      moved = moved.reverse unless multiple
+
+      stacks[step[:to].to_i - 1] += moved
+      stacks
+    end
+
+    stacks = PROCEDURE.reduce(STACKS) { |result, step| rearrange(result, step) }
+    solve!(
+      "The top crates after rearranging are:",
+      stacks.map(&:last).join
+    )
+
+    stacks = PROCEDURE.reduce(STACKS) { |result, step| rearrange(result, step, multiple: true) }
+    solve!(
+      "The top crates after rearranging with the CrateMover 9001 are:",
+      stacks.map(&:last).join
+    )

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

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

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

@@ -0,0 +1,21 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    DATA_STREAM = INPUT.chars.to_a
+
+    def processed_characters(buffer, marker_length)
+      buffer.each_cons(marker_length).each_with_index do |marker, i|
+        break i + marker_length if marker.uniq.count == marker_length
+      end
+    end
+
+    solve!(
+      "The number of characters processed before the first start-of-packet marker is:",
+      processed_characters(DATA_STREAM, 4)
+    )
+
+    solve!(
+      "The number of characters processed before the first start-of-message marker is:",
+      processed_characters(DATA_STREAM, 14)
+    )

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

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

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

@@ -0,0 +1,43 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    LINES = INPUT.split("\n").freeze
+    CHANGE_MATCHER = /\$ cd (?<directory>.+)/
+    FILE_MATCHER = /(?<filesize>\d+) (?<filename>.+)/
+
+    sizes = Hash.new(0)
+    pwd = []
+
+    LINES.each do |line|
+      case line
+      when CHANGE_MATCHER
+        dir = $~[:directory]
+        (dir == "..") ? pwd.pop : pwd << dir
+      when FILE_MATCHER
+        path = pwd.dup
+
+        loop do
+          sizes[path.dup] += $~[:filesize].to_i
+          path.pop
+          break if path.empty?
+        end
+      end
+    end
+
+    solve!(
+      "The total size of all directories below 100k is:",
+      sizes.values.select { |size| size < 100_000 }.sum
+    )
+
+    TOTAL = 70_000_000
+    NEEDED = 30_000_000
+    USABLE = TOTAL - NEEDED
+
+    USED = sizes[["/"]]
+    TARGET = USED - USABLE
+
+    solve!(
+      "The size of the best directory to remove is:",
+      sizes.values.sort.detect { |size| size >= TARGET }
+    )

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

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

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

@@ -0,0 +1,48 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    TREES = INPUT.split("\n").map { |row| row.chars.map(&:to_i) }
+    DIRECTIONS = [[0, 1], [1, 0], [0, -1], [-1, 0]].freeze
+
+    HEIGHT = TREES.length
+    WIDTH = TREES.first.length
+
+    COORDS = (0...WIDTH).to_a.product((0...HEIGHT).to_a)
+
+    def path_for(x, y, (dx, dy))
+      Enumerator.new do |enum|
+        loop do
+          x += dx
+          y += dy
+
+          break if x < 0 || y < 0 || x >= WIDTH || y >= HEIGHT
+
+          enum.yield [x, y]
+        end
+      end
+    end
+
+    def visible?(x, y)
+      height = TREES[y][x]
+
+      DIRECTIONS.any? do |dir|
+        path_for(x, y, dir).none? { |i, j| TREES[j][i] >= height }
+      end
+    end
+
+    solve!(COORDS.count { |x, y| visible?(x, y) })
+
+    def scenic_score(x, y)
+      height = TREES[y][x]
+
+      DIRECTIONS.reduce(1) do |score, dir|
+        count = path_for(x, y, dir).reduce(0) do |count, (i, j)|
+          (TREES[i][j] >= height) ? (break count + 1) : count + 1
+        end
+
+        score * count
+      end
+    end
+
+    solve!(COORDS.map { |x, y| scenic_score(x, y) }.max)

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

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

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

@@ -0,0 +1,48 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+
+    INSTRUCTIONS = INPUT.split("\n").map do |line|
+      direction, value = line.split
+      [direction.to_sym, value.to_i]
+    end
+
+    DIRECTIONS = {
+      R: Vector[1, 0],
+      L: Vector[-1, 0],
+      U: Vector[0, -1],
+      D: Vector[0, 1]
+    }
+
+    def rope(knots)
+      [Vector[0, 0]] * knots
+    end
+
+    def motion(head, tail)
+      dv = head - tail
+      (dv.any? { |d| d.abs > 1 }) ? dv.map { |d| d <=> 0 } : Vector[0, 0]
+    end
+
+    def path_for(rope, instructions)
+      instructions.each_with_object({}) do |(direction, value), path|
+        value.times do
+          rope[0] += DIRECTIONS[direction]
+          (1...rope.length).each { |i| rope[i] += motion(rope[i - 1], rope[i]) }
+          path[rope.last] = true
+        end
+      end
+    end
+
+    path = path_for(rope(2), INSTRUCTIONS)
+    solve!(
+      "The number of rooms visited by the 2-knot tail is:",
+      path.count
+    )
+
+    path = path_for(rope(10), INSTRUCTIONS)
+    solve!(
+      "The number of rooms visited by the 10-knot tail is:",
+      path.count
+    )

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

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

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

@@ -0,0 +1,50 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    SIGNALS = INPUT.split("\n").map(&:split).freeze
+
+    def run(cycles)
+      x = 1
+      cycle = 0
+
+      loop do
+        SIGNALS.each do |(instruction, value)|
+          delay, dx =
+            case instruction
+            when "noop" then [1, 0]
+            when "addx" then [2, value.to_i]
+            end
+
+          delay.times do
+            cycle += 1
+            yield cycle, x, cycles.include?(cycle)
+          end
+          x += dx
+        end
+
+        break if cycle >= cycles.max
+      end
+    end
+
+    total = 0
+    run([20, 60, 100, 140, 180, 220]) do |cycle, x, interesting|
+      total += (x * cycle) if interesting
+    end
+
+    solve!(
+      "The total signal strength from interesting cycles is:",
+      total
+    )
+
+    crt = ""
+    run([40, 80, 120, 160, 200, 240]) do |cycle, x, interesting|
+      overlaps = (x - ((cycle - 1) % 40)).abs <= 1
+      crt << (overlaps ? "#" : ".")
+      crt << "\n" if interesting
+    end
+
+    solve!(
+      "The message displayed on the CRT is as follows:",
+      crt
+    )

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

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