advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,54 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    prereqs, updates = INPUT.split("\n\n")
+
+    PREREQS = prereqs.split("\n").each_with_object(Hash.new { |h, k| h[k] = [] }) do |line, reqs|
+      a, b = line.split("|").map(&:to_i)
+      reqs[b] << a
+    end
+    UPDATES = updates.split("\n").map { |line| line.split(",").map(&:to_i) }
+
+    def valid_page?(page, index, update, prereqs, processed)
+      prereqs[page].empty? || prereqs[page].all? { |r| !update.include?(r) || processed[r] && processed[r] < index }
+    end
+
+    def valid?(update, prereqs)
+      processed = {}
+
+      update.each_with_index.all? do |page, i|
+        processed[page] = i
+        valid_page?(page, i, update, prereqs, processed)
+      end
+    end
+
+    def score(updates)
+      updates.sum { |update| update[update.length / 2] }
+    end
+
+    valid, invalid = UPDATES.partition { |update| valid?(update, PREREQS) }
+    solve!("The sum of middle page numbers for valid updates is:", score(valid))
+
+    def fix(update, prereqs)
+      processed = {}
+      fixed = []
+      current = 0
+      remaining = update
+
+      loop do
+        break fixed if remaining.empty?
+
+        next_page = remaining.detect do |page|
+          valid_page?(page, current, remaining, prereqs, processed)
+        end
+
+        fixed << next_page
+        processed[next_page] = current
+        current += 1
+        remaining -= [next_page]
+      end
+    end
+
+    fixed = invalid.map { |update| fix(update, PREREQS) }
+    solve!("The sum of middle page numbers for corrected updates is:", score(fixed))

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

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

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

@@ -0,0 +1,56 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    MAP = INPUT.split("\n").each_with_index.each_with_object({}) do |(row, y), grid|
+      row.chars.each_with_index do |tile, x|
+        grid[Vector[x, y]] = tile
+      end
+    end
+
+    DIRECTIONS = {"^" => Vector[0, -1], ">" => Vector[1, 0], "v" => Vector[0, 1], "<" => Vector[-1, 0]}
+    ANGLES = DIRECTIONS.keys
+    OBSTRUCTION = "#"
+    START = "^"
+
+    def navigate(map)
+      facing = START
+      position = map.key(facing)
+      visited = Hash.new { |h, k| h[k] = Set.new }
+
+      loop do
+        break visited if map[position].nil?
+        break false if visited[position].include?(facing)
+
+        visited[position] << facing
+        test = position + DIRECTIONS[facing]
+
+        if map[test] == OBSTRUCTION
+          facing = ANGLES[(ANGLES.index(facing) + 1) % ANGLES.length]
+        else
+          position = test
+        end
+      end
+    end
+
+    visits = navigate(MAP)
+    solve!("The number of visited tiles is:", visits.count)
+
+    def obstructed(position, map)
+      map.dup.tap do |updated|
+        updated[position] = OBSTRUCTION
+      end
+    end
+
+    candidates = MAP.keys & visits.keys
+    loops = candidates.count do |position|
+      next false if MAP[position] == OBSTRUCTION
+      next false if MAP[position] == START
+
+      map = obstructed(position, MAP)
+      !navigate(map)
+    end
+
+    solve!("The number of possible loops is:", loops)

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

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

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

