advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,106 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    require "matrix"
+    require "set"
+
+    class Valley
+      Blizzard = Struct.new(:position, :direction)
+
+      DIRECTIONS = {
+        "<" => Vector[-1, 0],
+        ">" => Vector[1, 0],
+        "v" => Vector[0, 1],
+        "^" => Vector[0, -1]
+      }
+
+      attr_reader :height, :width
+
+      def initialize(diagram)
+        area = diagram.split("\n")
+
+        @height = area.size - 2
+        @width = area.first.size - 2
+        @blizzards = []
+
+        area[1..-2].each_with_index do |line, y|
+          line[1..-2].chars.each_with_index do |tile, x|
+            @blizzards << Blizzard.new(Vector[x, y], DIRECTIONS[tile]) if DIRECTIONS.key?(tile)
+          end
+        end
+      end
+
+      def valid?(position, time)
+        return false if position[0] < 0 || position[0] >= width
+        return false if position[1] < 0 || position[1] >= height
+
+        !blizzards_at(time)[position]
+      end
+
+      def entrance
+        Vector[0, -1]
+      end
+
+      def goal
+        Vector[width - 1, height]
+      end
+
+      private
+
+      def blizzards_at(time)
+        @blizzards_at ||= {}
+        @blizzards_at[time % height.lcm(width)] ||= @blizzards.each_with_object({}) do |blizzard, map|
+          computed = blizzard.position + (blizzard.direction * time)
+          position = Vector[computed[0] % width, computed[1] % height]
+
+          map[position] = true
+        end
+      end
+    end
+
+    class Expedition
+      def initialize(valley)
+        @valley = valley
+      end
+
+      def quickest_route(at: 0, from: @valley.entrance, to: @valley.goal)
+        positions = Set.new([from])
+        time = at
+
+        loop do
+          break time if positions.include?(to)
+
+          next_positions = Set.new
+          positions.each do |position|
+            Valley::DIRECTIONS.each_value do |dv|
+              next if next_positions.include?(position + dv)
+              next unless position + dv == to || @valley.valid?(position + dv, time + 1)
+              next_positions << position + dv
+            end
+
+            next unless position == from || @valley.valid?(position, time + 1)
+            next_positions << position
+          end
+
+          positions = next_positions
+          time += 1
+        end
+      end
+    end
+
+    VALLEY = Valley.new(INPUT)
+    EXPEDITION = Expedition.new(VALLEY)
+
+    time = EXPEDITION.quickest_route
+    solve!(
+      "The fastest time possible through the blizzards is:",
+      time
+    )
+
+    time = EXPEDITION.quickest_route(at: time, from: VALLEY.goal, to: VALLEY.entrance)
+    time = EXPEDITION.quickest_route(at: time)
+    solve!(
+      "The fastest time including a return trip is:",
+      time
+    )

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

@@ -0,0 +1,35 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2022
+  :solution: |-
+    VALUES = {
+      "=" => -2,
+      "-" => -1,
+      "0" => 0,
+      "1" => 1,
+      "2" => 2
+    }
+
+    def parse(snafu)
+      snafu.chars.reduce([]) do |places, c|
+        places.map { |p| p * 5 } + [VALUES[c]]
+      end.sum
+    end
+
+    def snafuize(value)
+      carry = 0
+      snafu = value.to_s(5).chars.reverse.map do |c|
+        v = c.to_i + carry
+        carry = v / 3
+        VALUES.key(v - (carry * 5))
+      end
+      snafu << VALUES.key(carry) if carry > 0
+
+      snafu.reverse.join
+    end
+
+    decimal = INPUT.split("\n").sum { |snafu| parse(snafu) }
+    solve!(
+      "The SNAFU number you should supply is:",
+      snafuize(decimal)
+    )

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

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

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

