advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,50 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    order, *boards = INPUT.split("\n\n")
+
+    DRAW_ORDER = order.split(",").map(&:to_i).freeze
+    BOARDS = boards.freeze
+
+    class Board
+      def initialize(board)
+        @numbers = board.split("\n").map { |row| row.scan(/\d+/).map(&:to_i) }
+
+        @height = @numbers.length
+        @width = @numbers.first.length
+
+        @marks = Array.new(@height) { Array.new(@width) }
+      end
+
+      def mark!(number)
+        @height.times do |i|
+          @width.times do |j|
+            next unless @numbers[i][j] == number
+
+            @marks[i][j] = true
+            return true
+          end
+        end
+      end
+
+      def solved?
+        @marks.any?(&:all?) || @width.times.any? { |i| @marks.all? { |row| row[i] } }
+      end
+
+      def score
+        @height.times.sum do |i|
+          @width.times.sum { |j| @marks[i][j] ? 0 : @numbers[i][j] }
+        end
+      end
+    end
+
+    participants = BOARDS.map { |b| Board.new(b) }
+    scores = DRAW_ORDER.each_with_object([]) do |number, scores|
+      participants.each { |p| p.mark!(number) }
+      winners, participants = participants.partition(&:solved?)
+      winners.each { |board| scores << (board.score * number) }
+    end
+
+    solve!("The score of the winning board is:", scores.first)
+    solve!("The score of the losing board is:", scores.last)

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

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

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

@@ -0,0 +1,37 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    VENT_MATCHER = /(?<x1>\d+),(?<y1>\d+) -> (?<x2>\d+),(?<y2>\d+)/
+    VENTS = INPUT.split("\n").map { |line| line.match(VENT_MATCHER) }
+
+    def range_for(begins, ends)
+      min = [begins, ends].min
+      (min == begins) ? (begins..ends).to_a : begins.downto(ends).to_a
+    end
+
+    def map_for(vents, diagonals: false)
+      vents.each_with_object(Hash.new { |h, k| h[k] = 0 }) do |vent, map|
+        next unless diagonals || (vent[:x1] == vent[:x2]) || (vent[:y1] == vent[:y2])
+
+        y_range = range_for(vent[:y1].to_i, vent[:y2].to_i)
+        x_range = range_for(vent[:x1].to_i, vent[:x2].to_i)
+
+        x_range *= y_range.length if x_range.length == 1
+        y_range *= x_range.length if y_range.length == 1
+
+        x_range.zip(y_range).each do |x, y|
+          map[[x, y]] += 1
+        end
+      end
+    end
+
+    def overlapping_vents(map)
+      map.values.count { |vent| vent > 1 }
+    end
+
+    map = map_for(VENTS)
+    solve!("The number of overlapping vents is:", overlapping_vents(map))
+
+    map = map_for(VENTS, diagonals: true)
+    solve!("The number of overlapping vents (with diagonals) is:", overlapping_vents(map))

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    LANTERNFISH = INPUT.split(",").map(&:to_i).freeze
+
+    MATURATION_DAYS = 2
+    GESTATION_DAYS = 7
+    CYCLE_DAYS = MATURATION_DAYS + GESTATION_DAYS
+
+    def next_state(timers)
+      fish = (0...CYCLE_DAYS).map { |i| timers[i + 1].to_i }
+
+      fish[CYCLE_DAYS - 1] += timers[0]
+      fish[GESTATION_DAYS - 1] += timers[0]
+
+      fish
+    end
+
+    def fish_after(days)
+      fish = (0...CYCLE_DAYS).map { |i| LANTERNFISH.count(i) }
+      days.times { fish = next_state(fish) }
+
+      fish.sum
+    end
+
+    solve!("The number of lanternfish after 80 days is:", fish_after(80))
+    solve!("The number of lanternfish after 256 days is:", fish_after(256))

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

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

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

