advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,97 @@
+---
+- :name: 16.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "rb_heap/heap"
+    require "matrix"
+
+    class Maze
+      DIRECTIONS = %i[e s w n]
+      MOVES = {e: Vector[1, 0], s: Vector[0, 1], w: Vector[-1, 0], n: Vector[0, -1]}
+      WALL = "#"
+
+      STEP_COST = 1
+      TURN_COST = 1000
+
+      def initialize(maze)
+        @maze = maze
+      end
+
+      def options(start, facing)
+        [
+          ([start + MOVES[facing], facing, STEP_COST] unless @maze[start + MOVES[facing]] == WALL),
+          [start, DIRECTIONS[(DIRECTIONS.index(facing) - 1) % DIRECTIONS.length], TURN_COST],
+          [start, DIRECTIONS[(DIRECTIONS.index(facing) + 1) % DIRECTIONS.length], TURN_COST]
+        ].compact
+      end
+
+      def optimal_routes(start, goal)
+        facing = :e
+        queue = Heap.new { |a, b| a[0] < b[0] }
+        queue << [0, start, facing, []]
+
+        scores = {[start, facing] => 0}
+        origins = {[start, facing] => []}
+
+        loop do
+          break if queue.empty?
+
+          score, spot, facing = queue.pop
+          options(spot, facing).each do |new_spot, new_facing, cost|
+            key = [new_spot, new_facing]
+            new_score = score + cost
+
+            next if scores.key?(key) && scores[key] < new_score
+
+            if scores.key?(key) && scores[key] == new_score
+              origins[key] << [spot, facing]
+            else
+              scores[key] = new_score
+              origins[key] = [[spot, facing]]
+
+              queue << [new_score, new_spot, new_facing] unless new_spot == goal
+            end
+          end
+        end
+
+        {
+          scores: scores.select { |(position, facing), score| position == goal },
+          origins: origins
+        }
+      end
+
+      def best_score(start, goal)
+        optimal_routes(start, goal)[:scores].min_by(&:last)[1]
+      end
+
+      def best_tiles(start, goal)
+        routes = optimal_routes(start, goal)
+        route = routes[:scores].min_by(&:last)[0]
+        origins = routes[:origins][route]
+
+        tiles = Set.new([route[0]] + origins.map(&:first))
+
+        loop do
+          break tiles.count if origins.empty?
+
+          origins = origins.flat_map do |origin|
+            routes[:origins][origin].each do |tile, _|
+              tiles << tile
+            end
+          end
+        end
+      end
+    end
+
+    MAZE = INPUT.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
+
+    START = MAZE.key("S")
+    GOAL = MAZE.key("E")
+
+    maze = Maze.new(MAZE)
+    solve!("The minimum possible score is:", maze.best_score(START, GOAL))
+    solve!("The number of tiles along optimal paths is:", maze.best_tiles(START, GOAL))

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

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

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

