1
0
www.mikescher.com/www/statics/aoc/2019/15_solution-1.ts

665 lines
15 KiB
TypeScript

namespace AdventOfCode2019_15_1
{
const DAY = 15;
const PROBLEM = 1;
export async function run()
{
let input = await AdventOfCode.getInput(DAY);
if (input == null) return;
const code = input.trim().split(",").map(p => parseInt(p.trim()));
let wm = new WorldMap();
let rnr = new Interpreter(code, []);
let d = Direction.North;
await AdventOfCode.outputIntermed(wm.dump());
for(;;)
{
if (wm.isfree(move_pos(wm.position, turn_right(d))))
{
d = turn_right(d);
}
rnr.inputqueue.push(d);
rnr.autoRun();
if (rnr.is_halted) throw "halted";
if (rnr.output.length !== 1) throw "out";
let nx = wm.position[0];
let ny = wm.position[1];
if (d === Direction.North) ny--;
if (d === Direction.East) nx++;
if (d === Direction.South) ny++;
if (d === Direction.West) nx--;
if (rnr.output[0] === 0)
{
wm.set_wall(nx, ny);
d = turn_left(d);
}
else if (rnr.output[0] === 1)
{
wm.set_empty(nx, ny);
wm.position = [nx, ny];
}
else if (rnr.output[0] === 2)
{
wm.set_target(nx, ny);
wm.position = [nx, ny];
}
rnr.output = [];
await AdventOfCode.outputIntermed(wm.dump());
if (wm.unknowns.length === 0) break;
}
await AdventOfCode.outputIntermed(wm.dump());
const dist = await wm.calcDistance();
await AdventOfCode.outputIntermed(wm.dump3());
AdventOfCode.output(DAY, PROBLEM, dist.toString());
}
function turn_right(d: Direction): Direction
{
if (d === Direction.North) return Direction.East;
if (d === Direction.East) return Direction.South;
if (d === Direction.South) return Direction.West;
if (d === Direction.West) return Direction.North;
throw "d";
}
function turn_left(d: Direction): Direction
{
if (d === Direction.North) return Direction.West;
if (d === Direction.East) return Direction.North;
if (d === Direction.South) return Direction.East;
if (d === Direction.West) return Direction.South;
throw "d";
}
function move_pos(p: [number, number], d: Direction): [number, number]
{
let nx = p[0];
let ny = p[1];
if (d === Direction.North) ny--;
if (d === Direction.East) nx++;
if (d === Direction.South) ny++;476
if (d === Direction.West) nx--;
return [nx, ny];
}
enum Direction
{
North = 1,
South = 2,
West = 3,
East = 4,
}
enum Field
{
Unknown = 0,
Wall = 1,
Empty = 2,
POI = 3, // possible new way to go, but unknown
Target = 4,
Path = 5,
}
class WorldMap
{
world: { [_:number]: Field } = {};
unknowns: [number, number][] = [];
position: [number, number] = [0, 0];
minx: number = 0;
miny: number = 0;
maxx: number = 0;
maxy: number = 0;
target_pos: [number,number] = [NaN, NaN];
distance_map: { [_:number]: number } = {};
constructor()
{
this.set_empty(0, 0);
}
async calcDistance(): Promise<number>
{
this.position = [0,0];
let distance_map: { [_:number]: number } = {};
distance_map[0] = 0;
let updates: [number, number][] = [];
updates.unshift([-1,0]);
updates.unshift([+1,0]);
updates.unshift([0,+1]);
updates.unshift([0,-1]);
while(updates.length > 0)
{
const pos = updates.pop();
if (pos === undefined) throw "undef";
if (!this.isfree(pos)) continue;
const x = pos[0];
const y = pos[1];
const i = (y*10000000 + x);
const i_n = ((y-1)*10000000 + (x));
const i_e = ((y)*10000000 + (x+1));
const i_s = ((y+1)*10000000 + (x));
const i_w = ((y)*10000000 + (x-1));
const d_curr = (i in distance_map) ? distance_map[i] : Number.MAX_SAFE_INTEGER;
const d_n = (i_n in distance_map) ? distance_map[i_n] : Number.MAX_SAFE_INTEGER;
const d_e = (i_e in distance_map) ? distance_map[i_e] : Number.MAX_SAFE_INTEGER;
const d_s = (i_s in distance_map) ? distance_map[i_s] : Number.MAX_SAFE_INTEGER;
const d_w = (i_w in distance_map) ? distance_map[i_w] : Number.MAX_SAFE_INTEGER;
let d_new = Math.min(d_n, d_e, d_s, d_w);
if (d_new !== Number.MAX_SAFE_INTEGER) d_new++;
await AdventOfCode.outputIntermed(this.dump2(distance_map, updates));
if (d_curr <= d_new) continue;
distance_map[i] = d_new;
updates.unshift([x+1, y]);
updates.unshift([x-1, y]);
updates.unshift([x, y+1]);
updates.unshift([x, y-1]);
}
await AdventOfCode.outputIntermed(this.dump2(distance_map, updates));
let tpos = this.target_pos;
for(;;)
{
const x = tpos[0];
const y = tpos[1];
const i = (y*10000000 + x);
const d = distance_map[i];
const i_n = ((y-1)*10000000 + (x));
const i_e = ((y)*10000000 + (x+1));
const i_s = ((y+1)*10000000 + (x));
const i_w = ((y)*10000000 + (x-1));
const d_n = (i_n in distance_map) ? distance_map[i_n] : Number.MAX_SAFE_INTEGER;
const d_e = (i_e in distance_map) ? distance_map[i_e] : Number.MAX_SAFE_INTEGER;
const d_s = (i_s in distance_map) ? distance_map[i_s] : Number.MAX_SAFE_INTEGER;
const d_w = (i_w in distance_map) ? distance_map[i_w] : Number.MAX_SAFE_INTEGER;
if (d === 1) break;
if (d_n+1 === d)
{
tpos = [tpos[0], tpos[1]-1];
this.set(tpos[0], tpos[1], Field.Path);
}
else if (d_e+1 === d)
{
tpos = [tpos[0]+1, tpos[1]];
this.set(tpos[0], tpos[1], Field.Path);
}
else if (d_s+1 === d)
{
tpos = [tpos[0], tpos[1]+1];
this.set(tpos[0], tpos[1], Field.Path);
}
else if (d_w+1 === d)
{
tpos = [tpos[0]-1, tpos[1]];
this.set(tpos[0], tpos[1], Field.Path);
}
else throw "";
}
return distance_map[(this.target_pos[1]*10000000 + this.target_pos[0])];
}
dump2(distance_map: { [_:number]: number }, updates: [number, number][]): string
{
let str = "";
for(let yy=this.miny;yy<=this.maxy;yy++)
{
for(let xx=this.minx;xx<=this.maxx;xx++)
{
const i = (yy*10000000 + xx);
if (this.get(xx, yy) === Field.Wall)
{
str += "#";
}
else if (updates.filter(u => u[0] === xx && u[1] === yy).length > 0)
{
str += "@";
}
else if (i in distance_map)
{
str += "+";
}
else
{
str += ".";
}
}
str += "\n";
}
return str;
}
isfree(p: [number, number]): boolean
{
const f = this.get(p[0], p[1]);
return (f !== Field.Wall) && (f !== Field.Unknown);
}
get(x: number, y: number): Field
{
const i = (y*10000000 + x);
if (!(i in this.world)) return Field.Unknown;
return this.world[i];
}
set(x: number, y: number, f: Field)
{
const i = (y*10000000 + x);
if (this.world[i] === Field.POI) this.unknowns = this.unknowns.filter(p => p[0] !== x || p[1] !== y);
this.world[i] = f;
if (f === Field.POI) this.unknowns.push([x, y]);
if (f === Field.Target) this.target_pos = [x, y];
this.minx = Math.min(this.minx, x);
this.maxx = Math.max(this.maxx, x);
this.miny = Math.min(this.miny, y);
this.maxy = Math.max(this.maxy, y);
}
set_empty(x: number, y: number)
{
this.set(x, y, Field.Empty);
if (this.get(x-1, y) === Field.Unknown) this.set(x-1, y, Field.POI);
if (this.get(x+1, y) === Field.Unknown) this.set(x+1, y, Field.POI);
if (this.get(x, y-1) === Field.Unknown) this.set(x, y-1, Field.POI);
if (this.get(x, y+1) === Field.Unknown) this.set(x, y+1, Field.POI);
}
set_target(x: number, y: number)
{
this.set(x, y, Field.Target);
if (this.get(x-1, y) === Field.Unknown) this.set(x-1, y, Field.POI);
if (this.get(x+1, y) === Field.Unknown) this.set(x+1, y, Field.POI);
if (this.get(x, y-1) === Field.Unknown) this.set(x, y-1, Field.POI);
if (this.get(x, y+1) === Field.Unknown) this.set(x, y+1, Field.POI);
}
set_wall(x: number, y: number)
{
this.set(x, y, Field.Wall);
}
dump(): string
{
let str = "";
for(let yy=this.miny;yy<=this.maxy;yy++)
{
for(let xx=this.minx;xx<=this.maxx;xx++)
{
if (xx === this.position[0] && yy === this.position[1])
{
str += "X";
}
else if (xx === 0 && yy === 0)
{
str += "0";
}
else
{
switch(this.get(xx, yy))
{
case Field.Empty: str += "."; break;
case Field.POI: str += "?"; break;
case Field.Target: str += "@"; break;
case Field.Unknown: str += " "; break;
case Field.Wall: str += "#"; break;
case Field.Path: str += "="; break;
}
}
}
str += "\n";
}
return str;
}
dump3(): string
{
let str = "";
for(let yy=this.miny;yy<=this.maxy;yy++)
{
for(let xx=this.minx;xx<=this.maxx;xx++)
{
if (xx === 0 && yy === 0)
{
str += "X";
}
else
{
switch(this.get(xx, yy))
{
case Field.Empty: str += " "; break;
case Field.POI: str += " "; break;
case Field.Target: str += "@"; break;
case Field.Unknown: str += " "; break;
case Field.Wall: str += "#"; break;
case Field.Path: str += "."; break;
}
}
}
str += "\n";
}
return str;
}
}
class Interpreter
{
program: InfMem;
inputqueue: number[];
instructionpointer: number;
output: number[];
relative_base: number;
is_halted: boolean = false;
constructor(prog: number[], input: number[])
{
this.program = new InfMem(prog);
this.inputqueue = input;
this.instructionpointer = 0;
this.output = [];
this.relative_base = 0;
}
fullRun() : number[]
{
while(!this.is_halted)
{
const r = this.singleStep();
if (r === StepResult.EXECUTED) continue;
if (r === StepResult.HALTED) return this.output;
if (r === StepResult.WAITING_FOR_IN) throw "not enough input";
throw "unknown output of singleStep";
}
return this.output;
}
autoRun() : StepResult
{
while(!this.is_halted)
{
const r = this.singleStep();
if (r === StepResult.EXECUTED) continue;
if (r === StepResult.HALTED) return StepResult.HALTED;
if (r === StepResult.WAITING_FOR_IN) return StepResult.WAITING_FOR_IN;
throw "unknown output of singleStep";
}
return StepResult.HALTED;
}
singleStep() : StepResult
{
const cmd = new Op(this.program.r(this.instructionpointer));
if (cmd.opcode == OpCode.ADD)
{
const p0 = cmd.getParameter(this, 0);
const p1 = cmd.getParameter(this, 1);
const pv = p0 + p1;
cmd.setParameter(this, 2, pv);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.MUL)
{
const p0 = cmd.getParameter(this, 0);
const p1 = cmd.getParameter(this, 1);
const pv = p0 * p1;
cmd.setParameter(this, 2, pv);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.HALT)
{
this.is_halted = true;
return StepResult.HALTED;
}
else if (cmd.opcode == OpCode.IN)
{
if (this.inputqueue.length == 0) return StepResult.WAITING_FOR_IN;
const pv = this.inputqueue[0];
cmd.setParameter(this, 0, pv);
this.inputqueue = this.inputqueue.slice(1);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.OUT)
{
const p0 = cmd.getParameter(this, 0);
this.output.push(p0);
//AdventOfCode.outputConsole("# " + p0);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.TJMP)
{
const p0 = cmd.getParameter(this, 0);
if (p0 != 0) this.instructionpointer = cmd.getParameter(this, 1);
else this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.FJMP)
{
const p0 = cmd.getParameter(this, 0);
if (p0 == 0) this.instructionpointer = cmd.getParameter(this, 1);
else this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.LT)
{
const p0 = cmd.getParameter(this, 0);
const p1 = cmd.getParameter(this, 1);
const pv = p0 < p1 ? 1 : 0;
cmd.setParameter(this, 2, pv);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.EQ)
{
const p0 = cmd.getParameter(this, 0);
const p1 = cmd.getParameter(this, 1);
const pv = p0 == p1 ? 1 : 0;
cmd.setParameter(this, 2, pv);
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else if (cmd.opcode == OpCode.ARB)
{
const p0 = cmd.getParameter(this, 0);
this.relative_base = this.relative_base+p0;
this.incInstrPtr(cmd);
return StepResult.EXECUTED;
}
else throw "Unknown Op: " + cmd.opcode + " @ " + this.instructionpointer;
}
private incInstrPtr(cmd: Op)
{
this.instructionpointer += 1 + cmd.parametercount;
}
}
enum StepResult { EXECUTED, HALTED, WAITING_FOR_IN }
enum OpCode
{
ADD = 1,
MUL = 2,
IN = 3,
OUT = 4,
TJMP = 5,
FJMP = 6,
LT = 7,
EQ = 8,
ARB = 9,
HALT = 99,
}
enum ParamMode
{
POSITION_MODE = 0,
IMMEDIATE_MODE = 1,
RELATIVE_MODE = 2,
}
class Op
{
opcode: OpCode;
modes: ParamMode[];
name: string;
parametercount: number;
constructor(v: number)
{
this.opcode = v%100;
v = Math.floor(v/100);
this.modes = [];
for(let i=0; i<4; i++)
{
this.modes.push(v%10);
v = Math.floor(v/10);
}
if (this.opcode == OpCode.ADD) { this.name="ADD"; this.parametercount=3; }
else if (this.opcode == OpCode.MUL) { this.name="MUL"; this.parametercount=3; }
else if (this.opcode == OpCode.HALT) { this.name="HALT"; this.parametercount=0; }
else if (this.opcode == OpCode.IN) { this.name="IN"; this.parametercount=1; }
else if (this.opcode == OpCode.OUT) { this.name="OUT"; this.parametercount=1; }
else if (this.opcode == OpCode.TJMP) { this.name="TJMP"; this.parametercount=2; }
else if (this.opcode == OpCode.FJMP) { this.name="FJMP"; this.parametercount=2; }
else if (this.opcode == OpCode.LT) { this.name="LT"; this.parametercount=3; }
else if (this.opcode == OpCode.EQ) { this.name="EQ"; this.parametercount=3; }
else if (this.opcode == OpCode.ARB) { this.name="ARB"; this.parametercount=1; }
else throw "Unknown opcode: "+this.opcode;
}
getParameter(proc: Interpreter, index: number): number
{
const prog = proc.program;
const ip = proc.instructionpointer;
let p = prog.r(ip+1+index);
if (this.modes[index] == ParamMode.POSITION_MODE) p = prog.r(p);
else if (this.modes[index] == ParamMode.IMMEDIATE_MODE) p = p;
else if (this.modes[index] == ParamMode.RELATIVE_MODE) p = prog.r(proc.relative_base+p);
else throw "Unknown ParamMode: "+this.modes[index];
return p;
}
setParameter(proc: Interpreter, index: number, value: number): void
{
const prog = proc.program;
const ip = proc.instructionpointer;
let p = prog.r(ip+1+index);
if (this.modes[index] == ParamMode.POSITION_MODE) prog.w(p, value);
else if (this.modes[index] == ParamMode.IMMEDIATE_MODE) throw "Immediate mode not allowed in write";
else if (this.modes[index] == ParamMode.RELATIVE_MODE) prog.w(proc.relative_base+p, value);
else throw "Unknown ParamMode: "+this.modes[index];
}
}
class InfMem
{
private data: { [_:number]:number } = {};
constructor(v: number[])
{
for(let i=0; i<v.length;i++) this.data[i]=v[i];
}
r(pos: number): number
{
if (!(pos in this.data)) this.data[pos] = 0;
return this.data[pos];
}
w(pos: number, val: number): number
{
return this.data[pos] = val;
}
}
}