Day 7

Author: ansf

Makefile

@@ -27,3 +27,8 @@ day6:
 	npx ts-node day6.ts
 day6-2:
 	npx ts-node day6-2.ts
+
+day7:
+	npx ts-node day7.ts
+day7-2:
+	npx ts-node day7-2.ts

day7.ts

@@ -1,94 +1,139 @@
-import * as fs from "fs" 
+import * as fs from "fs"
 
-const input = [5]
+function load(program: string) {
+	return fs.readFileSync(program, "utf8")
+		.split(",")
+		.map(l => parseInt(l))
+}
+
+const program = load("input-day7.txt")
+
+//const program = [3, 15, 3, 16, 1002, 16, 10, 16, 1, 16, 15, 15, 4, 15, 99, 0, 0]
+
+function thruster(input: number[]): number {
+	const out = compute(program, input)
+	return out[out.length - 1]
+}
+function thrusterChain(phases: number[]): number {
+	const p = phases.slice()
+	let out = thruster([p.shift(), 0])
+	while (p.length) {
+		out = thruster([p.shift(), out])
+	}
+	return out
+}
 
-const mem = fs.readFileSync("input-day5.txt", "utf8")
-	.split(",")
-	.map(l => parseInt(l))
+const phases = [0, 1, 2, 3, 4]
+const allPhases = permutate(phases)
+const maxThrust = allPhases.reduce((acc, v) => {
+	return Math.max(acc, thrusterChain(v))
+}, 0)
+console.log(maxThrust)
 
-let iptr = 0
+function permutate(a: number[]): number[][] {
+	if (a.length == 1) {
+		return [a]
+	}
+	return Array(a.length).fill(0)
+		.map((_, i) => {
+			const c = a.slice()
+			return [c.splice(i, 1)[0], c] as const
+		})
+		.reduce((acc, [prefix, rest]) => {
+			permutate(rest)
+				.map(p => [prefix, ...p])
+				.forEach(p => acc.push(p))
+			return acc
+		}, [])
+}
 
-while(true) {
-	const code = mem[iptr]
-	const op = code % 100
-	const modes = [code % 1000 / 100, code % 10000 / 1000, code % 100000 / 10000].map(Math.floor)
+function compute(p: number[], input: number[]): number[] {
+	const mem = p.slice()
+	const outputs = []
+	let iptr = 0
+	while (true) {
+		const code = mem[iptr]
+		const op = code % 100
+		const modes = [code % 1000 / 100, code % 10000 / 1000, code % 100000 / 10000].map(Math.floor)
 
-	switch(op) {
-		case 1:	
-			iptr = add(iptr, mem, modes)
-		break
-		case 2:	
-			iptr = mul(iptr, mem, modes)
-		break
-		case 3:
-			iptr = get(iptr, mem, modes)
-		break
-		case 4:
-			iptr = put(iptr, mem, modes)
-		break
-		case 5:
-			iptr = jnz(iptr, mem, modes)
-		break
-		case 6:
-			iptr = jz(iptr, mem, modes)
-		break
-		case 7:
-			iptr = lt(iptr, mem, modes)
-		break
-		case 8:
-			iptr = eq(iptr, mem, modes)
-		break
-		case 99:
-			process.exit(0)
-		break
-		default: throw new Error(`unknown instruction ${mem[iptr]}`)
+		switch (op) {
+			case 1:
+				iptr = add(iptr, mem, modes)
+				break
+			case 2:
+				iptr = mul(iptr, mem, modes)
+				break
+			case 3:
+				iptr = get(iptr, mem, modes, input)
+				break
+			case 4:
+				const [newIptr, output] = put(iptr, mem, modes)
+				iptr = newIptr
+				//outputs.push(output)
+				return [output]
+				break
+			case 5:
+				iptr = jnz(iptr, mem, modes)
+				break
+			case 6:
+				iptr = jz(iptr, mem, modes)
+				break
+			case 7:
+				iptr = lt(iptr, mem, modes)
+				break
+			case 8:
+				iptr = eq(iptr, mem, modes)
+				break
+			case 99:
+				return outputs
+			default: throw new Error(`unknown instruction ${mem[iptr]}`)
+		}
 	}
 }
 
-function v(ptr: number, mode: number) {
-	if(mode === 0) {
+function v(mem: number[], ptr: number, mode: number) {
+	if (mode === 0) {
 		return mem[mem[ptr]]
-	} else if(mode === 1) {
+	} else if (mode === 1) {
 		return mem[ptr]
 	}
 	throw new Error(`unknown mode ${mode}`)
 }
 
 function add(iptr: number, mem: number[], modes: number[]) {
-	mem[mem[iptr+3]] = v(iptr+1, modes[0]) + v(iptr+2, modes[1])
+	mem[mem[iptr + 3]] = v(mem, iptr + 1, modes[0]) + v(mem, iptr + 2, modes[1])
 	return iptr + 4
 }
 function mul(iptr: number, mem: number[], modes: number[]) {
-	mem[mem[iptr+3]] = v(iptr+1, modes[0]) * v(iptr+2, modes[1])
+	mem[mem[iptr + 3]] = v(mem, iptr + 1, modes[0]) * v(mem, iptr + 2, modes[1])
 	return iptr + 4
 }
 function put(iptr: number, mem: number[], modes: number[]) {
-	console.log(v(iptr+1, modes[0]))
-	return iptr + 2
+	return [iptr + 2, v(mem, iptr + 1, modes[0])]
 }
-function get(iptr: number, mem: number[], modes: number[]) {
-	mem[mem[iptr+1]] = input.shift()
+function get(iptr: number, mem: number[], modes: number[], input: number[]) {
+	mem[mem[iptr + 1]] = input.shift()
 	return iptr + 2
 }
 function jnz(iptr: number, mem: number[], modes: number[]) {
-	if(v(iptr+1, modes[0]) !== 0) {
-		return v(iptr+2, modes[1])
+	if (v(mem, iptr + 1, modes[0]) !== 0) {
+		return v(mem, iptr + 2, modes[1])
 	}
 	return iptr + 3
 }
 function jz(iptr: number, mem: number[], modes: number[]) {
-	if(v(iptr+1, modes[0]) === 0) {
-		return v(iptr+2, modes[1])
+	if (v(mem, iptr + 1, modes[0]) === 0) {
+		return v(mem, iptr + 2, modes[1])
 	}
 	return iptr + 3
 }
 function lt(iptr: number, mem: number[], modes: number[]) {
-	const val = (v(iptr+1, modes[0]) < v(iptr+2, modes[1])) ? 1 : 0
-	mem[mem[iptr+3]] = val
+	const val = (v(mem, iptr + 1, modes[0]) < v(mem, iptr + 2, modes[1])) ? 1 : 0
+	mem[mem[iptr + 3]] = val
 	return iptr + 4
 }
 function eq(iptr: number, mem: number[], modes: number[]) {
-	const val = (v(iptr+1, modes[0]) === v(iptr+2, modes[1])) ? 1 : 0
-	mem[mem[iptr+3]] = val
+	const val = (v(mem, iptr + 1, modes[0]) === v(mem, iptr + 2, modes[1])) ? 1 : 0
+	mem[mem[iptr + 3]] = val
 	return iptr + 4
 }