2019: Day 15 Part 1
This commit is contained in:
parent
e5c99b6217
commit
e81de93801
2 changed files with 515 additions and 0 deletions
244
2019/day15/intcode.rb
Normal file
244
2019/day15/intcode.rb
Normal file
|
|
@ -0,0 +1,244 @@
|
|||
# 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 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
|
||||
271
2019/day15/part1.rb
Normal file
271
2019/day15/part1.rb
Normal file
|
|
@ -0,0 +1,271 @@
|
|||
# frozen_string_literal: true
|
||||
|
||||
require 'set'
|
||||
require_relative 'intcode'
|
||||
|
||||
Cell = Struct.new(:x, :y) do
|
||||
def north
|
||||
Cell.new(x, y - 1)
|
||||
end
|
||||
|
||||
def south
|
||||
Cell.new(x, y + 1)
|
||||
end
|
||||
|
||||
def west
|
||||
Cell.new(x - 1, y)
|
||||
end
|
||||
|
||||
def east
|
||||
Cell.new(x + 1, y)
|
||||
end
|
||||
|
||||
def neighbors
|
||||
[north, south, west, east]
|
||||
end
|
||||
|
||||
def direction_to(other)
|
||||
dx = other.x - x
|
||||
dy = other.y - y
|
||||
|
||||
if dy.negative?
|
||||
:north
|
||||
elsif dy.positive?
|
||||
:south
|
||||
elsif dx.negative?
|
||||
:west
|
||||
elsif dx.positive?
|
||||
:east
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class Map
|
||||
def initialize
|
||||
@grid = {}
|
||||
end
|
||||
|
||||
def set_content!(cell, content)
|
||||
@grid[cell] = content
|
||||
end
|
||||
|
||||
def get(cell)
|
||||
@grid[cell]
|
||||
end
|
||||
|
||||
def printable(droid_position)
|
||||
tl, br = corners(droid_position)
|
||||
|
||||
s = String.new
|
||||
(tl.y..br.y).each do |y|
|
||||
(tl.x..br.x).each do |x|
|
||||
cell = Cell.new(x, y)
|
||||
s << if cell == droid_position
|
||||
'D'
|
||||
else
|
||||
char(cell)
|
||||
end
|
||||
end
|
||||
s << "\n"
|
||||
end
|
||||
s
|
||||
end
|
||||
|
||||
def goal
|
||||
@grid.each_pair do |cell, content|
|
||||
return cell if content == :oxygen
|
||||
end
|
||||
nil
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def corners(droid_position)
|
||||
min_x = max_x = droid_position.x
|
||||
min_y = max_y = droid_position.y
|
||||
|
||||
@grid.keys.each do |p|
|
||||
min_x = [min_x, p.x].min
|
||||
min_y = [min_y, p.y].min
|
||||
max_x = [max_x, p.x].max
|
||||
max_y = [max_y, p.y].max
|
||||
end
|
||||
|
||||
upper_left = Cell.new(min_x, min_y)
|
||||
lower_right = Cell.new(max_x, max_y)
|
||||
[upper_left, lower_right]
|
||||
end
|
||||
|
||||
def char(cell)
|
||||
content = get(cell)
|
||||
case content
|
||||
when :wall
|
||||
'#'
|
||||
when :open
|
||||
'.'
|
||||
when :oxygen
|
||||
'G'
|
||||
when nil
|
||||
' '
|
||||
else
|
||||
raise StandardError, "unknown content: #{content}"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class Droid
|
||||
def initialize(program, map)
|
||||
@computer = Intcode::Computer.new(program.as_memory) { on_input }
|
||||
@map = map
|
||||
|
||||
@direction = nil
|
||||
@position = Cell.new(0, 0)
|
||||
@mode = :exploration
|
||||
|
||||
@map.set_content!(@position, :open)
|
||||
end
|
||||
|
||||
MOVEMENT_COMMANDS = { north: 1, south: 2, west: 3, east: 4 }.freeze
|
||||
|
||||
def on_input
|
||||
MOVEMENT_COMMANDS.fetch(@direction)
|
||||
end
|
||||
|
||||
def run
|
||||
iterations = 0
|
||||
loop do
|
||||
result = step!
|
||||
if (iterations % 100).zero?
|
||||
print_state!
|
||||
sleep 0.01
|
||||
end
|
||||
|
||||
return result if result
|
||||
|
||||
iterations += 1
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def step!
|
||||
case @mode
|
||||
when :exploration
|
||||
step_exploration!
|
||||
nil
|
||||
when :pathfinding
|
||||
step_pathfinding
|
||||
end
|
||||
end
|
||||
|
||||
def step_pathfinding
|
||||
search(Cell.new(0, 0), @map.goal)
|
||||
end
|
||||
|
||||
def step_exploration!
|
||||
if @path.nil? || @path.length.zero? || @position == @path[-1] || blocked?(@path)
|
||||
target = closest_unexplored_cell
|
||||
if target.nil?
|
||||
# Nothing left to see!
|
||||
@mode = :pathfinding
|
||||
return
|
||||
end
|
||||
@path = replan(target)
|
||||
end
|
||||
|
||||
@direction = next_movement
|
||||
status = next_output!
|
||||
case status
|
||||
when 0
|
||||
set_content!(@direction, :wall)
|
||||
# no movement
|
||||
when 1
|
||||
set_content!(@direction, :open)
|
||||
move!(@direction)
|
||||
when 2
|
||||
set_content!(@direction, :oxygen)
|
||||
move!(@direction)
|
||||
else
|
||||
raise StandardError, "unknown status: #{status}"
|
||||
end
|
||||
end
|
||||
|
||||
def next_movement
|
||||
@path.shift if @position == @path[0]
|
||||
target = @path[0]
|
||||
@position.direction_to(target)
|
||||
end
|
||||
|
||||
def blocked?(path)
|
||||
path.any? do |cell|
|
||||
@map.get(cell) == :wall
|
||||
end
|
||||
end
|
||||
|
||||
def closest_unexplored_cell
|
||||
path = bfs(
|
||||
@position,
|
||||
->(cell) { cell.neighbors.reject { |c| @map.get(c) == :wall } },
|
||||
->(cell) { @map.get(cell).nil? },
|
||||
)
|
||||
path.nil? ? nil : path[-1]
|
||||
end
|
||||
|
||||
def replan(goal)
|
||||
search(@position, goal)
|
||||
end
|
||||
|
||||
def search(start, goal)
|
||||
bfs(
|
||||
start,
|
||||
->(cell) { cell.neighbors.reject { |c| @map.get(c) == :wall } },
|
||||
->(cell) { cell == goal },
|
||||
)
|
||||
end
|
||||
|
||||
def move!(direction)
|
||||
@position = @position.send(direction)
|
||||
@path.shift if @position == @path[0]
|
||||
end
|
||||
|
||||
def next_output!
|
||||
out = nil
|
||||
out = @computer.tick until out
|
||||
out
|
||||
end
|
||||
|
||||
def set_content!(direction, content)
|
||||
neighbor = @position.send(direction)
|
||||
@map.set_content!(neighbor, content)
|
||||
end
|
||||
|
||||
def print_state!
|
||||
system 'clear'
|
||||
puts @map.printable(@position)
|
||||
end
|
||||
end
|
||||
|
||||
def bfs(start, get_neighbors, is_goal)
|
||||
queue = [[start]]
|
||||
visited = Set.new
|
||||
until queue.empty?
|
||||
path = queue.shift
|
||||
state = path[-1]
|
||||
next if visited.include? state
|
||||
|
||||
visited << state
|
||||
return path if is_goal.call(state)
|
||||
|
||||
children = get_neighbors.call(state).reject { |cell| visited.include? cell }
|
||||
children.each do |child|
|
||||
queue << path + [child]
|
||||
end
|
||||
end
|
||||
nil
|
||||
end
|
||||
|
||||
program = Intcode.read(File.join(__dir__, 'input'))
|
||||
map = Map.new
|
||||
droid = Droid.new(program, map)
|
||||
path = droid.run
|
||||
puts path.length - 1
|
||||
Loading…
Reference in a new issue