@@ -0,0 +1,47 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    LINE_MATCHER = /\A(?<value>\d+): (?<numbers>[0-9 ]+)\z/
+    TESTS = INPUT.split("\n").map do |line|
+      match = line.match(LINE_MATCHER)
+      {
+        value: match[:value].to_i,
+        numbers: match[:numbers].split.map(&:to_i)
+      }
+    end
+    OPERATIONS = {
+      "+": ->(a, b) { a + b },
+      "*": ->(a, b) { a * b },
+      "||": ->(a, b) { "#{a}#{b}".to_i }
+    }
+
+    def valid?(equation, operators)
+      target = equation[:value]
+      numbers = equation[:numbers].dup
+      current_values = [numbers.shift]
+
+      loop do
+        break if numbers.empty?
+
+        next_value = numbers.shift
+        next_values = []
+
+        operators.each do |operator|
+          current_values.each do |value|
+            result = OPERATIONS[operator].call(value, next_value)
+            next_values << result if result <= target
+          end
+        end
+
+        current_values = next_values
+      end
+
+      current_values.any? { |v| v == target }
+    end
+
+    calibrations = TESTS.select { |test| valid?(test, %i[+ *]) }
+    solve!("The calibration total is:", calibrations.sum { |c| c[:value] })
+
+    calibrations = TESTS.select { |test| valid?(test, %i[+ * ||]) }
+    solve!("The total with concatenation is:", calibrations.sum { |c| c[:value] })

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

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

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

@@ -0,0 +1,58 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    MAP = INPUT.split("\n").each_with_index.each_with_object({}) do |(row, y), grid|
+      row.chars.each_with_index do |tile, x|
+        grid[Vector[x, y]] = tile
+      end
+    end
+
+    XMAX = MAP.keys.map { |position| position[0] }.max
+    YMAX = MAP.keys.map { |position| position[1] }.max
+
+    ANTENNAS = (MAP.values.uniq - ["."]).each_with_object({}) do |frequency, antennas|
+      antennas[frequency] = MAP.keys.select { |position| MAP[position] == frequency }
+    end
+
+    def out_of_bounds?(node)
+      node[0] < 0 || node[1] < 0 || node[0] > XMAX || node[1] > YMAX
+    end
+
+    def single_antinodes(a, b)
+      d = b - a
+      [a - d, b + d].reject { |node| out_of_bounds?(node) }
+    end
+
+    def multi_antinodes(a, b)
+      antinodes = [a, b]
+      d = b - a
+
+      a -= d
+      b += d
+
+      loop do
+        break antinodes if out_of_bounds?(a) && out_of_bounds?(b)
+
+        antinodes += [a, b].reject { |node| out_of_bounds?(node) }
+
+        a -= d
+        b += d
+      end
+    end
+
+    def antinodes_for(map, multi = false)
+      ANTENNAS.each_with_object({}) do |(_, antennas), antinode_map|
+        antennas.combination(2).each do |a, b|
+          antinodes = multi ? multi_antinodes(a, b) : single_antinodes(a, b)
+          antinodes.each do |antinode|
+            antinode_map[antinode] = true
+          end
+        end
+      end
+    end
+
+    solve!("The number of unique antinode positions is:", antinodes_for(MAP).count)
+    solve!("The number of antinode positions with the updated model is:", antinodes_for(MAP, true).count)

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

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

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

@@ -0,0 +1,76 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    FILESYSTEM = INPUT.chars.each_slice(2).each_with_index.each_with_object([]) do |((file, space), index), system|
+      file.to_i.times { system << index }
+      space.to_i.times { system << nil }
+    end
+
+    def compact_blocks(filesystem)
+      compacted = filesystem.dup
+
+      cursor = 0
+      tail = compacted.length - 1
+
+      loop do
+        if compacted[cursor]
+          cursor += 1 until compacted[cursor].nil?
+        end
+        if compacted[tail].nil?
+          tail -= 1 until compacted[tail]
+        end
+
+        break compacted if tail <= cursor
+
+        compacted[cursor] = compacted[tail]
+        compacted[tail] = nil
+
+        cursor += 1
+        tail -= 1
+      end
+    end
+
+    def checksum(filesystem)
+      filesystem.each_with_index.sum { |file, pos| file ? file * pos : 0 }
+    end
+
+    solve!("The checksum after block-level compacting is:", checksum(compact_blocks(FILESYSTEM)))
+
+    def compact_files(filesystem)
+      compacted = filesystem.dup
+
+      file = compacted.last
+      loop do
+        break compacted if file <= 0
+
+        file_starts = compacted.index(file)
+        filesize = 0
+        filesize += 1 until compacted[file_starts + filesize] != file
+
+        cursor = compacted.index(nil)
+
+        loop do
+          break if cursor >= file_starts
+
+          available = 0
+          available += 1 while compacted[cursor + available].nil?
+
+          if available >= filesize
+            filesize.times do |i|
+              compacted[cursor + i] = file
+              compacted[file_starts + i] = nil
+            end
+
+            break
+          end
+
+          cursor = cursor + available + 1
+          cursor += 1 until compacted[cursor].nil?
+        end
+
+        file -= 1
+      end
+    end
+
+    solve!("The checksum after whole-file compacting is:", checksum(compact_files(FILESYSTEM)))

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

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

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

