Python 3.5, 703 695 676 648 587 581 542 535 500 486 462 431 423 411 octets:
( Merci à @flawr pour ses conseils sur la sauvegarde de 55 octets (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]))
Pas vraiment un prétendant au titre, mais je l’ai quand même tenté le coup et cela fonctionne parfaitement. Je vais essayer de le raccourcir davantage avec le temps, mais pour l'instant, je l'aime et je ne pourrais pas être plus heureux.
Essayez-le en ligne! (Idéone) (Cela peut paraître un peu différent ici à cause des limitations apparentes du compilateur en ligne. Cependant, c'est toujours très similaire.)
Explication:
Aux fins de cette explication, supposons que la fonction ci-dessus a été exécutée avec l'entrée r, étant égale à 1. Cela étant dit, fondamentalement, ce qui se passe, étape par étape, est ...
q=[*Z(R(0,B-1,2),R(B-1,0,-2))]
Un objet zip,, qest créé avec 2 objets de plage, un composé de chaque deuxième entier de la plage 0=>r+r+1et un autre composé de chaque deuxième entier de la plage r+r+1=>0. En effet, chaque motif de départ d'un labyrinthe crétois d'un degré spécifique aura toujours un nombre pair de -dans chaque ligne. Par exemple, pour un labyrinthe de degrés crétois 1, r+r+1égaux 3, son motif commence toujours par des 0tirets, suivis par une autre ligne comportant des 4tirets (2 + 2). Cet objet zip sera utilisé pour les premières r+1lignes du motif du labyrinthe.
Remarque: La seule raison qest une liste séparée du reste, car elle qest référencée plusieurs fois et en indice, et pour économiser beaucoup de répétition et permettre l'indexation, j'ai simplement créé un objet zip qsous la forme d'une liste.
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]))
C'est la dernière étape dans laquelle le labyrinthe est construit et assemblé. Ici, trois listes, la première comprenant les 4*r+1lignes supérieures du labyrinthe, la seconde les 3*r+3lignes centrales du labyrinthe et la dernière liste constituée de la dernière ligne du labyrinthe, sont reliées entre elles, avec des sauts de ligne ( \n) dans une longue ficelle. Enfin, cette énorme chaîne composée de tout le labyrinthe est imprimée. Approfondissons ce que ces 2 listes et cette chaîne contiennent:
La 1ère liste, dans laquelle un autre objet compressé est utilisé dans la compréhension de liste pour créer chaque ligne une par une, avec des majuscules |ou des +symboles, un nombre impair de tirets dans la plage 0=>4*(r+1), de fin |ou des +symboles, puis une nouvelle ligne ( \n). Dans le cas d'un 1labyrinthe de degrés , cette liste renvoie:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
La 2ème liste, qui consiste en un objet zip contenant 4 listes, chaque liste correspondant au nombre de |symboles de début / fin , au nombre de +symboles, au nombre de tirets, et enfin à la dernière liste, qui contient les premières r+1lignes de le motif créé en fonction de l’objet zip q, la ligne au milieu du motif (celui qui n’a pas |) et les dernières r+2lignes du motif symétrique. Dans ce cas spécifique, la dernière liste utilisée dans l'objet zip de cette liste renverrait:
+ | | | +
--+ | +--
----+----
--+ | +--
+ | | | +
--+ | +-- <- Last line created especially for use in the middle of the labyrinth itself.
Et donc, dans le cas d'un labyrinthe de 1 degré, toute cette liste renverrait:
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ | <- Here is where the extra line of the pattern is used.
Cette liste finale, dans laquelle la dernière ligne est créée. Ici, le premier segment (celui qui précède le premier espace) Pest créé avec la longueur de la dernière ligne de la liste . Ensuite, la longueur du dernier segment (le segment de fin) de la même ligne + 4 tirets sont ajoutés, lesquels sont tous précédés et suivis d'un +symbole unique . Dans le cas d'un labyrinthe de degré 1, cette dernière liste renvoie:
+---------------+
Après avoir réuni tout cela, cette étape renvoie enfin le labyrinthe terminé. Dans le cas d'un labyrinthe de 1 degré, cela renverrait finalement ceci:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ |
+---------------+
R=rangeou quelque chose comme ça? La même chose pourP='+'?for g,o,k,u in Z