Heimwerker für den Minotaurus

42

Heimwerker für den Minotaurus

Das kretische Labyrinth ist recht einfach zu zeichnen. Beginnen Sie einfach mit einer symmetrischen Form (hier in rot). Nennen wir alle Endpunkte dieser Linien "Knoten". Dann beginnen Sie mit dem Zeichnen der Bögen (schwarz): Der erste beginnt immer im oberen mittleren Knoten und verbindet sich mit dem Knoten rechts daneben. Dann werden die beiden Knoten, die dem vorherigen Bogen am nächsten liegen, verbunden. Dies wird wiederholt, bis alle Knoten abgedeckt sind.

gif

Jetzt können wir dieses Konzept verallgemeinern: Wir können leicht neue Anfangsmuster erzeugen, indem wir mehr LFormen hinzufügen . Ich habe die anfänglichen Formen wie folgt aufgezählt:

Grad

Das am weitesten links stehende Muster ergibt ein kretisches Labyrinth vom Grad 0 . Mit dem nächsten wird ein kretisches Labyrinth der Stufe 1 (das ursprüngliche) usw. erstellt.

Aufgabe

Bei einer nichtnegativen Ganzzahl nsollte Ihr Programm die ASCII-Darstellung eines kretischen Gradlabyrinths ausgeben n, wie in den folgenden Beispielen gezeigt. Nachgestellte Leerzeichen / Zeilenumbrüche spielen keine Rolle. Sie müssen eine kurze Erklärung hinzufügen, wie Ihr Code funktioniert.

Beispiele

Die Ausgabe für das ursprüngliche kretische Labyrith (Grad 1) lautet wie folgt:

+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ |
              +---------------+

Ausgangsmuster:

+ | | | +
--+ | +--
----+----
--+ | +--
+ | | | +

Das kretische Labyrinth der Stufe 0 sollte folgendermaßen aussehen:

+-------------+ 
| +---------+ | 
| | +-----+ | | 
| | | +-+ | | | 
| | + | + | | | 
| +---+---+ | | 
+---+ | +---+ | 
      +-------+ 

Ausgangsmuster:

+ | +
--+--
+ | +
fehlerhaft
quelle

Antworten:

10

Perl 5, 349 Bytes

say$p="| "x$_,"+","-"x(16*$n-4*$_+13),"+ $p"for 0..4*($n=pop)+3;say$p="| "x(3*$n+2),"+ | ","| "x2x$n,"+ $p|";$p=~s/..//,$q="-"x(4*$_-1),say"$p+$q+ ","| "x(2*$n-2*$_+1),"+$q+ $p|"for 1..$n;$p=~s/..//;say$p,("+---"."-"x4x$n)x2,"+ $p|";$p=~s/..//,$q="-"x(4*$n+3)."-"x4x$_,say"$p+$q+ | ","| "x2x($n-abs$_),"+$q+ $p|"for-$n..$n;say" "x(8*$n+6),"+----$q+"

(Übergeben Sie n als Befehlszeilenargument.)

Berechnet das Labyrinth zeilenweise in sechs Abschnitten:

  • erste 4n + 4 Zeilen,
  • nächste Zeile (die einzige Zeile mit Nein -),
  • nächste n zeilen,
  • nächste Zeile (die Zeile in der Mitte des Anfangsmusters),
  • die nächsten 2n + 1 Zeilen,
  • letzte Zeile (die Zeile mit den führenden Leerzeichen).
Anders Kaseorg
quelle
6

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 ...

  1. 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.

  2. 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. Kap
quelle
1
Kannst du vielleicht erstmal so R=rangeetwas definieren oder? Das gleiche für P='+'?
Fehler
1
Ich denke, Sie sollten die goldene Gelegenheit nutzen, um zu sagenfor g,o,k,u in Z
Sherlock9
@ Sherlock9 Haha! Gute Idee! Hinzugefügt. :)
R. Kap