@@ -0,0 +1,38 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    LINES = INPUT.split("\n").freeze
+
+    sum = LINES.reduce(0) do |total, line|
+      numbers = line.scan(/\d/)
+      value = numbers.first.to_i * 10 + numbers.last.to_i
+
+      total + value
+    end
+
+    solve!("The sum of calibration values is:", sum)
+
+    REPLACEMENTS = {
+      "one" => 1,
+      "two" => 2,
+      "three" => 3,
+      "four" => 4,
+      "five" => 5,
+      "six" => 6,
+      "seven" => 7,
+      "eight" => 8,
+      "nine" => 9
+    }.freeze
+
+    sum = LINES.reduce(0) do |total, line|
+      numbers = line.chars.each_with_index.each_with_object([]) do |(c, i), digits|
+        translated = line[i..].sub(Regexp.union(REPLACEMENTS.keys), REPLACEMENTS)
+        digits << translated[0] if translated[0] =~ /\d/
+      end.map(&:to_i)
+
+      value = numbers.first.to_i * 10 + numbers.last.to_i
+      total + value
+    end
+
+    solve!("The sum of calibration values with word digits is:", sum)

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

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

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

@@ -0,0 +1,38 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    GAME_MATCHER = /\AGame (?<id>\d+): (?<hands>.+)\z/
+    HOLD_MATCHER = /(?<count>\d+) (?<color>\w+)/
+    COLORS = %i[red green blue].freeze
+
+    Game = Data.define(:id, :hands) do
+      def possible?(test)
+        hands.all? do |hand|
+          COLORS.all? { |color| hand[color] <= test[color] }
+        end
+      end
+
+      def power
+        COLORS.map { |color| hands.map { |h| h[color] }.max }.reduce(:*)
+      end
+    end
+
+    GAMES = INPUT.split("\n").map do |line|
+      data = line.match(GAME_MATCHER)
+      id = data[:id].to_i
+      hands = data[:hands].split(";").map do |hand|
+        hand.split(",").each_with_object(Hash.new(0)) do |item, colors|
+          hold = item.match(HOLD_MATCHER)
+          colors[hold[:color].to_sym] = hold[:count].to_i
+        end
+      end
+
+      Game.new(id:, hands:)
+    end.freeze
+
+    TEST = {red: 12, green: 13, blue: 14}.freeze
+    possibilities = GAMES.select { |g| g.possible?(TEST) }
+
+    solve!("The sum of possible game IDs is:", possibilities.sum(&:id))
+    solve!("The total set power across games is:", GAMES.sum(&:power))

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

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

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

@@ -0,0 +1,55 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    EMPTY = "."
+    SCHEMATIC = INPUT.split("\n").each_with_index.each_with_object(Hash.new(EMPTY)) do |(line, y), grid|
+      line.chars.each_with_index { |c, x| grid[[x, y]] = c }
+    end
+
+    def part_at?(schematic, y, xs)
+      edges = [
+        [xs[0] - 1, y - 1],
+        [xs[0] - 1, y],
+        [xs[0] - 1, y + 1],
+        [xs[-1] + 1, y - 1],
+        [xs[-1] + 1, y],
+        [xs[-1] + 1, y + 1]
+      ]
+
+      edges.any? { |coord| schematic[coord] != EMPTY } ||
+        xs.any? { |x| schematic[[x, y - 1]] != EMPTY || schematic[[x, y + 1]] != EMPTY }
+    end
+
+    Part = Data.define(:id, :row, :columns) do
+      def adjacent_to?((x, y))
+        (row - 1 <= y && row + 1 >= y) &&
+          (columns[0] - 1 <= x && columns[-1] + 1 >= x)
+      end
+    end
+
+    HEIGHT = SCHEMATIC.keys.map(&:last).max
+    WIDTH = SCHEMATIC.keys.map(&:first).max
+
+    PARTS = (0..HEIGHT).flat_map do |y|
+      (0..WIDTH)
+        .chunk { |x| SCHEMATIC[[x, y]].match?(/\d/) }
+        .select(&:first)
+        .map(&:last)
+        .select { |columns| part_at?(SCHEMATIC, y, columns) }
+        .map do |columns|
+          Part.new(
+            id: columns.map { |x| SCHEMATIC[[x, y]] }.join.to_i,
+            row: y,
+            columns:
+          )
+        end
+    end
+
+    solve!("The sum of part IDs is:", PARTS.sum(&:id))
+
+    GEAR = "*"
+    gears = SCHEMATIC.select { |coord, c| c == GEAR && PARTS.count { |p| p.adjacent_to?(coord) } == 2 }.map(&:first)
+    ratios = gears.map { |coord| PARTS.select { |p| p.adjacent_to?(coord) }.map(&:id).reduce(:*) }
+
+    solve!("The sum of gear ratios is:", ratios.sum)

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

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

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

