Erzeugen Sie bei einer ungeraden ganzen Zahl N (5 <= N <= 51) ein Labyrinth mit der Seitenlänge N , das den folgenden Anforderungen entspricht:

Das Labyrinth muss aus den Zeichen | -und bestehen +. Der |Charakter muss als vertikale Wand, der -Charakter als horizontale Wand +verwendet werden. Wenn sich diese Wand dreht, sollte der Charakter verwendet werden.

Die Breite des Pfades muss ein Zeichen sein.

Das Labyrinth muss sich mindestens viermal drehen.

Das Labyrinth muss Außenwände haben, die an zwei Stellen brechen: am Anfang und am Ende.

Das Labyrinth muss von Anfang bis Ende aus einem einzigen, nicht brechenden Pfad bestehen.

Das folgende Beispiel ist ein gültiges Labyrinth: ( N = 5)

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

Und für N = 7:

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

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit der geringsten Anzahl von Bytes.

Jelly , 36 35 34 33 32 Bytes

2*×5H_2Bị⁾ |
_3”-ẋ”+;;Çsẋ2U3¦ṁµY

TryItOnline!

Bauen Sie ein Nachtflugzeug andersherum zu den Beispielen wie:

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

Wie?

2*×5H_2Bị⁾ | - Link 1, pipes & spaces: n      e.g. 7
2*           - 2 raised to the nth power      e.g. 128
  ×5         - multiply by 5                  e.g. 640
    H        - halve                          e.g. 320
     _2      - subtract 2                     e.g. 318
       B     - convert to binary              e.g. [1,0,0,1,1,1,1,1,0]
        ị    - index into (1-based)
         ⁾ | - char list " |"                 e.g. " ||     |"

_3”-ẋ”+;;Çsẋ2U3¦ṁµY - Main link: n            e.g. 7
_3                  - n - 3                   e.g. 4
  ”-                - char list "-"
    ẋ               - repeat                  e.g. "----"
     ”+             - char list "+"
       ;            - concatenate             e.g. "+----"
         Ç          - call last link (1) as a monad
        ;           - concatenate             e.g. "+---- ||     |"" 
          s         - split into chunks of n  e.g. ["+---- |","|     |"]
           ẋ2       - repeat 2 times          e.g. ["+---- |",
                                                    "|     |",
                                              +-->  "+---- |",
                                              |     "|     |"]
              3¦    - apply to index 3:       |
             U      -    upend                +---  "| ----+"
                ṁ   - mould like n (i.e. repeat to fill)
                 µ  - monadic chain separation
                  Y - join with line feeds

(jedes Byte gespeicherten ziemlich nicht-triviale Änderungen beteiligt, die Versionsgeschichte sehen , ob Sie daran interessiert sind, obwohl ich gerade bemerkt , dass Verbindung 1 ist die gleiche Byteanzahl als konventionellere wiederholen und kommen: _2⁶ẋ“ ||“|”j)

JavaScript (ES6), 86 92 116

Fast eine Herausforderung der Kolmogorv-Komplexität ... Mit ein wenig Querdenken (inspiriert von der Antwort von @ Neil) kann es sehr viel kürzer sein. Einfach um 90 ° drehen

n=>`|${s=' '[r='repeat'](n-2)}|
| ${h='-'[r](n-3)}+
|${s}|
+${h} |
`[r](n).slice(n*~n)

Prüfung

f=
n=>`|${s=' '[r='repeat'](n-2)}|
| ${h='-'[r](n-3)}+
|${s}|
+${h} |
`[r](n).slice(n*~n)

function update() {
  var i=+I.value
  O.textContent=i&1? f(i): 'even'
}

update()

<input id=I value=7 min=5 max=49 step=2 type=number oninput="update()"><pre id=O><pre>

Stapel, 216 Bytes

