From ae044cb162fae13f31c6ac07a1db5bfa86496432 Mon Sep 17 00:00:00 2001 From: Jeremy Kaplan Date: Tue, 17 Dec 2019 09:24:02 -0800 Subject: [PATCH] 2019: Day 17 Part 1 --- 2019/day17/intcode.rb | 252 ++++++++++++++++++++++++++++++++++++++++++ 2019/day17/part1.rb | 125 +++++++++++++++++++++ 2 files changed, 377 insertions(+) create mode 100644 2019/day17/intcode.rb create mode 100644 2019/day17/part1.rb diff --git a/2019/day17/intcode.rb b/2019/day17/intcode.rb new file mode 100644 index 0000000..4e827f3 --- /dev/null +++ b/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 diff --git a/2019/day17/part1.rb b/2019/day17/part1.rb new file mode 100644 index 0000000..04915a5 --- /dev/null +++ b/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