@@ -0,0 +1,92 @@
+---
+- :name: 17.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    registers, program = INPUT.split("\n\n")
+
+    PROGRAM = program.split(" ").last.split(",").map(&:to_i)
+
+    REGISTER_MATCHER = /\ARegister (?<label>.+): (?<value>-?\d+)\z/
+    REGISTERS = registers.split("\n").each_with_object({}) do |register, data|
+      match = register.match(REGISTER_MATCHER)
+      data[match[:label].to_sym] = match[:value].to_i
+    end
+
+    OPCODES = %i[adv bxl bst jnz bxc out bdv cdv]
+    OPERATIONS = {}
+
+    def combo_operand(registers, operand)
+      if operand <= 3
+        operand
+      elsif operand == 4
+        registers[:A]
+      elsif operand == 5
+        registers[:B]
+      elsif operand == 6
+        registers[:C]
+      else
+        raise "Invalid program"
+      end
+    end
+
+    def run(instructions, registers)
+      registers = registers.dup
+      outputs = []
+
+      pointer = 0
+      loop do
+        break if pointer >= instructions.length
+
+        operator = instructions[pointer]
+        operand = instructions[pointer + 1]
+
+        case OPCODES[operator]
+        when :adv
+          registers[:A] = registers[:A] / (2**combo_operand(registers, operand))
+        when :bxl
+          registers[:B] = registers[:B] ^ operand
+        when :bst
+          registers[:B] = combo_operand(registers, operand) % 8
+        when :jnz
+          if registers[:A] != 0
+            pointer = operand
+            next
+          end
+        when :bxc
+          registers[:B] = registers[:B] ^ registers[:C]
+        when :out
+          outputs << combo_operand(registers, operand) % 8
+        when :bdv
+          registers[:B] = registers[:A] / (2**combo_operand(registers, operand))
+        when :cdv
+          registers[:C] = registers[:A] / (2**combo_operand(registers, operand))
+        end
+
+        pointer += 2
+      end
+
+      outputs
+    end
+
+    solve!("The output after running is:", run(PROGRAM, REGISTERS).join(","))
+
+    def a_value(program, i = program.length - 1, value = 0)
+      return value if i < 0
+
+      registers = REGISTERS.dup
+      value = value << 3
+
+      (value...(value + 8)).each do |j|
+        registers[:A] = j
+        output = run(PROGRAM, registers)
+
+        if output[0] == program[i]
+          final = a_value(program, i - 1, j)
+          return final if final > 0
+        end
+      end
+
+      -1
+    end
+
+    solve!("The minimal A value that copies the program is:", a_value(PROGRAM))

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

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

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

@@ -0,0 +1,77 @@
+---
+- :name: 18.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+    require "rb_heap/heap"
+
+    BYTES = INPUT.split("\n").each_with_index.each_with_object({}) do |(line, t), grid|
+      x, y = line.split(",").map(&:to_i)
+      grid[Vector[x, y]] = t + 1
+    end
+
+    class Computer
+      ORIGIN = Vector[0, 0]
+      NEIGHBORS = [Vector[1, 0], Vector[0, 1], Vector[-1, 0], Vector[0, -1]]
+
+      def initialize(bytes, size)
+        @bytes = bytes
+        @size = size
+        @goal = Vector[size - 1, size - 1]
+      end
+
+      def neighbors_at(spot, time)
+        NEIGHBORS.filter_map do |adjacency|
+          new_spot = spot + adjacency
+          next if new_spot[0] < 0 || new_spot[0] >= @size
+          next if new_spot[1] < 0 || new_spot[1] >= @size
+          next if @bytes[new_spot] && @bytes[new_spot] <= time
+
+          new_spot
+        end
+      end
+
+      def steps_after(time)
+        queue = Heap.new { |a, b| a[0] + (@goal - a[1]).magnitude < b[0] + (@goal - b[1]).magnitude }
+        queue << [0, ORIGIN]
+        steps = {ORIGIN => 0}
+
+        loop do
+          break steps[@goal] if queue.empty?
+
+          step, spot = queue.pop
+          break step if spot == @goal
+          next if steps[spot] < step
+
+          neighbors_at(spot, time).each do |new_spot|
+            next if steps.key?(new_spot) && steps[new_spot] <= step + 1
+
+            steps[new_spot] = step + 1
+            queue << [step + 1, new_spot]
+          end
+        end
+      end
+    end
+
+    SIZE ||= 71
+    TIME ||= 1024
+
+    computer = Computer.new(BYTES, SIZE)
+    solve!(computer.steps_after(TIME))
+
+    lower = TIME
+    upper = BYTES.size
+
+    blocked_at = loop do
+      break upper if lower + 1 == upper
+      test = (lower + upper) / 2
+
+      if computer.steps_after(test).nil?
+        upper = test
+      else
+        lower = test
+      end
+    end
+
+    blocking_byte = BYTES.key(blocked_at)
+    solve!("#{blocking_byte[0]},#{blocking_byte[1]}")

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

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

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

@@ -0,0 +1,19 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    patterns, designs = INPUT.split("\n\n")
+    PATTERNS = patterns.split(", ")
+    DESIGNS = designs.split("\n")
+
+    def possibilities(design, patterns, known = {})
+      return 1 if design.nil? || design.empty?
+
+      known[design] ||= patterns.sum do |pattern|
+        next 0 unless design.start_with?(pattern)
+        possibilities(design[pattern.length..], patterns, known)
+      end
+    end
+
+    solve!("The number of possible designs is:", DESIGNS.count { |design| possibilities(design, PATTERNS) > 0 })
+    solve!("The number of unique constructions is:", DESIGNS.sum { |design| possibilities(design, PATTERNS) })

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

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

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