@@ -0,0 +1,39 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    Card = Data.define(:id, :winning_numbers, :personal_numbers) do
+      def matches
+        (winning_numbers & personal_numbers).count
+      end
+
+      def score
+        (matches > 0) ? (matches - 1).times.reduce(1) { |i, _| i * 2 } : 0
+      end
+    end
+
+    CARDS = INPUT.split("\n").map do |line|
+      identifier, numbers = line.split(":")
+      winning, personal = numbers.split("|")
+
+      Card.new(
+        id: identifier.scan(/\d+/).first.to_i,
+        winning_numbers: winning.scan(/\d+/).map(&:to_i),
+        personal_numbers: personal.scan(/\d+/).map(&:to_i)
+      )
+    end
+
+    solve!("The total point value of your cards is:", CARDS.sum(&:score))
+
+    def winnings(cards)
+      counts = cards.to_h { |card| [card.id, 1] }
+      cards.each do |card|
+        card.matches.times do |i|
+          counts[card.id + i + 1] += counts[card.id]
+        end
+      end
+
+      counts.values.sum
+    end
+
+    solve!("The total number of cards in the pile (including copies) is:", winnings(CARDS))

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

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

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

@@ -0,0 +1,85 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    Range = Data.define(:source_start, :destination_start, :length) do
+      def source?(n)
+        source_start <= n && source_end >= n
+      end
+
+      def destination_for(n)
+        destination_start + (n - source_start)
+      end
+
+      def source_end
+        source_start + length
+      end
+
+      def destination_range(source_range)
+        destination_for(source_range.begin)...destination_for(source_range.end)
+      end
+    end
+
+    Map = Data.define(:source, :destination, :ranges) do
+      def destination_for(n)
+        range = ranges.detect { |r| r.source?(n) }
+        range ? range.destination_for(n) : n
+      end
+
+      def destination_ranges(sources)
+        ranges.each_with_object([]) do |range, mapped|
+          sources = sources.each_with_object([]) do |source, unmapped|
+            before = source.begin...[source.end, range.source_start].min
+            overlap = [source.begin, range.source_start].max...[range.source_end, source.end].min
+            after = [range.source_end, source.begin].max...source.end
+
+            unmapped << before if before.end > before.begin
+            unmapped << after if after.end > after.begin
+            mapped << range.destination_range(overlap) if overlap.end > overlap.begin
+          end
+        end + sources
+      end
+    end
+
+    seeds, *maps = INPUT.split("\n\n")
+
+    DESCRIPTION_MATCHER = /\A(?<source>\w+)-to-(?<destination>\w+) map:\z/
+    SEEDS = seeds.scan(/\d+/).map(&:to_i)
+    MAPS = maps.each_with_object({}) do |map, translations|
+      description, *values = map.split("\n")
+      info = description.match(DESCRIPTION_MATCHER)
+      ranges = values.map do |line|
+        d, s, l = line.split(" ").map(&:to_i)
+        Range.new(
+          source_start: s,
+          destination_start: d,
+          length: l
+        )
+      end
+
+      translations[info[:source]] = Map.new(
+        source: info[:source],
+        destination: info[:destination],
+        ranges:
+      )
+    end
+
+    def locations_for(sources)
+      type = "seed"
+
+      loop do
+        map = MAPS[type]
+        type = map.destination
+        sources = yield map, sources
+
+        break sources if type == "location"
+      end
+    end
+
+    locations = locations_for(SEEDS) { |map, sources| sources.map { |s| map.destination_for(s) } }
+    solve!("The minimum seed location is:", locations.min)
+
+    seeds = SEEDS.each_slice(2).map { |(a, b)| a...(a + b) }
+    ranges = locations_for(seeds) { |map, sources| map.destination_ranges(sources) }
+
+    solve!("The minimum location for seed ranges is:", ranges.map(&:begin).min)

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    times, distances = INPUT.split("\n")
+    TIMES = times.scan(/\d+/).map(&:to_i)
+    RECORDS = distances.scan(/\d+/).map(&:to_i)
+
+    def distance_for(t, time)
+      (time - t) * t
+    end
+
+    def strategies_for(time, distance)
+      min = distance / time
+      min += 1 until distance_for(min, time) > distance
+
+      max = time
+      max -= 1 until distance_for(max, time) > distance
+
+      max - min + 1
+    end
+
+    strategies = TIMES.zip(RECORDS).map { |time, distance| strategies_for(time, distance) }
+    solve!("The product of winning strategies is:", strategies.reduce(:*))
+
+    TIME = times.gsub(/\D+/, "").to_i
+    RECORD = distances.gsub(/\D+/, "").to_i
+
+    solve!("The long-run winning strategy count is:", strategies_for(TIME, RECORD))

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

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

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