@@ -0,0 +1,51 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    MAP = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), map|
+      line.chars.each_with_index do |c, x|
+        map[Vector[x, y]] = c.to_i unless c == "."
+      end
+    end
+
+    TRAILHEADS = MAP.keys.select { |position| MAP[position] == 0 }
+    ADJACENCIES = [Vector[1, 0], Vector[0, 1], Vector[-1, 0], Vector[0, -1]]
+
+    def score_map(map, peak_scores)
+      scores = peak_scores.dup
+
+      8.downto(0).each do |height|
+        map.keys.each do |position|
+          next unless map[position] == height
+
+          ADJACENCIES.each do |move|
+            next unless map[position + move] == height + 1
+            scores[position] += scores[position + move]
+          end
+        end
+      end
+
+      scores
+    end
+
+    def peaks_map(map)
+      reachable = Hash.new { |h, k| h[k] = Set.new }
+      map.keys.each { |position| reachable[position] << position if map[position] == 9 }
+
+      score_map(map, reachable).to_h { |position, peaks| [position, peaks.count] }
+    end
+
+    scores = peaks_map(MAP)
+    solve!("The sum of trail scores is:", TRAILHEADS.sum { |trailhead| scores[trailhead] })
+
+    def ratings_map(map)
+      ratings = Hash.new(0)
+      map.keys.each { |position| ratings[position] = 1 if map[position] == 9 }
+
+      score_map(map, ratings)
+    end
+
+    scores = ratings_map(MAP)
+    solve!("The sum of trail ratings is:", TRAILHEADS.sum { |trailhead| scores[trailhead] })

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    STONES = INPUT.split(" ").map(&:to_i)
+
+    def stone_count(engraving, blink, max, counts = {})
+      return 1 if blink > max
+
+      counts["#{engraving}-#{blink}"] ||=
+        if engraving == 0
+          stone_count(1, blink + 1, max, counts)
+        elsif engraving.to_s.length.even?
+          length = engraving.to_s.length / 2
+          stone_count(engraving.to_s[0, length].to_i, blink + 1, max, counts) +
+            stone_count(engraving.to_s[length..].to_i, blink + 1, max, counts)
+        else
+          stone_count(engraving * 2024, blink + 1, max, counts)
+        end
+    end
+
+    def stones_after(stones, blinks)
+      stone_counts = {}
+      stones.sum { |engraving| stone_count(engraving, 1, blinks, stone_counts) }
+    end
+
+    BLINKS ||= 25
+    solve!("The number of stones after #{BLINKS} blinks is:", stones_after(STONES, BLINKS))
+    solve!("The number of stones after 75 blinks is:", stones_after(STONES, 75))

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    GARDEN = INPUT.split("\n").each_with_index.each_with_object({}) do |(row, y), map|
+      row.chars.each_with_index do |plot, x|
+        map[Vector[x, y]] = plot
+      end
+    end
+    ADJACENCIES = [Vector[1, 0], Vector[0, 1], Vector[-1, 0], Vector[0, -1]]
+
+    def regions_in(garden)
+      plots = garden.keys
+      regions = []
+
+      loop do
+        plot = plots.shift
+        break regions unless plot
+
+        crop = garden[plot]
+
+        region = {}
+        perimeters = Hash.new(0)
+
+        connected = [plot]
+
+        loop do
+          plot = connected.shift
+          break unless plot
+          next if region[plot]
+
+          region[plot] = true
+
+          ADJACENCIES.each do |test|
+            neighbor = plot + test
+
+            if garden[neighbor] != crop
+              perimeters[plot] += 1
+            else
+              connected << neighbor
+            end
+          end
+        end
+
+        plots -= region.keys
+        regions << {plots: region, perimeters:}
+      end
+    end
+
+    def fence_cost(region)
+      region[:plots].length * region[:perimeters].values.sum
+    end
+
+    regions = regions_in(GARDEN)
+    solve!(regions.sum { |region| fence_cost(region) })
+
+    CORNER_TESTS = [
+      [Vector[1, 0], Vector[0, 1], Vector[1, 1]],
+      [Vector[1, 0], Vector[0, -1], Vector[1, -1]],
+      [Vector[-1, 0], Vector[0, 1], Vector[-1, 1]],
+      [Vector[-1, 0], Vector[0, -1], Vector[-1, -1]]
+    ]
+
+    def sides_for(region)
+      region.keys.each_with_object(Hash.new(0)) do |plot, corners|
+        CORNER_TESTS.each do |corner|
+          x, y, test = corner.map { |v| region[plot + v] }
+          corners[plot] += 1 if (x && y && !test) || !(x || y)
+        end
+      end.values.sum
+    end
+
+    def side_fence_cost(region)
+      region[:plots].length * sides_for(region[:plots])
+    end
+
+    solve!(regions.sum { |region| side_fence_cost(region) })

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

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

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