@@ -0,0 +1,66 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    TRACK = INPUT.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
+
+    ADJACENCIES = [Vector[1, 0], Vector[0, 1], Vector[-1, 0], Vector[0, -1]]
+
+    START = TRACK.key("S")
+    GOAL = TRACK.key("E")
+    PATH = {START => 0}
+
+    position = START
+    steps = 0
+
+    loop do
+      break if position == GOAL
+      move = ADJACENCIES.detect do |move|
+        next if PATH[position + move]
+        TRACK[position + move] != "#"
+      end
+
+      position += move
+      PATH[position] = steps
+      steps += 1
+    end
+
+    def distance(from, to)
+      (to - from).map(&:abs).sum
+    end
+
+    def shortcuts(path, savings, length)
+      max_steps = path.values.max
+      minx, maxx = path.keys.map { |v| v[0] }.minmax
+      miny, maxy = path.keys.map { |v| v[1] }.minmax
+
+      path.sum do |from, time|
+        next 0 if max_steps - time < savings
+
+        ((from[0] - length)..(from[0] + length)).sum do |x|
+          next 0 if x < minx || x > maxx
+          dy = length - (x - from[0]).abs
+
+          ((from[1] - dy)..(from[1] + dy)).count do |y|
+            next if y < miny || y > maxy
+
+            to = Vector[x, y]
+            next unless path.key?(to)
+            next if path[to] - time < savings
+
+            d = distance(from, to)
+            d <= length && (path[to] - time - d + 1) >= savings
+          end
+        end
+      end
+    end
+
+    SAVINGS ||= 100
+    solve!("The number of 2-picosecond shortcuts is:", shortcuts(PATH, SAVINGS, 2))
+    solve!("The number of 20-picosecond shortcuts is:", shortcuts(PATH, SAVINGS, 20))

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

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

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

@@ -0,0 +1,79 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    require "matrix"
+
+    CODES = INPUT.split("\n")
+
+    DIRECTIONAL_LAYOUT = {
+      Vector[1, 0] => "^", Vector[2, 0] => "A",
+      Vector[0, 1] => "<", Vector[1, 1] => "v", Vector[2, 1] => ">"
+    }
+
+    NUMERIC_LAYOUT = {
+      Vector[0, 0] => "7", Vector[1, 0] => "8", Vector[2, 0] => "9",
+      Vector[0, 1] => "4", Vector[1, 1] => "5", Vector[2, 1] => "6",
+      Vector[0, 2] => "1", Vector[1, 2] => "2", Vector[2, 2] => "3",
+      Vector[1, 3] => "0", Vector[2, 3] => "A"
+    }
+
+    class Keypad
+      def initialize(layout)
+        @layout = layout
+        @sequences = {}
+      end
+
+      def position(key)
+        @layout.key(key)
+      end
+
+      def sequence(from, to)
+        @sequences[[from, to]] ||= begin
+          sequence = []
+
+          p1 = position(from)
+          p2 = position(to)
+
+          move_x = p2[0] - p1[0]
+          move_y = p2[1] - p1[1]
+
+          if move_x < 0 && @layout.key?(p1 + Vector[move_x, 0])
+            move_x.abs.times { sequence << "<" }
+            move_y.abs.times { sequence << ((move_y < 0) ? "^" : "v") }
+          elsif @layout.key?(p1 + Vector[0, move_y])
+            move_y.abs.times { sequence << ((move_y < 0) ? "^" : "v") }
+            move_x.abs.times { sequence << ((move_x < 0) ? "<" : ">") }
+          else
+            move_x.abs.times { sequence << ((move_x < 0) ? "<" : ">") }
+            move_y.abs.times { sequence << ((move_y < 0) ? "^" : "v") }
+          end
+
+          sequence << "A"
+          sequence.join
+        end
+      end
+    end
+
+    DIRECTIONAL_KEYPAD = Keypad.new(DIRECTIONAL_LAYOUT)
+    NUMERIC_KEYPAD = Keypad.new(NUMERIC_LAYOUT)
+
+    def directional_presses(code, robots, cache = {})
+      cache[[code, robots]] ||= "A#{code}".chars.each_cons(2).sum do |a, b|
+        sequence = DIRECTIONAL_KEYPAD.sequence(a, b)
+        next sequence.length if robots == 0
+
+        directional_presses(sequence, robots - 1, cache)
+      end
+    end
+
+    def key_presses(code, robots)
+      entry = "A#{code}".chars.each_cons(2).map { |a, b| NUMERIC_KEYPAD.sequence(a, b) }.join
+      directional_presses(entry, robots - 1)
+    end
+
+    complexity = CODES.sum { |code| code.to_i * key_presses(code, 2) }
+    solve!("The total complexity of two-robot codes is:", complexity)
+
+    complexity = CODES.sum { |code| code.to_i * key_presses(code, 25) }
+    solve!("The total complexity of 25-robot codes is:", complexity)

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

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

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