@@ -0,0 +1,19 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    POSITIONS = INPUT.split(",").map(&:to_i).freeze
+    RANGE = Range.new(*POSITIONS.minmax)
+
+    def fuel_needed(position, increasing: false)
+      POSITIONS.sum do |i|
+        fuel = (i - position).abs
+        increasing ? fuel * (fuel + 1) / 2 : fuel
+      end
+    end
+
+    align_on = RANGE.map { |i| fuel_needed(i) }.min
+    solve!("The minimum fuel needed for alignment is:", align_on)
+
+    align_on = RANGE.map { |i| fuel_needed(i, increasing: true) }.min
+    solve!("The minimum (increasing) fuel needed for alignment is:", align_on)

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

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

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

@@ -0,0 +1,56 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    ENTRIES = INPUT.split("\n").map do |line|
+      input, output = line.split(" | ")
+
+      [
+        input.split.map(&:chars).map(&:sort),
+        output.split.map(&:chars).map(&:sort)
+      ]
+    end
+
+    AVAILABLE_SEGMENTS = %w[a b c d e f g].freeze
+    SEGMENT_MAPPINGS = {
+      0 => %w[a b c e f g],
+      1 => %w[c f],
+      2 => %w[a c d e g],
+      3 => %w[a c d f g],
+      4 => %w[b c d f],
+      5 => %w[a b d f g],
+      6 => %w[a b d e f g],
+      7 => %w[a c f],
+      8 => %w[a b c d e f g],
+      9 => %w[a b c d f g]
+    }.freeze
+
+    UNIQUE_DIGITS = [1, 4, 7, 8].freeze
+
+    unique_counts = UNIQUE_DIGITS.map { |digit| SEGMENT_MAPPINGS[digit].size }
+    digit_count = ENTRIES.sum do |(_input, output)|
+      output.count { |word| unique_counts.include?(word.size) }
+    end
+
+    solve!("The count of unique digits is:", digit_count)
+
+    final = ENTRIES.sum do |inputs, outputs|
+      inputs = inputs.uniq
+      patterns = {
+        1 => inputs.detect { |i| i.size == 2 },
+        4 => inputs.detect { |i| i.size == 4 },
+        7 => inputs.detect { |i| i.size == 3 },
+        8 => inputs.detect { |i| i.size == 7 }
+      }
+
+      patterns[9] = inputs.detect { |i| i.size == 6 && (i & patterns[4]).size == 4 }
+      patterns[0] = inputs.detect { |i| i.size == 6 && (i & patterns[7]).size == 3 && i != patterns[9] }
+      patterns[6] = inputs.detect { |i| i.size == 6 && i != patterns[9] && i != patterns[0] }
+      patterns[5] = inputs.detect { |i| i.size == 5 && (i & patterns[6]).size == 5 }
+      patterns[3] = inputs.detect { |i| i.size == 5 && (i & patterns[4]).size == 3 && i != patterns[5] }
+      patterns[2] = inputs.detect { |i| i.size == 5 && i != patterns[5] && i != patterns[3] }
+
+      outputs.map { |o| patterns.key(o) }.join.to_i
+    end
+
+    solve!("The sum of output values is:", final)

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

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

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

