2019: Day 17 Part 1

2019/day17/intcode.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Intcode
+  def self.read(filename)
+    parse File.read(filename)
+  end
+
+  def self.parse(input)
+    parsed = input
+             .gsub(/^#.*$/, '')
+             .gsub('\s', '')
+             .split(',')
+             .map(&:to_i)
+    Program.new parsed
+  end
+
+  class Program
+    def initialize(mem)
+      @initial_state = mem
+    end
+
+    def as_memory
+      Memory.new(@initial_state.clone)
+    end
+
+    def run(&user_input)
+      Computer.new(as_memory).run(&user_input)
+    end
+  end
+
+  class Memory
+    extend Forwardable
+
+    def_delegator :@cells, :[]
+    def_delegator :@cells, :[]=
+
+    attr_accessor :relative_base
+
+    def initialize(cells)
+      @cells = cells
+      @relative_base = 0
+    end
+
+    def to_s
+      batch_size = 10
+      s = String.new
+      @cells.each_slice(batch_size).each_with_index do |batch, idx|
+        prefix = idx * batch_size
+        s << "#{prefix}: #{batch.join(' ')}\n"
+      end
+      s
+    end
+
+    def read(addr, mode)
+      # raise ArgumentError, "address out of range: #{addr}" if addr.negative? || addr >= @cells.length
+      return 0 if addr.negative? || addr >= @cells.length
+
+      case mode
+      when INDIRECT_MODE
+        read(@cells[addr], IMMEDIATE_MODE)
+      when IMMEDIATE_MODE
+        @cells[addr]
+      when RELATIVE_MODE
+        read(@cells[addr] + relative_base, IMMEDIATE_MODE)
+      else
+        raise ArgumentError, "unexpected mode: #{mode}"
+      end
+    end
+
+    def write(addr, mode, val)
+      raise ArgumentError, "address out of range: #{addr}" if addr.negative? || addr >= @cells.length
+
+      case mode
+      when INDIRECT_MODE
+        r = @cells[addr]
+        @cells[r] = val
+      when IMMEDIATE_MODE
+        raise ArgumentError, 'writes are not allowed in immediate mode'
+        @cells[addr]
+      when RELATIVE_MODE
+        r = @cells[addr] + relative_base
+        @cells[r] = val
+      else
+        raise ArgumentError, "unexpected mode: #{mode}"
+      end
+    end
+  end
+
+  INDIRECT_MODE = 0
+  IMMEDIATE_MODE = 1
+  RELATIVE_MODE = 2
+
+  class Computer
+    def initialize(mem, &block)
+      @mem = mem
+      @ip = 0
+      @input_block = block
+    end
+
+    def on_output(&block)
+      @output_block = block
+    end
+
+    def run
+      loop do
+        return if tick == :done_executing
+      end
+    end
+
+    def next_output
+      loop do
+        out = tick
+        return nil if out == :done_executing
+        return out if out
+      end
+    end
+
+    def tick
+      opcode = operation(@mem[@ip])
+      case opcode
+      when 1
+        add!
+        nil
+      when 2
+        mul!
+        nil
+      when 3
+        input!(&@input_block)
+        nil
+      when 4
+        output!(&@output_block)
+      when 5
+        branch_if_not_zero!
+        nil
+      when 6
+        branch_if_zero!
+        nil
+      when 7
+        less_than!
+        nil
+      when 8
+        equal!
+        nil
+      when 9
+        move_relative_base!
+        nil
+      when 99
+        :done_executing
+      else
+        raise StandardError, "unexpected opcode: #{opcode}"
+      end
+    end
+
+    private
+
+    def add!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      @mem.write(@ip + 3, mode[2], a + b)
+      @ip += 4
+    end
+
+    def mul!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      @mem.write(@ip + 3, mode[2], a * b)
+      @ip += 4
+    end
+
+    def input!(&user_input)
+      mode = modes(@mem[@ip])
+      inp = input(&user_input)
+      @mem.write(@ip + 1, mode[0], inp)
+      @ip += 2
+    end
+
+    def output!(&user_output)
+      mode = modes(@mem[@ip])
+      output = @mem.read(@ip + 1, mode[0])
+      user_output.call output if block_given?
+      @ip += 2
+      output
+    end
+
+    def branch_if_not_zero!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      @ip = a.zero? ? @ip + 3 : b
+    end
+
+    def branch_if_zero!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      @ip = a.zero? ? b : @ip + 3
+    end
+
+    def less_than!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      val = a < b ? 1 : 0
+      @mem.write(@ip + 3, mode[2], val)
+      @ip += 4
+    end
+
+    def equal!
+      mode = modes(@mem[@ip])
+      a = @mem.read(@ip + 1, mode[0])
+      b = @mem.read(@ip + 2, mode[1])
+      val = a == b ? 1 : 0
+      @mem.write(@ip + 3, mode[2], val)
+      @ip += 4
+    end
+
+    def move_relative_base!
+      mode = modes(@mem[@ip])
+      delta = @mem.read(@ip + 1, mode[0])
+      @mem.relative_base += delta
+      @ip += 2
+    end
+
+    def input
+      if block_given?
+        inp = yield
+        raise "Invalid input: #{inp.inspect}" unless inp.is_a?(Numeric)
+
+        return inp
+      end
+
+      print 'input> '
+      gets.to_i
+    end
+
+    def operation(cell)
+      (cell % 100)
+    end
+
+    def modes(cell)
+      m = Hash.new(0)
+      (cell / 100).truncate.digits.each_with_index do |d, i|
+        m[i] = d
+      end
+      m
+    end
+  end
+end

2019/day17/part1.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'intcode'
+
+Cell = Struct.new(:r, :c) do
+  def neighbors
+    [
+      Cell.new(r + 1, c),
+      Cell.new(r - 1, c),
+      Cell.new(r, c + 1),
+      Cell.new(r, c - 1)
+    ]
+  end
+end
+
+class World
+  def initialize
+    @cells = {}
+    @max_r = -1
+    @max_c = -1
+  end
+
+  def set(cell, contents)
+    @cells[cell] = contents
+    @max_r = [@max_r, cell.r].max
+    @max_c = [@max_c, cell.c].max
+  end
+
+  def intersections
+    @cells.keys.select { |cell| intersection? cell }
+  end
+
+  def intersection?(cell)
+    scaffold?(cell) && cell.neighbors.all? { |neighbor| scaffold?(neighbor) }
+  end
+
+  SCAFFOLDS = %i[scaffold robot_up robot_down robot_left robot_right] .freeze
+
+  def scaffold?(cell)
+    SCAFFOLDS.include? @cells[cell]
+  end
+
+  def to_s
+    s = String.new
+    (0..@max_r).each do |r|
+      (0..@max_c).each do |c|
+        s << char(@cells[Cell.new(r, c)])
+      end
+      s << "\n"
+    end
+    s
+  end
+
+  CHAR_TO_CONTENTS = {
+    '#' => :scaffold,
+    '.' => :open,
+    '^' => :robot_up,
+    'v' => :robot_down,
+    '<' => :robot_left,
+    '>' => :robot_right,
+    'x' => :robot_tumbling
+  }.freeze
+
+  CONTENTS_TO_CHAR = {
+    scaffold: '#',
+    open: '.',
+    robot_up: '^',
+    robot_down: 'v',
+    robot_left: '<',
+    robot_right: '>',
+    robot_tumbling: 'x'
+  }.freeze
+
+  def self.parse(text)
+    r = c = 0
+    world = new
+    text.each_char do |char|
+      if char == "\n"
+        r += 1
+        c = 0
+        next
+      end
+      contents = CHAR_TO_CONTENTS.fetch(char)
+      world.set(Cell.new(r, c), contents)
+      c += 1
+    end
+    world
+  end
+
+  private
+
+  def char(contents)
+    CONTENTS_TO_CHAR.fetch(contents)
+  end
+end
+
+class Calibrator
+  def initialize(program)
+    @computer = Intcode::Computer.new(program.as_memory)
+    @world = nil
+  end
+
+  def calibrate
+    text = ''
+    while (i = tick)
+      text += i.chr
+    end
+    @world = World.parse(text)
+    alignment(@world.intersections)
+  end
+
+  def alignment(intersections)
+    intersections.sum do |cell|
+      cell.r * cell.c
+    end
+  end
+
+  def tick
+    @computer.next_output
+  end
+end
+
+program = Intcode.read(File.join(__dir__, 'input'))
+c = Calibrator.new(program)
+puts c.calibrate