From 52dc14a761ae49d78fa2ec211988e7bc52702f32 Mon Sep 17 00:00:00 2001 From: Jeremy Kaplan Date: Fri, 27 Dec 2019 18:40:12 -0700 Subject: [PATCH] 2019: Day 19 Part 1 --- 2019/day19/intcode.rb | 252 ++++++++++++++++++++++++++++++++++++++++++ 2019/day19/part1.rb | 38 +++++++ 2 files changed, 290 insertions(+) create mode 100644 2019/day19/intcode.rb create mode 100644 2019/day19/part1.rb diff --git a/2019/day19/intcode.rb b/2019/day19/intcode.rb new file mode 100644 index 0000000..1fbe41f --- /dev/null +++ b/2019/day19/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.map { |i| i || '-' }.join(' ')}\n" + end + s + end + + def read(addr, mode) + # raise ArgumentError, "address out of range: #{addr}" if addr.negative? || addr >= @cells.size + return 0 if addr.negative? || addr >= @cells.size + + case mode + when INDIRECT_MODE + read(@cells[addr], IMMEDIATE_MODE) + when IMMEDIATE_MODE + @cells[addr] || 0 + 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.size + + 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 diff --git a/2019/day19/part1.rb b/2019/day19/part1.rb new file mode 100644 index 0000000..f38ad26 --- /dev/null +++ b/2019/day19/part1.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +require_relative 'intcode' + +Cell = Struct.new(:x, :y) + +class Drone + def initialize(program, target) + @computer = Intcode::Computer.new(program.as_memory) { on_input } + @input_queue = [target.x, target.y] + end + + def on_input + @input_queue.shift + end + + def run + @computer.next_output + end +end + +program = Intcode.read(File.join(__dir__, 'input')) + +affected = 0 +(0...50).each do |y| + (0...50).each do |x| + drone = Drone.new(program, Cell.new(x, y)) + case drone.run + when 0 + print '.' + when 1 + print '#' + affected += 1 + end + end + print "\n" +end +puts affected