more catch up

robbkidd · robbkidd · commit c1e4f0c48907 · 2024-12-19T19:12:27.000-05:00
diff --git a/2024/ruby/Gemfile b/2024/ruby/Gemfile
@@ -6,6 +6,7 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 gem "priority_queue_cxx"
 gem "parallel"
+gem "ruby-progressbar"
 gem "matrix"
 
 gem "rake"
diff --git a/2024/ruby/Gemfile.lock b/2024/ruby/Gemfile.lock
@@ -51,6 +51,7 @@ GEM
       prism (>= 1.2, < 2.0)
       rbs (>= 3, < 4)
       sorbet-runtime (>= 0.5.10782)
+    ruby-progressbar (1.13.0)
     sorbet-runtime (0.5.11670)
     stringio (3.1.2)
     yard (0.9.37)
@@ -73,6 +74,7 @@ DEPENDENCIES
   rake
   rspec
   ruby-lsp
+  ruby-progressbar
   yard-doctest
 
 BUNDLED WITH
diff --git a/2024/ruby/day17.rb b/2024/ruby/day17.rb
@@ -0,0 +1,199 @@
+require_relative 'day'
+require 'parallel'
+
+class Day17 < Day # >
+
+  # @example
+  #   day.part1 #=> '4,6,3,5,6,3,5,2,1,0'
+  def part1
+    computer = ChronospatialComputer.new(input)
+    computer.run
+    computer.output.join(',')
+  end
+
+  # @example
+  #   day = new(EXAMPLE_PART2)
+  #   day.part2 #=> 117440
+  def part2
+    quiney_inputs = Thread::Queue.new
+    n = 0
+    every = 1_000_000
+    while quiney_inputs.empty?
+      Parallel.map(n..n+every, in_threads: 4, progress: "Trying #{n}..#{n+every}") { |value|
+        computer = ChronospatialComputer.new(input)
+        computer.registers[:a] = value
+        computer.run
+        if computer.output == computer.program
+          quiney_inputs << value
+          raise Parallel::Break
+        end
+      }
+      n += every
+    end
+    results = []
+    results << quiney_inputs.pop until quiney_inputs.empty?
+    results.min
+  end
+
+  EXAMPLE_INPUT = File.read("../inputs/day17-example-input.txt")
+  EXAMPLE_PART2 = <<~EXAMPLE
+    Register A: 2024
+    Register B: 0
+    Register C: 0
+
+    Program: 0,3,5,4,3,0
+  EXAMPLE
+end
+
+class ChronospatialComputer
+  attr_reader :input, :registers, :program, :output, :state
+  # @example
+  #   computer = new(Day17::EXAMPLE_INPUT)
+  #   computer.registers #=> {a: 729, b: 0, c: 0}
+  #   computer.program   #=> [0,1,5,4,3,0]
+  def initialize(input='')
+    @input = input
+    @registers, @program = parse(input)
+    @instruction_pointer = 0
+    @output = []
+    @state = :initialized
+  end
+
+  # @example
+  #   computer = new('')
+  #   computer.parse(Day17::EXAMPLE_INPUT) #=> [{a: 729,b: 0,c: 0},[0,1,5,4,3,0]]
+  def parse(input)
+    input_numbers = input.scan(/\d+/).map(&:to_i)
+    [
+      { a: input_numbers[0], b: input_numbers[1], c: input_numbers[2] },
+      input_numbers[3..]
+    ]
+  end
+
+  OPCODES = {
+    0 => :adv,
+    1 => :bxl,
+    2 => :bst,
+    3 => :jnz,
+    4 => :bxc,
+    5 => :out,
+    6 => :bdv,
+    7 => :cdv,
+  }
+  OPCODES.default_proc = ->(h,k){ raise "unknown opcode: #{k}" }
+
+  # @example If register C contains 9, the program 2,6 would set register B to 1.
+  #  computer = new('0 0 9 2 6')
+  #  computer.run
+  #  computer.registers[:b] #=> 1
+  #
+  # @example If register A contains 10, the program 5,0,5,1,5,4 would output 0,1,2.
+  #   computer = new('10 0 0 5 0 5 1 5 4')
+  #   computer.run
+  #   computer.output #=> [0,1,2]
+  #
+  # @example If register A contains 2024, the program 0,1,5,4,3,0 would output 4,2,5,6,7,7,7,7,3,1,0 and leave 0 in register A.
+  #   computer = new('2024 0 0 0 1 5 4 3 0')
+  #   computer.run
+  #   computer.output #=> [4,2,5,6,7,7,7,7,3,1,0]
+  #   computer.registers[:a] #=> 0
+  #
+  # @example If register B contains 29, the program 1,7 would set register B to 26.
+  #   computer = new('0 29 0 1 7')
+  #   computer.run
+  #   computer.registers[:b] #=> 26
+  #
+  # @example If register B contains 2024 and register C contains 43690, the program 4,0 would set register B to 44354.
+  #   computer = new('0 2024 43690 4 0')
+  #   computer.run
+  #   computer.registers[:b] #=> 44354
+  def run
+    @state = :running
+    while @state != :halted
+      if @instruction_pointer < 0 || @instruction_pointer >= @program.length
+        @state = :halted
+        break
+      else
+        opcode, operand = @program[@instruction_pointer, 2].tap{ puts _1.inspect if ENV['DEBUG'] }
+        send(OPCODES.fetch(opcode), operand)
+      end
+      puts @output.inspect if ENV['DEBUG']
+    end
+  end
+
+  def decompile
+    @decompiled ||=
+      @program.each_slice(2).map{ |opcode, operand|
+        "#{OPCODES.fetch(opcode)}(#{operand})"
+      }.join("\n")
+  end
+
+  def combo_value(combo)
+    case combo
+    when 0,1,2,3 ; combo
+    when 4 ; @registers.fetch(:a)
+    when 5 ; @registers.fetch(:b)
+    when 6 ; @registers.fetch(:c)
+    when 7 ; raise "reserved: should not have appeared in a valid program (...yet?)"
+    end
+  end
+
+  # @example with low combo (treat as literal)
+  #   computer = new('')
+  #   computer.registers[:a] = 17
+  #   computer.adv(2)
+  #   computer.registers[:a] #=> 4
+  # @example with high combo (use value in register)
+  #   computer = new('')
+  #   computer.registers[:a] = 17
+  #   computer.registers[:b] = 2
+  #   computer.adv(5)
+  #   computer.registers[:a] #=> 4
+  def adv(combo)
+    @registers[:a] = ( @registers.fetch(:a) / 2**combo_value(combo) ).truncate
+    @instruction_pointer += 2
+  end
+
+  # @example
+  #   computer = new
+  #   computer.registers[:b] = 1
+  #   computer.bxl(2)
+  #   computer.registers[:b] #=> 3
+  def bxl(literal)
+    @registers[:b] = @registers[:b] ^ literal
+    @instruction_pointer += 2
+  end
+
+  def bst(combo)
+    @registers[:b] = combo_value(combo) % 8
+    @instruction_pointer += 2
+  end
+
+  def jnz(literal)
+    if @registers[:a].zero?
+      @instruction_pointer += 2
+    else
+      @instruction_pointer = literal
+    end
+  end
+
+  def bxc(_ignored)
+    @registers[:b] = @registers[:b] ^ @registers[:c]
+    @instruction_pointer += 2
+  end
+
+  def out(combo)
+    @output << combo_value(combo) % 8
+    @instruction_pointer += 2
+  end
+
+  def bdv(combo)
+    @registers[:b] = ( @registers.fetch(:a) / 2**combo_value(combo) ).truncate
+    @instruction_pointer += 2
+  end
+
+  def cdv(combo)
+    @registers[:c] = ( @registers.fetch(:a) / 2**combo_value(combo) ).truncate
+    @instruction_pointer += 2
+  end
+end
diff --git a/2024/ruby/day18.rb b/2024/ruby/day18.rb
@@ -0,0 +1,113 @@
+require_relative 'day'
+require 'fc' # FastContainers::PriorityQueue
+
+class Day18 < Day # >
+  attr_reader :memory_space_size, :start, :goal, :incoming_byte_positions, :first_bytes
+
+  def initialize(input = nil, memory_space_size: 70, first_bytes: 1024)
+    super(input)
+    @memory_space_size = memory_space_size
+    @first_bytes = first_bytes
+    @start = [0, 0]
+    @goal = [@memory_space_size, @memory_space_size]
+    @incoming_byte_positions =
+      @input
+        .split("\n")
+        .map { |line| line.scan(/(\d+)/).flatten.map(&:to_i) }
+  end
+
+  # @example
+  #   day = new(EXAMPLE_INPUT, memory_space_size: 6, first_bytes: 12)
+  #   day.part1 #=> 22
+  def part1
+    find_shortest_path_around_corrupted_memory(
+      Set.new(incoming_byte_positions.take(first_bytes))
+    ).count - 1
+  end
+
+  # @example
+  #   day = new(EXAMPLE_INPUT, memory_space_size: 6, first_bytes: 12)
+  #   day.part2 #=> "6,1"
+  def part2
+    low = first_bytes
+    high = incoming_byte_positions.size
+    result = nil
+
+    while low <= high
+      mid = (low + high) / 2
+      path_to_exit = find_shortest_path_around_corrupted_memory(
+        Set.new(incoming_byte_positions.take(mid))
+      )
+
+      if path_to_exit.empty?
+        result = mid
+        high = mid - 1
+      else
+        low = mid + 1
+      end
+    end
+
+    incoming_byte_positions[result - 1].join(",")
+  end
+
+  def find_shortest_path_around_corrupted_memory(corrupted_memory)
+    backsteps = Hash.new
+    backsteps[start] = nil
+
+    costs = Hash.new(Float::INFINITY)
+    costs[start] = 0 # we start here, though, so it's cheap
+
+    survey_queue = FastContainers::PriorityQueue.new(:min)
+    survey_queue.push(start, 0)
+    while !survey_queue.empty?
+      check_pos = survey_queue.pop
+      break if check_pos == goal
+
+      [ [-1, 0] , [1, 0], [0, -1], [0, 1] ]
+        .map { |offset| [check_pos[0] + offset[0], check_pos[1] + offset[1]] }
+        .select { |neighbor| neighbor.all? { _1.between?(0, @memory_space_size) } }
+        .each do |neighbor|
+          neighbor_cost =
+            costs[check_pos] + (corrupted_memory.include?(neighbor) ? Float::INFINITY : 1)
+
+          if neighbor_cost < costs[neighbor]
+            costs[neighbor] = neighbor_cost
+            backsteps[neighbor] = check_pos
+
+            survey_queue.push(neighbor, neighbor_cost)
+          end
+        end
+    end
+
+    path = []
+    if backsteps.include?(goal)
+      path.push(goal)
+      step_backwards = backsteps[goal]
+      while step_backwards
+        path.push(step_backwards)
+        step_backwards = backsteps[step_backwards]
+      end
+    end
+    puts "\n" + debug(path, corrupted_memory) if ENV['DEBUG']
+    path
+  end
+
+  def debug(path, corrupted_memory)
+    (0..@memory_space_size)
+      .map { |row|
+        (0..@memory_space_size)
+          .map { |column|
+            coords = [column, row]
+            if path.include?(coords)
+              "\e[41m\e[1mO\e[0m"
+            elsif corrupted_memory.include?(coords)
+              "\e[31m#\e[0m"
+            else
+              "\e[32m.\e[0m"
+            end
+          }.join("")
+        }.join("\n")
+  end
+
+  EXAMPLE_INPUT = File.read("../inputs/day18-example-input.txt")
+end
diff --git a/2024/ruby/day19.rb b/2024/ruby/day19.rb
@@ -0,0 +1,20 @@
+require_relative 'day'
+
+class Day19 < Day # >
+
+  # @example
+  #   day.part1 #=> 6
+def part1
+  towels, designs = input.split("\n\n")
+  towel_matcher = Regexp.new(/\A(#{towels.gsub(", ", "|")})+\z/)
+  desired_designs = designs.split("\n")
+  desired_designs.count { |pattern| pattern.match?(towel_matcher) }
+end
+
+  # @example
+  #   day.part2 #=> 16
+  def part2
+  end
+
+  EXAMPLE_INPUT = File.read("../inputs/day19-example-input.txt")
+end