@@ -0,0 +1,37 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    CARD_SCORES = %w[2 3 4 5 6 7 8 9 T J Q K A].each_with_index.to_h.freeze
+    JOKER_SCORES = %w[J 2 3 4 5 6 7 8 9 T Q K A].each_with_index.to_h.freeze
+
+    Hand = Data.define(:cards) do
+      def score
+        base_score = cards.tally.values.sort.reverse
+        [base_score] + cards.map { |c| CARD_SCORES[c] }
+      end
+
+      def joker_score
+        counts = cards.tally
+        jokers = counts.delete("J") || 0
+
+        base_score = counts.values.sort.reverse
+        base_score = [0] if base_score.empty?
+        base_score[0] += jokers
+
+        [base_score] + cards.map { |c| JOKER_SCORES[c] }
+      end
+    end
+
+    BIDS = INPUT.split("\n").to_h do |line|
+      hand, bid = line.split(" ")
+      [Hand.new(cards: hand.chars), bid.to_i]
+    end
+    HANDS = BIDS.keys
+
+    def winnings(hands, bids)
+      hands.map.with_index { |h, i| bids[h] * (i + 1) }.sum
+    end
+
+    solve!("The total winnings are:", winnings(HANDS.sort_by(&:score), BIDS))
+    solve!("The total winnings with jokers are:", winnings(HANDS.sort_by(&:joker_score), BIDS))

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

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

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

@@ -0,0 +1,51 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    instructions, nodes = INPUT.split("\n\n")
+
+    NODE_MATCHER = /\A(?<id>.+) = \((?<left>.+), (?<right>.+)\)\z/
+    INSTRUCTIONS = instructions.chars
+    NETWORK = nodes.split("\n").to_h do |node|
+      data = node.match(NODE_MATCHER)
+
+      [data[:id], [data[:left], data[:right]]]
+    end
+
+    steps = 0
+    node = "AAA"
+
+    steps = loop do
+      step = (INSTRUCTIONS[steps % INSTRUCTIONS.count] == "L") ? 0 : 1
+      node = NETWORK[node][step]
+      steps += 1
+
+      break steps if node == "ZZZ"
+    end
+
+    solve!("The number of steps required to escape is:", steps)
+
+    steps = 0
+    nodes = NETWORK.keys.select { |node| node.end_with?("A") }
+    checkpoints = Array.new(nodes.length)
+    periods = Array.new(nodes.length)
+
+    steps = loop do
+      step = (INSTRUCTIONS[steps % INSTRUCTIONS.count] == "L") ? 0 : 1
+      nodes = nodes.map { |node| NETWORK[node][step] }
+      steps += 1
+
+      nodes.each_with_index do |n, i|
+        next unless periods[i].nil? && n.end_with?("Z")
+
+        if checkpoints[i] && periods[i].nil?
+          periods[i] = steps - checkpoints[i]
+        elsif checkpoints[i].nil?
+          checkpoints[i] = steps
+        end
+      end
+
+      break periods.reduce(&:lcm) if periods.all?
+    end
+
+    solve!("The number of steps required for a ghost to escape is:", steps)

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

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

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