@echo off
set s=
for /l %%i in (4,1,%1)do call set s=-%%s%%
set b= %s:-= %
set r=! %s%+
set s=+%s% !
call:e
for /l %%i in (5,2,%1)do call:l
:l
echo ^|%b%^|
set t=%s%
set s=%r%
set r=%t%
:e
echo %s:!=^|%

|s sind umständlich in Batch , damit ich reflektiertes die Beispiele stattdessen gedreht.

PHP, 99 Bytes

Up-Down-Tore

for($s=str_pad("\n| ",$c=$argv[1],"-")."+\n";$i++<$c;)echo$i%2?$s=strrev($s):str_pad("|",$c-1)."|";

PHP, 157 Bytes

links rechts Tore

<?=($p=str_pad)($n="\n",$c=1+$argv[1],"+---").$p($n,$c-1,"|   ")." #|"[$c%4].str_repeat($p($n,$c,"| "),$c-5).$p($n,$c-1,"  | ")."|# "[$c%4].$p($n,$c,"--+-");

@Titus Vielen Dank, dass Sie die Bytes minimiert haben

JavaScript (ES6), 87 Byte

Eine rekursive Funktion. Gibt einige nachgestellte Leerzeichen aus.

f=(n,w=n,s=' -'[n&1].repeat(w-3),c='|+'[n&1])=>n?`
`+(n&2?c+s+' |':'| '+s+c)+f(n-1,w):s

Prüfung

f=(n,w=n,s=' -'[n&1].repeat(w-3),c='|+'[n&1])=>n?`
`+(n&2?c+s+' |':'| '+s+c)+f(n-1,w):s

console.log(f(9));

Ruby 72 oder 69 Bytes

Lambda-Funktion. Gibt wie gezeigt eine durch Zeilenumbrüche getrennte Zeichenfolge zurück. Löschen Sie * $ /, um ein Array von Zeichenfolgen zurückzugeben.

->n{(1..n).map{|i|"|%s |+%s || %s|| %s+"[i%4*5,5]%(" -"[i%2]*(n-3))}*$/}

