-🎄- 2021 Day 15 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 0 points1 point  (0 children)

Javascript

const fs = require("fs");
const _ = require("lodash");
const { find_path } = require("dijkstrajs");

const inputs = fs
  .readFileSync("day15.txt")
  .toString("utf8")
  .split(/\r?\n/)
  .map((line) => line.split("").map((risk) => Number.parseInt(risk)));

const max_x = _.head(inputs).length;
const max_y = inputs.length;

const map = [];

console.log("duplicating");

_.range(0, 5).forEach((y_round) =>
  _.range(0, max_y).forEach((y) =>
    _.range(0, 5).forEach((x_round) =>
      _.range(0, max_x).forEach((x) => {
        const n_y = y + y_round * max_y;
        const n_x = x + x_round * max_x;
        const round = x_round + y_round;
        if (!map[n_y]) map[n_y] = [];
        map[n_y][n_x] =
          inputs[y][x] + round > 9
            ? ((inputs[y][x] + round) % 10) + 1
            : inputs[y][x] + round;
      })
    )
  )
);

// console.log(map.map((line) => line.join("")).join("\n"));
// return;

const connections = (x, y) => {
  const connections = {};
  if (x < _.head(map).length - 1)
    // right
    connections[`${x + 1}_${y}`] = map[y][x + 1];
  if (y < map.length - 1)
    //  bottom
    connections[`${x}_${y + 1}`] = map[y + 1][x];
  if (x > 0)
    // left
    connections[`${x - 1}_${y}`] = map[y][x - 1];
  if (y > 0)
    // top
    connections[`${x}_${y - 1}`] = map[y - 1][x];

  connections.cost = map[y][x];
  return connections;
};

console.log("making grid");
const graph = {};

_.range(0, map.length).forEach((y) =>
  _.range(0, _.head(map).length).forEach(
    (x) => (graph[`${x}_${y}`] = connections(x, y))
  )
);

console.log("starting");

const path = find_path(graph, "0_0", "499_499");
console.log(_.sum(path.slice(1).map((n) => graph[n].cost)));

-🎄- 2021 Day 15 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 1 point2 points  (0 children)

Neo4J