@@ -0,0 +1,44 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    MAP = INPUT.split("\n").map { |line| line.chars.map(&:to_i) }.freeze
+    BASIN_THRESHOLD = 9
+    NEIGHBORS = [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1]
+    ].freeze
+
+    def neighbors_for(x, y)
+      NEIGHBORS.filter_map do |dx, dy|
+        nx = x + dx
+        ny = y + dy
+
+        next if ny < 0 || ny >= MAP.size
+        next if nx < 0 || nx >= MAP[0].size
+
+        [nx, ny]
+      end
+    end
+
+    low_points = MAP.flat_map.with_index do |row, y|
+      row.filter_map.with_index do |n, x|
+        [x, y] if neighbors_for(x, y).all? { |i, j| MAP[j][i] > n }
+      end
+    end
+
+    solve!("The sum of low point scores is:", low_points.sum { |(x, y)| MAP[y][x] + 1 })
+
+    def basin_neighbors(x, y)
+      neighbors = neighbors_for(x, y).select do |i, j|
+        MAP[j][i] > MAP[y][x] && MAP[j][i] != BASIN_THRESHOLD
+      end
+
+      [[x, y]] + neighbors.flat_map { |(i, j)| basin_neighbors(i, j) }.uniq
+    end
+
+    basin_sizes = low_points.map { |(x, y)| basin_neighbors(x, y).count }.sort
+
+    solve!("The product of the three largest basin sizes is:", basin_sizes.last(3).inject(:*))

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

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

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

@@ -0,0 +1,53 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    LINES = INPUT.split("\n").map(&:chars)
+
+    PAIRINGS = {"(" => ")", "[" => "]", "{" => "}", "<" => ">"}.freeze
+    ERROR_SCORES = {")" => 3, "]" => 57, "}" => 1197, ">" => 25_137}.freeze
+
+    AutocompleteError = Class.new(RuntimeError)
+
+    def autocomplete(line)
+      unresolved = []
+
+      line.each do |char|
+        case char
+        when *PAIRINGS.keys
+          unresolved << char
+          false
+        when PAIRINGS[unresolved.last]
+          unresolved.pop
+          false
+        when *PAIRINGS.values
+          raise AutocompleteError, char
+        end
+      end
+
+      unresolved.reverse.map { |c| PAIRINGS[c] }
+    end
+
+    def corrupted?(line)
+      autocomplete(line)
+      false
+    rescue AutocompleteError
+      true
+    end
+
+    corrupted, incomplete = LINES.partition { |line| corrupted?(line) }
+    error_score = corrupted.sum do |line|
+      autocomplete(line)
+    rescue AutocompleteError => e
+      ERROR_SCORES[e.message]
+    end
+
+    solve!("The total syntax error score is:", error_score)
+
+    COMPLETION_SCORES = {")" => 1, "]" => 2, "}" => 3, ">" => 4}.freeze
+
+    completion_scores = incomplete.map do |line|
+      autocomplete(line).inject(0) { |score, c| (score * 5) + COMPLETION_SCORES[c] }
+    end
+
+    solve!("The middle autocomplete score is:", completion_scores.sort[completion_scores.length / 2])

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

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

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

@@ -0,0 +1,62 @@
+---
+- :name: 11.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    OCTOPODES = INPUT.split("\n").map { |row| row.chars.map(&:to_i) }.freeze
+    NEIGHBORS = ([-1, 0, 1].product([-1, 0, 1]) - [0, 0]).freeze
+    FLASH_THRESHOLD = 10
+    STEPS = 100
+
+    def flash(octopodes, x, y)
+      NEIGHBORS.each do |dx, dy|
+        nx = x + dx
+        ny = y + dy
+
+        next if ny < 0 || ny >= octopodes.size
+        next if nx < 0 || nx >= octopodes[y].size
+
+        octopodes[ny][nx] += 1
+        flash(octopodes, nx, ny) if octopodes[ny][nx] == FLASH_THRESHOLD
+      end
+    end
+
+    def step(octopodes)
+      octopodes = octopodes.map(&:dup)
+
+      octopodes.each_index do |y|
+        octopodes[y].each_index do |x|
+          octopodes[y][x] += 1
+          flash(octopodes, x, y) if octopodes[y][x] == FLASH_THRESHOLD
+        end
+      end
+
+      flashes = octopodes.each_index.sum do |y|
+        octopodes[y].each_index.count do |x|
+          next false if octopodes[y][x] < FLASH_THRESHOLD
+
+          octopodes[y][x] = 0
+        end
+      end
+
+      [flashes, octopodes]
+    end
+
+    octopodes = OCTOPODES
+    flash_count = STEPS.times.sum do
+      flashes, octopodes = step(octopodes)
+      flashes
+    end
+
+    solve!("The total number of flashes in 100 steps is:", flash_count)
+
+    step_number = 0
+    octopodes = OCTOPODES
+
+    loop do
+      step_number += 1
+      flashes, octopodes = step(octopodes)
+
+      break step_number if flashes == octopodes.size * octopodes[0].size
+    end
+
+    solve!("The first step where the octopodes synchronize is:", step_number)

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

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

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

