198 lines
5.4 KiB
Nix
198 lines
5.4 KiB
Nix
{lib, pkgs, ...}: input: rec {
|
|
inherit lib;
|
|
inherit (lib) splitString mod range;
|
|
inherit (lib.lists) findFirstIndex imap0;
|
|
inherit (lib.strings) stringToCharacters;
|
|
inherit (builtins) elemAt concatStringsSep length elem filter foldl' concatLists floor deepSeq listToAttrs attrValues attrNames mapAttrs hasAttr;
|
|
|
|
index = i: list: elemAt list i;
|
|
index2d = {x, y}: m: m |> index y |> index x;
|
|
|
|
init = let
|
|
chart = input |> splitString "\n" |> map stringToCharacters;
|
|
width = (elemAt chart 0 |> length) + 1;
|
|
height = length chart;
|
|
startIndex = input |> stringToCharacters |> findFirstIndex (char: char == "S") null;
|
|
endIndex = input |> stringToCharacters |> findFirstIndex (char: char == "E") null;
|
|
in {
|
|
inherit chart width height;
|
|
pos = {
|
|
x = mod startIndex width;
|
|
y = startIndex / width;
|
|
};
|
|
goal = {
|
|
x = mod endIndex width;
|
|
y = endIndex / width;
|
|
};
|
|
}
|
|
;
|
|
|
|
chartToStr = chart: chart |> (map (concatStringsSep "")) |> concatStringsSep "\n";
|
|
|
|
rotate' = {x, y}: {y = -x; x = y;};
|
|
rotate = {x, y}: {y = x; x = -y;};
|
|
|
|
addVec = a: b: {x = a.x or 0 + b.x or 0; y = a.y or 0 + b.y or 0;};
|
|
multVec = a: m: {x = a.x or 0 * m; y = a.y or 0 * m;};
|
|
|
|
|
|
dirs = {
|
|
north = {x = 0; y = -1;};
|
|
east = {x = 1; y = 0;};
|
|
south = {x = 0; y = 1;};
|
|
west = {x = -1; y = 0;};
|
|
};
|
|
|
|
search = {
|
|
pos,
|
|
dir,
|
|
score ? 0,
|
|
}: let
|
|
fwd = addVec pos dir;
|
|
in
|
|
if
|
|
index2d fwd init.chart == "#"
|
|
then null
|
|
else
|
|
if (isNode fwd || fwd == init.goal || fwd == init.pos)
|
|
then {
|
|
name = (key fwd);
|
|
value = score + 1;
|
|
}
|
|
else
|
|
search {pos = fwd; inherit dir; score = score + 1;}
|
|
;
|
|
|
|
isNode = pos: index2d pos init.chart == "." &&
|
|
(dirs
|
|
|> mapAttrs (name: dir: let n = addVec pos dir; in index2d n init.chart == ".")
|
|
|> ({north, east, south, west}:
|
|
north && east || east && south || south && west || west && north))
|
|
;
|
|
|
|
key = {x, y}: "${toString (y + 1)},${toString (x + 1)}";
|
|
|
|
nodes = range 1 (init.width - 3) |> map (x:
|
|
range 1 (init.height - 3) |> map (y: {inherit x y;})
|
|
)
|
|
|> concatLists
|
|
|> filter isNode
|
|
|> (nodes: nodes ++ [init.pos init.goal])
|
|
|> map (pos: {
|
|
name = key pos;
|
|
value = {
|
|
north = search {inherit pos; dir = dirs.north;};
|
|
east = search {inherit pos; dir = dirs.east;};
|
|
south = search {inherit pos; dir = dirs.south;};
|
|
west = search {inherit pos; dir = dirs.west;};
|
|
} |> lib.filterAttrs (n: v: !isNull v);
|
|
})
|
|
|> listToAttrs;
|
|
|
|
graph = pkgs.runCommand "graph" {} ''
|
|
mkdir -p $out
|
|
echo 'digraph {
|
|
${nodes |> mapAttrs (from: tos:
|
|
tos |> mapAttrs (dir: edge: if isNull edge then "" else ''
|
|
"${from}" -> "${edge.name}" [label="${dir} ${toString edge.value}"]
|
|
'') |> attrValues |> concatStringsSep "\n"
|
|
) |> attrValues |> concatStringsSep "\n"}
|
|
}' > $out/graph.dot
|
|
cat $out/graph.dot | ${pkgs.graphviz}/bin/dot -Tsvg > $out/graph.svg
|
|
'';
|
|
|
|
getPath = {
|
|
pos ? key init.pos
|
|
, goal
|
|
, dir ? "east"
|
|
, score ? 0
|
|
, hist ? []
|
|
, acc ? {}
|
|
}: let
|
|
node = nodes.${pos};
|
|
in attrNames node |> foldl' (best: edgedir:
|
|
lib.traceSeq acc
|
|
(let
|
|
newHist = hist ++ [edge.name value];
|
|
edge = node.${edgedir};
|
|
turnCost = if edgedir == dir then 0 else 1000;
|
|
value = edge.value + turnCost;
|
|
newScore = score + value;
|
|
in
|
|
if isNull edge || elem edge.name hist || (hasAttr "score" best && newScore > best.score) then best else
|
|
if edge.name == goal && (hasAttr "score" best -> newScore < best.score) then
|
|
({score = newScore;})
|
|
else
|
|
getPath {
|
|
pos = edge.name;
|
|
dir = edgedir;
|
|
score = newScore;
|
|
hist = newHist;
|
|
acc = best;
|
|
inherit goal;
|
|
}
|
|
)) acc;
|
|
|
|
initScores = {
|
|
scores = mapAttrs (n: v:
|
|
if n == key init.pos then {dir = "east"; score = 0; pos = n;}
|
|
else {dir = null; score = null; pos = n;}
|
|
) nodes;
|
|
done = [];
|
|
};
|
|
|
|
getScores = state: let
|
|
unvisited = removeAttrs state.scores state.done;
|
|
top = attrValues unvisited |> foldl' (acc: node:
|
|
if isNull acc.score then node else
|
|
if isNull node.score then acc else
|
|
if acc.score < node.score then acc else node
|
|
) {score = null;};
|
|
in
|
|
nodes.${top.pos}
|
|
|> mapAttrs (dir: {name, value}: let
|
|
turnCost = if top.dir == dir then 0 else 1000;
|
|
existing = state.scores.${name};
|
|
score = top.score + value + turnCost;
|
|
isBetter = isNull existing.score || existing.score > score;
|
|
in {
|
|
inherit name;
|
|
value = if elem name state.done || !isBetter then existing else {
|
|
inherit dir score;
|
|
pos = name;
|
|
};
|
|
})
|
|
|> attrValues
|
|
|> listToAttrs
|
|
|> (newScores: {
|
|
scores = state.scores // newScores;
|
|
done = state.done ++ [top.pos];
|
|
})
|
|
;
|
|
|
|
getPriority = {scores, done}: scores
|
|
|> lib.attrsToList
|
|
|> filter ({name, ...}: !elem name done)
|
|
|> filter ({value, ...}: !isNull value.score)
|
|
|> sortQueue
|
|
;
|
|
|
|
lessThan = a: b: isNull a || isNull b || a < b;
|
|
|
|
sortQueue = q: q
|
|
|> builtins.sort (a: b: lessThan a.value.score b.value.score)
|
|
# |> (q: lib.traceSeq (map (v: v.value.score) q) q)
|
|
|> map ({name, value}: {
|
|
pos = name;
|
|
inherit (value) dir score;
|
|
})
|
|
;
|
|
|
|
fastest = s: let
|
|
next = getScores s;
|
|
in if elem (key init.goal) next.done then next else fastest next;
|
|
|
|
part1result = (fastest initScores).scores.${key init.goal};
|
|
|
|
}
|