132 lines
3.6 KiB
Nix
132 lines
3.6 KiB
Nix
{lib, ...}: input: rec {
|
|
|
|
content = lib.trim input;
|
|
|
|
chart = toChart content;
|
|
|
|
toChart = s: s
|
|
|> lib.strings.splitString "\n"
|
|
|> map (lib.stringToCharacters)
|
|
;
|
|
|
|
startingPos = let
|
|
xs = map (lib.lists.findFirstIndex (char: char == "^") null) chart;
|
|
y = lib.lists.findFirstIndex (x: !isNull x) null xs;
|
|
x = builtins.elemAt xs y;
|
|
in
|
|
{inherit x y;}
|
|
;
|
|
|
|
posToString = {x, y}: "${toString x},${toString y}";
|
|
|
|
addVec = a: b: {x = a.x + b.x; y = a.y + b.y;};
|
|
|
|
index = i: list: builtins.elemAt list i;
|
|
|
|
getChar = {x, y}: chart: chart
|
|
|> index y
|
|
|> index x
|
|
;
|
|
|
|
height = builtins.length chart;
|
|
width = chart |> index 0 |> builtins.length;
|
|
|
|
replace2d = {x, y}: updated: chart: let
|
|
newRow = chart |> index y |> replace x updated;
|
|
in
|
|
replace y newRow chart;
|
|
|
|
replace = i: updated: list:
|
|
let before = lib.sublist 0 i list;
|
|
after = lib.sublist (i + 1) (builtins.length list - i) list;
|
|
in
|
|
if i < 0 || i > builtins.length list then list else
|
|
before ++ [updated] ++ after;
|
|
|
|
progress = {visited ? {}, pos, dir, obs ? [], charts ? chart, ...}: let
|
|
newDir = if colliding then rotate dir else dir;
|
|
newPos = addVec pos newDir;
|
|
colliding = nextChar == "#";
|
|
nextChar = getChar fwd charts;
|
|
fwd = addVec pos dir;
|
|
hash = posToString pos;
|
|
exited = fwd.y >= height || fwd.x >= width || fwd.y < 0 || fwd.x < 0;
|
|
canObstruct =
|
|
# unique
|
|
(!lib.elem (posToString fwd) obs)
|
|
# inside map
|
|
&& (!exited)
|
|
# can't put an obstacle when there already is one
|
|
&& (!colliding)
|
|
# if I already visited the place in front, putting an obstacle there won't work, as I can't get to where I am now!
|
|
&& (!lib.hasAttr (posToString fwd) visited)
|
|
# see if I will end up in a loop turning right here
|
|
&& getLoop {inherit pos visited dir; charts = replace2d fwd "#" charts;};
|
|
in
|
|
{
|
|
visited = visited // {${hash} = visited.${hash} or [] ++ [dir];};
|
|
pos = if colliding then pos else newPos;
|
|
dir = newDir;
|
|
inherit exited charts;
|
|
obs = obs ++ (if canObstruct then [(posToString fwd)] else []);
|
|
};
|
|
|
|
rotate = {x, y}: {x = -y; y = x;};
|
|
|
|
startingDir = {x = 0; y = -1;};
|
|
|
|
getVisits = {pos ? startingPos
|
|
, dir ? startingDir
|
|
, visited ? {}
|
|
, obs ? []
|
|
, charts ? chart
|
|
, ...}:
|
|
let
|
|
nextStep = progress {inherit pos dir visited obs charts;};
|
|
in if nextStep.exited then nextStep else getVisits nextStep;
|
|
|
|
path = getVisits {};
|
|
|
|
part1result = path.visited
|
|
|> builtins.attrNames
|
|
|> builtins.length
|
|
;
|
|
|
|
getLoop = state:
|
|
let
|
|
nextStep = progress state;
|
|
hash = posToString state.pos;
|
|
enteredLoop = lib.elem state.dir (state.visited.${hash} or []);
|
|
in if enteredLoop then true
|
|
else if nextStep.exited then false
|
|
else getLoop nextStep;
|
|
|
|
part2result = builtins.trace "This is very slow!" (path.obs |> builtins.length)
|
|
;
|
|
|
|
# visualisation stuff
|
|
|
|
hashToVec = s: s |> lib.splitString "," |> map lib.strings.toInt |> (v: {x = index 0 v; y = index 1 v;});
|
|
|
|
annotateObs = chart:
|
|
builtins.foldl'
|
|
(c: obs: let pos = hashToVec obs; in replace2d pos "O" c) chart path.obs;
|
|
|
|
annotatePath = chart:
|
|
builtins.foldl'
|
|
(c: hash: let
|
|
pos = hashToVec hash;
|
|
dir = index 0 path.visited.${hash};
|
|
sym = if dir.x == 1 then ">" else if dir.x == -1 then "<" else if dir.y == 1 then "v" else "^";
|
|
in replace2d pos sym c) chart
|
|
(builtins.attrNames path.visited);
|
|
|
|
chartToStr = c: c
|
|
|> map (lib.concatStringsSep "")
|
|
|> lib.concatStringsSep "\n"
|
|
;
|
|
|
|
annotated = chart |> annotatePath |> annotateObs |> chartToStr;
|
|
|
|
}
|