@@ -0,0 +1,53 @@
+---
+- :name: 12.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    MAP = INPUT.split("\n").each_with_object(Hash.new { |h, k| h[k] = [] }) do |line, map|
+      rooms = line.split("-")
+
+      map[rooms[0]] << rooms[1]
+      map[rooms[1]] << rooms[0]
+    end.freeze
+
+    class Path
+      attr_reader :current
+
+      def initialize(path = %w[start], revisit: false)
+        @path = path
+        @current = path.last
+        @revisit = revisit
+      end
+
+      def visitable?(cave)
+        return true unless small?(cave)
+        return false if %w[start end].include?(cave) && @path.include?(cave)
+
+        !@path.include?(cave) || @revisit
+      end
+
+      def visiting(cave)
+        revisit = (small?(cave) && @path.include?(cave)) ? false : @revisit
+
+        Path.new(@path + [cave], revisit: revisit)
+      end
+
+      private
+
+      def small?(cave)
+        cave.downcase == cave
+      end
+    end
+
+    def paths(from:)
+      current = from.current
+      return [from] if current == "end"
+
+      MAP[current].filter_map do |cave|
+        next unless from.visitable?(cave)
+
+        paths(from: from.visiting(cave))
+      end.flatten(1)
+    end
+
+    solve!("The number of distinct paths from start to end is:", paths(from: Path.new).size)
+    solve!("The number of distinct paths from start to end (with a detour) is:", paths(from: Path.new(revisit: true)).size)

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

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

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

@@ -0,0 +1,44 @@
+---
+- :name: 13.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    folding = false
+    folds, points = INPUT.split("\n").partition do |line|
+      folding = true if line.empty?
+      folding
+    end
+
+    FOLD_MATCHER = /\Afold along (?<axis>x|y)=(?<point>\d+)\z/
+    POINTS = points.map { |line| line.split(",").map(&:to_i) }.freeze
+    FOLDS = folds.drop(1).map { |line| line.match(FOLD_MATCHER) }
+
+    def fold(paper, fold)
+      fulcrum = fold[:point].to_i
+
+      paper.keys.each_with_object({}) do |(x, y), folded|
+        x, y =
+          case fold[:axis]
+          when "x"
+            [(x > fulcrum) ? fulcrum - (x - fulcrum) : x, y]
+          when "y"
+            [x, (y > fulcrum) ? fulcrum - (y - fulcrum) : y]
+          end
+
+        folded[[x, y]] = true
+      end
+    end
+
+    paper = POINTS.each_with_object({}) { |(x, y), sheet| sheet[[x, y]] = true }
+    paper = fold(paper, FOLDS[0])
+
+    solve!("The number of visible dots after the first fold is:", paper.values.count)
+
+    paper = POINTS.each_with_object({}) { |(x, y), sheet| sheet[[x, y]] = true }
+    FOLDS.each { |instruction| paper = fold(paper, instruction) }
+
+    final = (0..paper.keys.map(&:last).max).each_with_object("") do |y, rendered|
+      (0..paper.keys.map(&:first).max).each { |x| rendered << (paper[[x, y]] ? "#" : ".") }
+      rendered << "\n"
+    end
+
+    solve!("The paper looks like this after folding:", final)

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

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

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