@@ -0,0 +1,45 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    BUYERS = INPUT.split("\n").map(&:to_i)
+    PRUNE = 16777216
+
+    def evolve(number)
+      number = ((number * 64) ^ number) % PRUNE
+      number = ((number / 32) ^ number) % PRUNE
+      ((number * 2048) ^ number) % PRUNE
+    end
+
+    def secret(seed, iterations = 2000)
+      iterations.times.inject(seed) { |n| evolve(n) }
+    end
+
+    solve!("The sum of secret values is:", BUYERS.sum { |buyer| secret(buyer) })
+
+    def prices(seed, iterations = 2000)
+      number = seed
+      deltas = []
+
+      iterations.times.map do |i|
+        last = number
+        number = evolve(last)
+
+        deltas << (number % 10) - (last % 10)
+        deltas.shift if deltas.size > 4
+
+        [number % 10, deltas.hash]
+      end
+    end
+
+    bananas = BUYERS.each_with_object(Hash.new(0)) do |buyer, totals|
+      seen = {}
+      prices(buyer).each do |price, changes|
+        next if seen[changes]
+
+        seen[changes] = true
+        totals[changes] += price
+      end
+    end
+
+    solve!("The maximum number of bananas is:", bananas.values.max)

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

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

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

@@ -0,0 +1,43 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    NETWORK = INPUT.split("\n").each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |line, network|
+      computer, connected = line.split("-")
+
+      network[computer] << connected
+      network[connected] << computer
+    end
+
+    def cliques(computer, network)
+      network[computer].to_a.combination(2).select do |a, b|
+        network[a].include?(b)
+      end
+    end
+
+    parties = NETWORK.keys.each_with_object(Set.new) do |computer, lans|
+      cliques(computer, NETWORK).each { |peers| lans << Set.new([computer, *peers]) }
+    end
+    matches = parties.count { |party| party.any? { |cpu| cpu.start_with?("t") } }
+
+    solve!("The number of groups containing a 't' computer is:", matches)
+
+    def largest_clique(network, clique = Set.new, ignore = Set.new)
+      return clique if network.empty? && ignore.empty?
+
+      network.keys.map do |computer|
+        largest = largest_clique(
+          network.slice(*network[computer]),
+          clique + [computer],
+          ignore.intersection(network[computer])
+        )
+
+        network.delete(computer)
+        ignore << computer
+
+        largest
+      end.reject(&:nil?).max_by(&:size)
+    end
+
+    max_party = largest_clique(NETWORK.dup)
+    solve!("The LAN party password is:", max_party.sort.join(","))

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

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

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

