Day 16: Proboscidea Volcanium / Visnu Pitiyanuvath

Visnu Pitiyanuvath

Workspace

Public

Advent of Code 2022

Edited

Dec 19, 2022

1 fork

1 star

function distance(start) {

const distances = new Map([[start, 0]]);

const queue = [start];

while (queue.length) {

const valve = queue.shift();

for (const n of valves[valve].leads) {

if (!distances.has(n)) {

queue.push(n);

distances.set(n, distances.get(valve) + 1);

}

return distances;

}

releasing = Object.values(valves)

.filter((d) => d.rate)

.map((d) => d.valve)

function* simulate(order) {

let cave = "AA";

let t = 1;

let rate = 0;

let released = 0;

yield { cave, t, rate, released };

for (const valve of order) {

const d = distance(cave);

const dt = d.get(valve) + 1;

cave = valve;

t += dt;

released += rate * dt;

if (t >= 30) break;

rate += valves[cave].rate;

yield { cave, t, rate, released };

}

if (t <= 30) released += rate * (31 - t);

yield { cave, t: 30, rate, released };

}

// Inputs.table([...simulate(["DD", "BB", "JJ", "HH", "EE", "CC"])], { width: 300 })

Inputs.table([...simulate(releasing)], { width: 300 })

released = (order) => d3.reduce(simulate(order), (s, d) => d).released

// // https://stackoverflow.com/a/37580979

// function* permute(a, depth = 2, r = []) {

// if (r.length === depth) yield r;

// for (let i = 0; i < a.length; i++) {

// const aa = a.slice();

// const rr = [...r, ...aa.splice(i, 1)];

// yield* permute(aa, depth, rr);

// }

// // https://stackoverflow.com/a/37580979

// function* permute(permutation) {

// var length = permutation.length,

// c = Array(length).fill(0),

// i = 1, k, p;

// yield permutation.slice();

// while (i < length) {

// if (c[i] < i) {

// k = i % 2 && c[i];

// p = permutation[i];

// permutation[i] = permutation[k];

// permutation[k] = p;

// ++c[i];

// i = 1;

// yield permutation.slice();

// } else {

// c[i] = 0;

// ++i;

// }

function* permute(a, depth) {

}

[...permute(releasing, releasing.length)]

releasing

function* combine(a, count, r = []) {

if (count) {

count = count - 1;

for (let i = 0; i < a.length - count; i++) {

const aa = a.slice(i);

const rr = [...r, ...aa.splice(0, 1)];

yield* combine(aa, count, rr);

}

} else {

yield r;

}

function* exhaustive(depth) {

let max = 0, best;

let n = 0;

for (const p of permute(releasing, depth)) {

const r = released(p);

if (n++ % 1000 === 0 || true) yield { p, r, max, n }

if (r > max) {

max = r;

best = p;

}

yield { best, max, p: best, r: max, n };

}

// exhaustive(2)

// Plot.plot({

// marks: [

// Plot.tickX(exhaustive(1), {

// x: "r",

// y: (d) => String(d.p.slice(0, 2)),

// sort: { y: "x", reduce: "max" }

// })

// ]

// })

Inputs.table(distance("AA"), { width: 200 })

futurePressure = (start, remaining = 30) =>

d3.map(distance(start).entries(), ([valve, distance]) => [

valve,

(remaining - distance - 1) * valves[valve].rate

])

Inputs.table(

d3.filter(futurePressure("AA"), ([, v]) => v > 0),

{ width: 200, sort: "1" }

)

Inputs.table(futurePressure("DD", 28), { width: 200, sort: "1" })

Purpose-built for displays of data

Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.

Learn more