@@ -0,0 +1,33 @@
+---
+- :name: 14.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    base, *conversions = INPUT.split("\n").reject(&:empty?)
+
+    BASE = base.chars.freeze
+    CONVERSION_MATCHER = /\A(?<pair>[A-Z]{2}) -> (?<insert>[A-Z])\z/
+    CONVERSIONS = conversions.each_with_object({}) do |line, mappings|
+      match = line.match(CONVERSION_MATCHER)
+      mappings[match[:pair].chars] = match[:insert]
+    end.freeze
+
+    def score_after(steps:)
+      pairs = BASE.each_cons(2).each_with_object(Hash.new(0)) { |pair, counts| counts[pair] += 1 }
+
+      steps.times do
+        pairs = pairs.each_with_object(Hash.new(0)) do |(k, v), updated|
+          insert = CONVERSIONS[k]
+          updated[[k[0], insert]] += v
+          updated[[insert, k[1]]] += v
+        end
+      end
+
+      elements = pairs.each_with_object(Hash.new(0)) { |(k, v), totals| totals[k[0]] += v }
+      elements[BASE.last] += 1
+
+      low, high = elements.values.minmax
+      high - low
+    end
+
+    solve!("The difference between most/least common element after 10 steps is:", score_after(steps: 10))
+    solve!("The difference between most/least common element after 40 steps is:", score_after(steps: 40))

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

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

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

@@ -0,0 +1,83 @@
+---
+- :name: 15.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2021
+  :solution: |-
+    require "rb_heap/heap"
+
+    CAVE = INPUT.split("\n").map { |line| line.chars.map(&:to_i) }.freeze
+    DEEP_CAVE =
+      (CAVE.size * 5).times.map do |y|
+        (CAVE[0].size * 5).times.map do |x|
+          depth = (y / CAVE.size) + (x / CAVE[0].size)
+          risk = CAVE[y % CAVE.size][x % CAVE[0].size]
+
+          ((risk + depth - 1) % 9) + 1
+        end
+      end.freeze
+
+    class Cave
+      DIRECTIONS = [[1, 0], [0, 1], [-1, 0], [0, -1]].freeze
+
+      def initialize(layout)
+        @layout = layout
+      end
+
+      def height
+        @height ||= @layout.size
+      end
+
+      def width
+        @width ||= @layout[0].size
+      end
+
+      def cost((x, y))
+        @layout[y][x]
+      end
+
+      def adjacent_spots((x, y))
+        DIRECTIONS.filter_map do |dx, dy|
+          next if x + dx < 0 || x + dx >= width
+          next if y + dy < 0 || y + dy >= height
+
+          [x + dx, y + dy]
+        end
+      end
+    end
+
+    class Spelunker
+      def initialize(cave)
+        @cave = cave
+      end
+
+      def risk(start, target)
+        queue = Heap.new { |a, b| a[0] < b[0] }
+        queue << [0, start]
+
+        costs = {start => 0}
+
+        loop do
+          break if queue.empty?
+
+          cost, spot = queue.pop
+          break cost if spot == target
+
+          @cave.adjacent_spots(spot).each do |new_spot|
+            new_cost = cost + @cave.cost(new_spot)
+            next if costs.key?(new_spot) && costs[new_spot] <= new_cost
+
+            costs[new_spot] = new_cost
+            queue << [new_cost, new_spot]
+          end
+        end
+      end
+    end
+
+    cave = Cave.new(CAVE)
+    spelunker = Spelunker.new(cave)
+    risk = spelunker.risk([0, 0], [cave.width - 1, cave.height - 1])
+    solve!("The minimal risk to traverse the cave is:", risk)
+
+    cave = Cave.new(DEEP_CAVE)
+    spelunker = Spelunker.new(cave)
+    risk = spelunker.risk([0, 0], [cave.width - 1, cave.height - 1])
+    solve!("The minimal risk to traverse the deep cave is:", risk)

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

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