Python 3.5, 703 695 676 648 587 581 542 535 500 486 462 431 423 411 Bytes:
( Vielen Dank an @flawr für den Rat zum Sparen von 55 Bytes (486 -> 431)! )
def j(r):R=range;Z=zip;B=r+r+2;P,M='+-';X='| ';q=[*Z(R(0,B-1,2),R(B-1,0,-2))];L=r+1;A=2+r;print('\n'.join([X*w+P+M*v+P+' |'*w for v,w in Z(R(4*L*4-3,0,-4),R(4*L))]+[X*g+P*o+M*k+u+M*k+P*o+' |'*-~g for g,o,k,u in Z([*R(4*L-A,0,-1),*R(4*L-A)],[0]+[1]*(3*r+2),[0,*R(1,4*L,2),*R(4*L+1,11*r,2)],[M*y+'+ '+X*b+P+M*y for y,b in q]+[M*B+P+M*B]+[M*y+'+ '+X*b+P+M*y for y,b in q[::-1]+q[1:]])]+[' '*(8*r+6)+P+M*(8*r+7)+P]))
Es ist kein großer Anwärter auf den Titel, aber ich habe es trotzdem ausprobiert, und es funktioniert perfekt. Ich werde versuchen, es mit der Zeit zu verkürzen, wo ich kann, aber im Moment liebe ich es und könnte nicht glücklicher sein.
Probieren Sie es online! (Ideone) (Kann hier aufgrund offensichtlicher Einschränkungen des Online-Compilers etwas anders aussehen. Es ist jedoch immer noch sehr ähnlich.)
Erläuterung:
Für die Zwecke dieser Erklärung nehmen wir an, dass die obige Funktion ausgeführt wurde, wobei die Eingabe rgleich ist 1. Das heißt, im Grunde, was passiert, Schritt für Schritt, ist ...
q=[*Z(R(0,B-1,2),R(B-1,0,-2))]
Ein zip-Objekt qwird mit 2 Bereichsobjekten erstellt, von denen eines aus jeder zweiten Ganzzahl im Bereich 0=>r+r+1und eines aus jeder zweiten Ganzzahl im Bereich besteht r+r+1=>0. Dies liegt daran, dass jedes Startmuster eines kretischen Labyrinths eines bestimmten Grades -in jeder Zeile immer eine gerade Zahl aufweist . Zum Beispiel für ein kretischen Labyrinth Grad 1, ist r+r+1gleich 3, und somit wird immer sein Muster beginnt mit 0Bindestrichen, gefolgt von einer anderen Linie mit 4(2 + 2) Strichen. Dieses Zip-Objekt wird für die ersten r+1Zeilen des Labyrinthmusters verwendet.
Hinweis: Der einzige Grund qist eine Liste, die vom Rest getrennt ist, da sie qeinige Male referenziert und subskribiert wird. Um viel Wiederholung zu sparen und das Subskribieren zu ermöglichen, habe ich einfach ein Zip-Objekt qin Form einer Liste erstellt.
print('\n'.join([X*w+P+M*v+P+' |'*w for v,w in Z(R(4*L*4-3,0,-4),R(4*L))]+[X*g+P*o+M*k+u+M*k+P*o+' |'*-~g for g,o,k,u in Z([*R(4*L-A,0,-1),*R(4*L-A)],[0]+[1]*(3*r+2),[0,*R(1,4*L,2),*R(4*L+1,11*r,2)],[M*y+'+ '+X*b+P+M*y for y,b in q]+[M*B+P+M*B]+[M*y+'+ '+X*b+P+M*y for y,b in q[::-1]+q[1:]])]+[' '*(8*r+6)+P+M*(8*r+7)+P]))
Dies ist der letzte Schritt, in dem das Labyrinth gebaut und zusammengesetzt wird. Hier werden drei Listen, die erste bestehend aus den oberen 4*r+1Zeilen des Labyrinths, die zweite bestehend aus den mittleren 3*r+3Zeilen des Labyrinths und die letzte Liste bestehend aus der allerletzten Zeile des Labyrinths, mit Zeilenumbrüchen ( \n) in zusammengefügt eine lange Schnur. Zum Schluss wird diese eine riesige Saite ausgedruckt, die aus dem gesamten Labyrinth besteht. Gehen wir näher auf das ein, was diese 2 Listen und 1 Zeichenkette tatsächlich enthalten:
Die 1. Liste, in der ein anderes gezipptes Objekt für das Listenverständnis verwendet wird, um jede Zeile einzeln mit führenden |oder +Symbolen, einer ungeraden Anzahl von Strichen im Bereich 0=>4*(r+1), nachgestellten |oder +Symbolen und einer neuen Zeile ( \n) zu erstellen . Im Fall eines 1Gradlabyrinths gibt diese Liste Folgendes zurück:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
Die 2. Liste, die aus einem Zip-Objekt mit 4 Listen besteht, und jede Liste entspricht der Anzahl der führenden / nachfolgenden |Symbole, der Anzahl der +Symbole, der Anzahl der Bindestriche und schließlich der letzten Liste, die die ersten r+1Zeilen von enthält Das Muster, das gemäß dem Zip-Objekt erstellt wurde q, die Linie in der Mitte des Musters (die mit der Nr. |) und die letzten r+2Linien des symmetrischen Musters. In diesem speziellen Fall würde die zuletzt im zip-Objekt dieser Liste verwendete Liste Folgendes zurückgeben:
+ | | | +
--+ | +--
----+----
--+ | +--
+ | | | +
--+ | +-- <- Last line created especially for use in the middle of the labyrinth itself.
Und daher würde im Fall eines Labyrinths von 1 Grad diese gesamte Liste zurückkehren:
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ | <- Here is where the extra line of the pattern is used.
Diese endgültige Liste, in der die letzte Zeile erstellt wird. Hier wird die Länge des ersten Segments (das vor dem ersten Leerzeichen) der letzten Zeile der Listenzahl Pder Leerzeichen erstellt. Dann wird die Länge des letzten Segments (des Endsegments) derselben Zeile + 4 Striche hinzugefügt, denen jeweils ein einzelnes +Symbol vorangestellt und gefolgt wird . Im Fall eines Labyrinths der Stufe 1 gibt diese letzte Liste Folgendes zurück:
+---------------+
Nachdem Sie all dies zusammengefügt haben, wird mit diesem Schritt das fertige Labyrinth wiederhergestellt. Im Falle eines 1-Grad-Labyrinths würde es schließlich Folgendes zurückgeben:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ |
+---------------+
R=rangeetwas definieren oder? Das gleiche fürP='+'?