@@ -0,0 +1,68 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2024
+  :solution: |-
+    setup, outputs = INPUT.split("\n\n")
+
+    WIRE_MATCHER = /\A(?<wire>.+): (?<value>0|1)\z/
+    WIRES = setup.split("\n").each_with_object({}) do |line, wires|
+      match = line.match(WIRE_MATCHER)
+      wires[match[:wire]] = match[:value].to_i(2)
+    end
+
+    GATE_MATCHER = /\A(?<w1>.+) (?<gate>.+) (?<w2>.+) -> (?<output>.+)\z/
+    GATES = outputs.split("\n").each_with_object({}) do |line, gates|
+      match = line.match(GATE_MATCHER)
+      gates[match[:output]] = [match[:w1], match[:w2], match[:gate]]
+    end
+
+    def value_for(wire, wires, gates)
+      wires[wire] ||= begin
+        w1, w2, gate = gates[wire]
+
+        v1 = value_for(w1, wires, gates)
+        v2 = value_for(w2, wires, gates)
+
+        case gate
+        when "XOR" then v1 ^ v2
+        when "AND" then v1 & v2
+        when "OR" then v1 | v2
+        end
+      end
+    end
+
+    def value_on(wires, prefix)
+      keys = wires.keys.select { |w| w.start_with?(prefix) }
+      keys.sort.reverse.map { |k| wires[k] }.join.to_i(2)
+    end
+
+    def value(wires, gates)
+      wires = wires.dup
+
+      gates.keys.each do |output|
+        value_for(output, wires, gates)
+      end
+
+      value_on(wires, "z")
+    end
+
+    solve!("The final value on the Z wires is:", value(WIRES, GATES))
+
+    def used_for?(wire, gates, &block)
+      gates.any? { |_, (w1, w2, g)| (w1 == wire || w2 == wire) && block.call(g) }
+    end
+
+    HIGHEST_OUTPUT_BIT = GATES.keys.select { |k| k.start_with?("z") }.max
+
+    invalid_outputs = GATES.each_with_object([]) do |(output, (w1, w2, gate)), invalid|
+      invalid_operations = [
+        output.start_with?("z") && gate != "XOR" && output != HIGHEST_OUTPUT_BIT,
+        gate == "AND" && w1 != "x00" && w2 != "x00" && used_for?(output, GATES) { |op| op != "OR" },
+        gate == "XOR" && [output, w1, w2].none? { |w| w.start_with?("x", "y", "z") },
+        gate == "XOR" && used_for?(output, GATES) { |op| op == "OR" }
+      ]
+
+      invalid << output if invalid_operations.any?
+    end
+
+    solve!("The swapped outputs are:", invalid_outputs.sort.join(","))

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

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

data/data/solutions/github/eregon/2015/01_1.yml

@@ -0,0 +1,4 @@
+---
+- :name: 1.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2015
+  :solution: p ARGF.read.strip.each_char.inject(0) { |f,c| f + { '(' => 1, ')' => -1 }[c] }

data/data/solutions/github/eregon/2015/01_2.yml

@@ -0,0 +1,9 @@
+---
+- :name: 1b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2015
+  :solution: |-
+    f = 0
+    p (ARGF.read.strip.each_char.find_index { |c|
+      f += { '(' => 1, ')' => -1 }[c]
+      f == -1
+    }+1)

data/data/solutions/github/eregon/2015/02_1.yml

@@ -0,0 +1,9 @@
+---
+- :name: 2.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2015
+  :solution: |-
+    p ARGF.readlines.map(&:chomp).inject(0) { |total,box|
+      l, w, h = box.split('x').map { |e| Integer(e) }
+      surfaces = [l*w, w*h, h*l]
+      total + 2 * surfaces.reduce(:+) + surfaces.min
+    }

data/data/solutions/github/eregon/2015/02_2.yml

@@ -0,0 +1,8 @@
+---
+- :name: 2b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2015
+  :solution: |-
+    p ARGF.readlines.map(&:chomp).inject(0) { |total,box|
+      sides = box.split('x').map { |e| Integer(e) }
+      total + sides.min(2).reduce(:+) * 2 + sides.reduce(:*)
+    }

data/data/solutions/github/eregon/2015/03_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: 3.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2015
+  :solution: |-
+    require 'set'
+    map = Set.new
+    x, y = 0, 0
+    map << [x,y]
+    ARGF.read.chomp.each_char { |c|
+      case c
+      when '<'
+        x -= 1
+      when '>'
+        x += 1
+      when '^'
+        y -= 1
+      when 'v'
+        y += 1
+      else
+        raise c
+      end
+      map << [x,y]
+    }
+    p map.size