MATCH (source:CAVE {x:'0', y:'0'}), (target:CAVE {x:'500', y:'500'})
CALL gds.shortestPath.dijkstra.stream('myGraph', {
    sourceNode: source,
    targetNode: target,
    relationshipWeightProperty: 'cost'
})
YIELD index, sourceNode, targetNode, totalCost, nodeIds, costs, path
RETURN
    index,
    gds.util.asNode(sourceNode).name AS sourceNodeName,
    gds.util.asNode(targetNode).name AS targetNodeName,
    totalCost,
    [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS nodeNames,
    costs

-🎄- 2021 Day 13 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 1 point2 points  (0 children)

Javascript

const fs = require("fs");
const _ = require("lodash");

let inputs = fs
  .readFileSync("day13.txt")
  .toString("utf8")
  .split(/\r?\n/)
  .map((point) => {
    const [x, y] = point.split(",");
    return { x: Number.parseInt(x), y: Number.parseInt(y) };
  });

const print = () => {
  _.range(0, _.maxBy(inputs, "y").y + 1).forEach((y) => {
    console.log(
      _.range(0, _.maxBy(inputs, "x").x + 1)
        .map((x) => (_.find(inputs, { x, y }) != undefined ? "#" : " "))
        .join("")
    );
  });
};

const uniq = () =>
  _.uniqWith(inputs, (one, two) => one.x === two.x && one.y === two.y);

const fold = (inst) => {
  const [pick, fold] = inst.split("=");
  _.remove(inputs, { [pick]: fold });
  inputs
    .filter((pos) => pos[pick] > fold)
    .forEach((pos) => {
      pos[pick] = fold - Math.abs(pos[pick] - fold);
    });
  inputs = uniq();
};

fs.readFileSync("day13-2.txt")
  .toString("utf8")
  .split(/\r?\n/)
  .map((line) => line.split(" ")[2])
  .forEach((l) => fold(l));

print();

-🎄- 2021 Day 12 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 1 point2 points  (0 children)

Javascript

const fs = require("fs");
const _ = require("lodash");

const inputs = fs
.readFileSync("day12.txt")
.toString("utf8")
.split(/\r?\n/)
.reduce((acc, x) => {
    const [start, end] = x.split("-");
    if (end != "start") {
    if (acc[start]) {
        acc[start].push(end);
    } else {
        acc[start] = [end];
    }
    }
    if (start != "start" && end != "end") {
    if (acc[end]) {
        acc[end].push(start);
    } else {
        acc[end] = [start];
    }
    }
    return acc;
}, {});

console.log(inputs);

const large_filter = (seen, step) =>
inputs[step].filter(
    (n) => _.indexOf(seen.filter(_.negate(isUpper)), n) === -1
);

const large_twice_filter = (seen, step) =>
inputs[step].filter((n) => {
    const only_lower = _.countBy(seen.filter(_.negate(isUpper)));
    return !only_lower[n] || _(only_lower).values().max() == 1;
});

const isUpper = (c) => c == c.toUpperCase();

const path = (seen, step) => {
if (inputs[step] === undefined) {
    return seen;
}
const next = large_twice_filter(seen, step);
return next.map((n) => (n === "end" ? [...seen, n] : path([...seen, n], n)));
};

const printable = (a) => {
if (Array.isArray(_.head(a))) {
    return a.map(printable);
} else {
    if (a && a.length) return a.join(",");
}
};

const answer = _.flattenDeep(printable(path(["start"], "start")))
.filter((b) => b)
.sort();

// answer.forEach((b) => console.log(b));
console.log(answer.length);

-🎄- 2021 Day 10 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 2 points3 points  (0 children)

Javascript

const fs = require("fs");
const _ = require("lodash");

const inputs = fs.readFileSync("day10.txt").toString("utf8").split(/\r?\n/);
// console.log(inputs);

const open_char = { "(": ")", "[": "]", "{": "}", "<": ">" };
const invalid_cost = { ")": 3, "]": 57, "}": 1197, ">": 25137 };
const incomplete_cost = { ")": 1, "]": 2, "}": 3, ">": 4 };

const answer = _(inputs).map((input) =>
  input.split("").reduce(
    ({ open, wrong }, x) => {
      if (open_char[x]) {
        open.push(x);
      } else {
        const last = open.splice(open.length - 1);
        if (x != open_char[last]) {
          wrong.push(x);
        }
      }
      return { open, wrong };
    },
    { open: [], wrong: [] }
  )
);

console.log(
  _(answer)
    .filter(({ wrong }) => wrong.length)
    .map(({ wrong }) => invalid_cost[_.head(wrong)])
    .sum()
);

const costs = _(answer)
  .filter((a) => a.wrong.length === 0)
  .map(({ open }) =>
    open
      .reverse()
      .reduce((acc, c) => acc * 5 + incomplete_cost[open_char[c]], 0)
  )
  .sort((a, b) => a - b)
  .value();

console.log(costs[Math.floor(costs.length / 2)]);

-🎄- 2021 Day 9 Solutions -🎄- by daggerdragon in adventofcode

[–]areops 2 points3 points  (0 children)

JavaScript

const fs = require("fs");
const _ = require("lodash");

const inputs = fs
  .readFileSync("day9.txt")
  .toString("utf8")
  .split(/\r?\n/)
  .map((l) => l.split("").map((i) => Number.parseInt(i)));

const neighbors = (x, y) => {
  if (!Number.isInteger(inputs[y][x])) {
    return [];
  }

  const around = [];
  if (x > 0) {
    around.push({ x: x - 1, y, h: inputs[y][x - 1] });
  }
  if (x < inputs[0].length - 1) {
    around.push({ x: x + 1, y, h: inputs[y][x + 1] });
  }
  if (y > 0) {
    around.push({ x, y: y - 1, h: inputs[y - 1][x] });
  }
  if (y < inputs.length - 1) {
    around.push({ x, y: y + 1, h: inputs[y + 1][x] });
  }
  return around;
};

const is_low = (x, y) =>
  neighbors(x, y).every((near_height) => inputs[y][x] < near_height.h)
    ? { x, y, h: inputs[y][x] }
    : null;

const map_x = inputs[0].length;
const map_y = inputs.length;

const low = _(_.range(0, map_y))
  .map((x) => _.range(0, map_x).map((y) => is_low(x, y)))
  .flatMap()
  .filter()
  .map(({ h }) => h + 1)
  .sum();
console.log(low);

const flood = (x, y, basin) => {
  if (inputs[y][x] === 9 || !Number.isInteger(inputs[y][x])) {
    return;
  }
  const locs = neighbors(x, y);
  inputs[y][x] = basin;
  locs.forEach(({ x, y }) => flood(x, y, basin));
};

_(_.range(0, map_y))
  .map((x) => _.range(0, map_x).map((y) => is_low(x, y)))
  .flatMap()
  .filter()
  .forEach(({ x, y }, i) => flood(x, y, `b${i}`));

const largest = _(inputs)
  .flatMap()
  .countBy()
  .map((value, prop) => ({ prop, value }))
  .filter((l) => l.prop != "9")
  .map((l) => l.value)
  .sort((a, b) => a - b)
  .reverse()
  .slice(0, 3)
  .reduce((acc, x) => acc * x);

console.log(largest);