@@ -0,0 +1,46 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    BUTTON_MATCHER = /\AButton (?<button>A|B): X\+(?<x>[0-9]+), Y\+(?<y>[0-9]+)\z/
+    PRIZE_MATCHER = /\APrize: X=(?<x>[0-9]+), Y=(?<y>[0-9]+)\z/
+
+    MACHINES = INPUT.split("\n\n").map do |machine|
+      a, b, prize = machine.split("\n")
+
+      a = a.match(BUTTON_MATCHER)
+      b = b.match(BUTTON_MATCHER)
+      prize = prize.match(PRIZE_MATCHER)
+
+      {
+        a: Vector[a[:x].to_i, a[:y].to_i],
+        b: Vector[b[:x].to_i, b[:y].to_i],
+        prize: Vector[prize[:x].to_i, prize[:y].to_i]
+      }
+    end
+
+    def win(machine, offset: 0)
+      target = machine[:prize] + Vector[offset, offset]
+
+      d = machine[:a][0] * machine[:b][1] - machine[:a][1] * machine[:b][0]
+      return 0 if d == 0
+
+      da = machine[:b][1] * target[0] - machine[:b][0] * target[1]
+      db = machine[:a][0] * target[1] - machine[:a][1] * target[0]
+
+      return da / d * 3 + db / d if da % d == 0 && db % d == 0
+
+      0
+    end
+
+    solve!(
+      "The minimum number of tokens to acquire all prizes is:",
+      MACHINES.sum { |machine| win(machine) }
+    )
+
+    solve!(
+      "The minimum number of tokens to acquire all (distant) prizes is:",
+      MACHINES.sum { |machine| win(machine, offset: 10_000_000_000_000) }
+    )

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

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

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

