08/part2.pl

@@ -1,3 +1,5 @@
+:- table direction_loop/1.
+
 :- op(700, xfx, l).
 :- op(700, xfx, r).
 From l To :- From to To-_.
@@ -5,43 +7,58 @@ From r To :- From to _-To.
 
 answer(Answer) :-
     starts(Starts),
-    routes(Starts, [Route1 | RestOfRoutes]),
-    foldl(unify2, RestOfRoutes, Route1, Answer).
+    routes(Starts, Routes),
+    collapse_routes(Routes, _-(_-Answer-_)).
 
-% unify2 combines 2 routes into one with its own stride-offsets-dests
-unify2(Route1, Route2, NewRoute) :-
-    once(findnsols(2, S, converge(Route1, Route2, S), SolutionPair)),
-    SolutionPair = [NewA-LenA-NewZ, _-LenB-_],
-    NewStride is LenB - LenA,
-    NewRoute = NewA-(NewStride-LenA-[0-NewZ]).
+collapse_routes([X], X).
+collapse_routes(Routes, Collapsed) :-
+    writef('Collapsing: %t\n', [Routes]),
+    sort(2, @=<, Routes, [Route1, Route2 | CdrRoutes]),
+    unify2(Route1, Route2, 0-0-0-0, [], NewRoute),
+    collapse_routes([NewRoute | CdrRoutes], Collapsed).
 
-% Len = Stride1*X1 + Offset1 + Dest1 = Stride2*X2 + Offset2 + Dest2
-% For performance, Route1's Stride should =< Route2's Stride
-converge(Route1, Route2, NewA-Len-NewZ) :-
-    writef('Combining %t - %t\n', [Route1, Route2]),
-    Route1 = A1-(Stride1-Offset1-Dests1),
-    Route2 = A2-(Stride2-Offset2-Dests2),
-    natnum(X2),
-    pick([Dests1, Dests2], [Dest1-Z1, Dest2-Z2]),
-    0 is (Stride2*X2 + Offset2 + Dest2 - Offset1 - Dest1) mod Stride1,
-    Len is Stride2*X2 + Offset2 + Dest2,
-    atom_concat(A1, A2, NewA), atom_concat(Z1, Z2, NewZ).
+unify2(Route1, Route2, N1-Term1-N2-Term2, Founds, NewRoute) :-
+    Route1 = A1-(Stride1-Offset1-Loop1),
+    Route2 = A2-(Stride2-Offset2-Loop2),
+    nth0(Term1, Loop1, C1-_),
+    nth0(Term2, Loop2, C2-_),
+    Z1 is Offset1 + Stride1*N1 + C1,
+    Z2 is Offset2 + Stride2*N2 + C2,
+    next(Route1, N1-Term1, NextN1-NextTerm1),
+    (   Z1 =:= Z2
+    ->  (   Founds = [OldZ]
+        ->  atom_concat(A1, A2, NewA),
+            NewStride is Z1 - OldZ,
+            NewRoute = NewA-(NewStride-OldZ-[0-NewA]),
+            !
+        ;   unify2(Route1, Route2, NextN1-NextTerm1-N2-Term2, [Z1], NewRoute)
+        )
+    ;   Z1 < Z2
+    ->  unify2(Route1, Route2, NextN1-NextTerm1-N2-Term2, Founds, NewRoute)
+    ;   next(Route2, N2-Term2, NextN2-NextTerm2),
+        unify2(Route1, Route2, N1-Term1-NextN2-NextTerm2, Founds, NewRoute)
+    ).
+
+next(_-(_-_-Loop), NLoops-Term, NextNLoops-NextTerm) :-
+    length(Loop, LoopLen),
+    (   Term < LoopLen - 1
+    ->  NextNLoops is NLoops, NextTerm is Term + 1
+    ;   NextNLoops is NLoops + 1, NextTerm is 0).
 
 routes(Starts, Routes) :-
-    maplist([S, S-Route]>>(zloop(S, Route)), Starts, Routes).
+    maplist([S, S-Route]>>(zloop([], S, 0, [], Route)), Starts, Routes).
 
-% zloop builds a route (Stride-Offset-Internals) for a particular starting node.
-zloop(Node, Route) :- zloop([], Node, 0, [], Route).
-zloop(_Direction, _Node, _Index, Zs, Stride-Offset-Dests) :-
+zloop(_, _, _, Zs, Stride-Offset-Loop) :-
     Zs = [FirstZIndex-Z | _], reverse(Zs, [LastZIndex-Z | ReversedZs]),
     DeltaZ is LastZIndex - FirstZIndex, DeltaZ =\= 0,
     direction_len(Len),
     divmod(DeltaZ, Len, _, 0),
     Offset = FirstZIndex, Stride = DeltaZ,
     foldl([Idx-Z, NewIdx-Z, Off, Off]>>(NewIdx is Idx - Off),
-          ReversedZs, ReversedDests, Offset, _),
-    reverse(ReversedDests, Dests),
+          ReversedZs, ReversedLoop, Offset, _),
+    reverse(ReversedLoop, Loop),
     !.
+
 zloop(Directions, Node, Index, Zs, Route) :-
     (   is_end(Node)
     ->  append(Zs, [Index-Node], NewZs)
@@ -62,10 +79,3 @@ next_step([], Move, Remain) :- direction_list([Move | Remain]).
 
 direction_list(Dir) :- direction(Str), atom_chars(Str, Dir).
 direction_len(Len) :- direction_list(D), length(D, Len).
-
-% pick([[1,2,3], [4], [5,6]], X). X = [1,4,5]; X = [1,4,6]; X = [2,4,5]; ...
-pick(ListOfLists, Items) :-
-    maplist([SubList, X]>>(member(X, SubList)), ListOfLists, Items).
-
-natnum(0).
-natnum(N) :- natnum(N0), N is N0 + 1.

08/test2.pl

@@ -8,12 +8,4 @@ nna to nnb-xxx.
 nnb to nnc-nnc.
 nnc to nnz-nnz.
 nnz to nnb-nnb.
-ooa to ooz-oob.
-oob to ood-ooc.
-ooc to ooa-oox.
-ood to ooz-ood.
-ooz to oob-ooz.
 xxx to xxx-xxx.
-
-% Routes = [mma-(2-2-[0-mmz]), nna-(6-3-[0-nnz, 3-nnz]), ooa-(8-1-[0-ooz, 1-ooz])].
-% X = mmannaooa-(24-18-[0-mmznnzooz]).