Zeichnet ein um 90 Grad gedrehtes Labyrinth aus den Beispielen. Für jede Zeile wird eine Formatzeichenfolge ausgewählt (z. B. +%s |für die erste Zeile (es gibt keine nullte Zeile) und diese mit dem Operator %sdurch eine entsprechende Anzahl von -oder Leerzeichen ersetzt %(entspricht sprintf, ist jedoch kürzer).

Java 7, 228 Bytes

String c(int n){String a="+x |",b="|y|\n",x,y,r=x=y="";int i=0;for(;i++<n-2;){x+=i>1?"-":"";y+=" ";}a=a.replace("x",x);b=b.replace("y",y);for(i=0;i<n;i++)r+=i%4<1?a+"\n":(i-2)%4==0?new StringBuffer(a).reverse()+"\n":b;return r;}

Verwendete eine ähnliche vertikale Ausgabe wie @JonathanAllans Gelee-Antwort .

Ungolfed & Testcode:

Probieren Sie es hier aus.

class M{
  static String c(int n){
    String a = "+x |",
           b = "|y|\n",
           x = "",
           y = "",
           r = "";
    int i = 0;
    for (; i++ < n-2;){
      x += i > 1
            ? "-"
            : "";
      y += " ";
    }
    a = a.replace("x", x);
    b = b.replace("y", y);
    for(i = 0; i < n; i++){
      r += i % 4 < 1
            ? a+"\n"
            : (i-2) % 4 == 0
               ? new StringBuffer(a).reverse()+"\n"
               : b;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(7));
    System.out.println();
    System.out.println(c(25));
  }
}

Ausgabe:

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


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

Python 2, 89 Bytes

def f(n):x='+'+'-'*(n-3)+' |';y='|'+' '*(n-2)+'|';print'\n'.join(([x,y,x[::-1],y]*n)[:n])

repl.it

Erstellt eine interne Wand, xwie '+---- |'und einen internen Korridor, ywie. '| |'
Erstellt dann eine Liste von [x,y,x[::-1],y]( x[::-1]ist eine Umkehrung von x).
Wiederholt dann diese Listenzeiten n(als einzelne Liste) mit *nund schneidet sie bis zu den ersten nEinträgen mit (...)[:n], zusammen Die Liste mit Zeilenumbrüchen, mit '\n'.join(...)und druckt das Ergebnis.

Schläger 187 Bytes

Verwenden des Anzeigemusters von @JonathanAllan

(let*((u "+---- |")(v "|     |")(sr(λ(s)(list->string(reverse(string->list s)))))(g #t)(d displayln)
(p(λ()(d(if g u(sr u)))(set! g(if g #f #t)))))(for((i(ceiling(/ n 2))))(p)(d v))(p))

Ungolfed:

(define (f n)
  (let* ((sr (lambda(s)
               (list->string
                (reverse
                 (string->list s)))))
         (u "+---- |")
         (v "|     |")
         (g #t)
         (d displayln)
         (p (lambda()
              (d (if g u (sr u)))
              (set! g (if g #f #t)))))
    (for ((i (ceiling (/ n 2))))
      (p)
      (d v))
    (p)))

Testen:

(f 10)

Ausgabe:

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

GNU sed 140 Bytes

Beinhaltet +1 für -r

s/1{5}//
h
s/^/+---+\n|   |\n| | |\n  |  \n--+--/
/1/!b
:w
s/^..(..)[^$]*/\1&/gm
s/11//
/1/bw
G
:h
s/\n[^\n]*\n([^\n]*\n)/&\1/
s/1//
/1/bh

Probieren Sie es online!

Nimmt Eingaben unärgerlich auf ( siehe Konsens) ).

Grundsätzlich wird das Labyrinth der Größe 5 eingefügt und dann das zweite und dritte Zeichen jeder Zeile so oft wie nötig an den Anfang angehängt. Dann dupliziert die 3. Zeile (abwechselnd |und ) so oft wie nötig.

Die einzige interessante Sache , die ich verwendet , ist die mOption auf Linie 6 , die erlaubt ^und $jeweils (zusätzlich zu dem normalen Verhalten) , um die leere Zeichenkette nach einem Newline und die leere Zeichenkette , bevor eine neue Zeile zu entsprechen.

T-SQL, 123/79 Bytes

Golf gespielt:

DECLARE @i INT=7

,@ INT=0z:PRINT
STUFF(CHOOSE(@%4+1,'+- |','|  |','| -+','|  |'),3,0,REPLICATE(IIF(@%2=0,'-',' '),@i))SET
@+=1IF @<@i GOTO z

Ungolfed:

DECLARE @i INT = 9

DECLARE @i INT=7

,@ INT=0
z:
  PRINT 
    STUFF(CHOOSE(@%4+1,'+- |','|  |','| -+','|  |'),3,0,
      REPLICATE(IIF(@%2=0,'-',' '),@i))
  SET @+=1
IF @<@i GOTO z

Wenn Sie schummeln und nur ein schmales Labyrinth bilden, kann das Skript auf 79 Bytes heruntergespielt werden:

Golf gespielt:

DECLARE @i INT = 9

,@ INT=0z:PRINT CHOOSE(@%4+1,'+- |','|  |','| -+','|  |')SET @+=1IF @<@i GOTO z

Ungolfed:

DECLARE @i INT = 9

,@ INT=0
z:
  PRINT CHOOSE(@%4+1,'+- |','|  |','| -+','|  |')
  SET @+=1
IF @<@i GOTO z

Geige für die lange Antwort

JavaScript (ES6), 96 Byte

f=(n,w=n-3)=>(h="-".repeat(w),n&2?`+${h} |`:`| ${h}+`)+(n>1?`
| ${" ".repeat(w)}|
`+f(n-2,w):"")

Ich hatte gehofft, dass Rekursion der kürzeste Weg sein würde, und anscheinend ist es ...