@@ -0,0 +1,52 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    ROBOT_MATCHER = /\Ap=(?<px>-?\d+),(?<py>-?\d+) v=(?<vx>-?\d+),(?<vy>-?\d+)\z/
+    ROBOTS = INPUT.split("\n").map do |line|
+      robot = line.match(ROBOT_MATCHER)
+
+      {
+        position: Vector[robot[:px].to_i, robot[:py].to_i],
+        velocity: Vector[robot[:vx].to_i, robot[:vy].to_i]
+      }
+    end
+
+    TIME = 100
+
+    WIDTH ||= 101
+    HEIGHT ||= 103
+
+    def final_position(width, height, robot, time)
+      position = robot[:position]
+      position += robot[:velocity] * time
+
+      Vector[position[0] % width, position[1] % height]
+    end
+
+    QUADRANTS = {[-1, -1] => :ul, [-1, 1] => :ur, [1, -1] => :bl, [1, 1] => :br}
+
+    def quadrant(width, height, position)
+      h = position[0] <=> width / 2
+      v = position[1] <=> height / 2
+
+      QUADRANTS[[h, v]]
+    end
+
+    positions = ROBOTS.map { |robot| final_position(WIDTH, HEIGHT, robot, 100) }
+    groups = positions.group_by { |position| quadrant(WIDTH, HEIGHT, position) }.reject { |k, _| k.nil? }
+
+    solve!("The safety factor after 100 seconds is:", groups.values.map(&:count).inject(:*))
+
+    tree_at = (TIME..Float::INFINITY).detect do |t|
+      positions = Hash.new(0)
+
+      ROBOTS.none? do |robot|
+        position = final_position(WIDTH, HEIGHT, robot, t)
+        (positions[position] += 1) > 1
+      end
+    end
+
+    solve!("The robots form a Christmas Tree at:", tree_at)

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

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

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

@@ -0,0 +1,98 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    layout, instructions = INPUT.split("\n\n")
+
+    def map_from(layout)
+      layout.split("\n").each_with_index.each_with_object({}) do |(line, y), grid|
+        line.chars.each_with_index do |c, x|
+          grid[Vector[x, y]] = c
+        end
+      end
+    end
+
+    INSTRUCTIONS = instructions.tr("\n", "").chars
+    DIRECTIONS = {">" => Vector[1, 0], "v" => Vector[0, 1], "<" => Vector[-1, 0], "^" => Vector[0, -1]}
+
+    ROBOT = "@"
+    WALL = "#"
+    CRATE = "O"
+    CRATE_L = "["
+    CRATE_R = "]"
+    EMPTY = "."
+
+    def after_move(map, move)
+      robot = map.key(ROBOT)
+      tests = [robot]
+      stack = [robot]
+
+      can_move = loop do
+        break false if tests.any? { |test| map[test + move] == WALL }
+
+        tests = tests.reject { |test| map[test + move] == EMPTY }
+        break true if tests.empty?
+
+        tests = tests.filter_map do |test|
+          if map[test + move] == CRATE
+            stack << (test + move)
+            test + move
+          elsif map[test + move] == CRATE_L
+            stack << (test + move)
+            stack << (test + Vector[1, 0] + move)
+
+            (move == Vector[1, 0]) ? test + move * 2 : [test + move, test + move + Vector[1, 0]]
+          elsif map[test + move] == CRATE_R
+            stack << (test + move)
+            stack << (test + Vector[-1, 0] + move)
+
+            (move == Vector[-1, 0]) ? test + move * 2 : [test + move, test + move + Vector[-1, 0]]
+          end
+        end.flatten.uniq
+      end
+
+      if can_move
+        updated = map.dup
+
+        stack.uniq.reverse_each do |from|
+          to = from + move
+          to_value = updated[to]
+          updated[to] = updated[from]
+          updated[from] = to_value
+        end
+
+        updated
+      else
+        map
+      end
+    end
+
+    def gps_total(map)
+      map.sum do |position, tile|
+        (tile == CRATE || tile == CRATE_L) ? position[1] * 100 + position[0] : 0
+      end
+    end
+
+    map = map_from(layout)
+    INSTRUCTIONS.each do |instruction|
+      map = after_move(map, DIRECTIONS[instruction])
+    end
+
+    solve!("The total of GPS coordinates after moving is:", gps_total(map))
+
+    def widen(layout)
+      layout
+        .gsub("#", "##")
+        .gsub(".", "..")
+        .gsub("O", "[]")
+        .gsub("@", "@.")
+    end
+
+    map = map_from(widen(layout))
+    INSTRUCTIONS.each do |instruction|
+      map = after_move(map, DIRECTIONS[instruction])
+    end
+
+    solve!("The total of wide-map GPS coordinates after moving is:", gps_total(map))

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

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