@@ -0,0 +1,29 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    REPORT = INPUT.split("\n").map { |line| line.split(" ").map(&:to_i) }
+
+    def decompose(history)
+      sequences = [history]
+
+      loop do
+        break sequences if history.all? { |d| d == 0 }
+
+        history = history.each_cons(2).each_with_object([]) { |(a, b), gaps| gaps << b - a }
+        sequences << history
+      end
+    end
+
+    def extrapolate_next(history)
+      decompose(history).sum(&:last)
+    end
+
+    def extrapolate_previous(history)
+      decompose(history).reverse.reduce(0) do |gap, sequence|
+        sequence.first - gap
+      end
+    end
+
+    solve!("The sum of next values is:", REPORT.sum { |history| extrapolate_next(history) })
+    solve!("The sum of previous values is:", REPORT.sum { |history| extrapolate_previous(history) })

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

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

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

@@ -0,0 +1,85 @@
+---
+- :name: 10.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2023
+  :solution: |-
+    NORTH_ANGLES = %w[7 | F].freeze
+    ANGLES = {
+      "|" => ->(x, y) { [[x, y - 1], [x, y + 1]] },
+      "-" => ->(x, y) { [[x - 1, y], [x + 1, y]] },
+      "L" => ->(x, y) { [[x, y - 1], [x + 1, y]] },
+      "J" => ->(x, y) { [[x, y - 1], [x - 1, y]] },
+      "7" => ->(x, y) { [[x, y + 1], [x - 1, y]] },
+      "F" => ->(x, y) { [[x, y + 1], [x + 1, y]] }
+    }.freeze
+
+    Pipe = Data.define(:angle, :connections) do
+      def connects_to?(position)
+        connections.include?(position)
+      end
+
+      def north?
+        NORTH_ANGLES.include?(angle)
+      end
+    end
+
+    starting_position = []
+    MAP = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, y), map|
+      line.chars.each_with_index do |angle, x|
+        if angle == "S"
+          starting_position = [x, y]
+          next
+        end
+
+        next unless ANGLES.key?(angle)
+
+        connections = ANGLES[angle].call(x, y)
+        map[[x, y]] = Pipe.new(angle:, connections:)
+      end
+    end
+
+    connections = MAP.select { |_, pipe| pipe.connects_to?(starting_position) }.map(&:first)
+    angle = ANGLES.keys.detect do |a|
+      connected = ANGLES[a].call(*starting_position)
+      connected.all? { |conn| connections.include?(conn) }
+    end
+
+    MAP[starting_position] = Pipe.new(angle:, connections:)
+
+    def distance_map(map, start_at)
+      distances = {}
+      tests = [[start_at, 0]]
+
+      loop do
+        break distances if tests.empty?
+
+        test, steps = tests.shift
+        next if distances.key?(test)
+
+        tests += map[test].connections.map { |conn| [conn, steps + 1] }
+        distances[test] = steps
+      end
+    end
+
+    distances = distance_map(MAP, starting_position)
+    solve!("The step count to the furthest pipe is:", distances.values.max)
+
+    def enclosed_tiles(loop_map)
+      xmin, xmax = loop_map.keys.map(&:first).minmax
+      ymin, ymax = loop_map.keys.map(&:last).minmax
+      enclosed = 0
+
+      (ymin..ymax).each do |y|
+        north = 0
+        (xmin..xmax).each do |x|
+          if !loop_map[[x, y]]
+            enclosed += 1 if north.odd?
+          elsif loop_map[[x, y]].north?
+            north += 1
+          end
+        end
+      end
+
+      enclosed
+    end
+
+    solve!("The number of enclosed tiles is:", enclosed_tiles(MAP.slice(*distances.keys)))

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

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