Dato un numero intero dispari N (5 <= N <= 51), genera un labirinto con lunghezza laterale N che segue i seguenti requisiti:

Il labirinto deve essere composto dai personaggi | -e +. Deve usare il |personaggio come un muro verticale, il -personaggio come un muro orizzontale e se quel muro gira, il personaggio +dovrebbe essere usato.

La larghezza del percorso deve essere di un carattere.

Il labirinto deve girare almeno quattro volte.

Il labirinto deve avere pareti esterne, che si spezzano in due punti: l'inizio e la fine.

Il labirinto deve consistere in un percorso senza interruzioni, dall'inizio alla fine.

Ad esempio, il seguente è un labirinto valido: ( N = 5)

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

E per N = 7:

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

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

Gelatina , 36 35 34 33 32 byte

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

TryItOnline!

Crea un nighter ™ viceversa rispetto agli esempi come:

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

Come?

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

(ogni byte salvato coinvolto cambiamenti abbastanza non banali, vedere la storia delle modifiche, se siete interessati, anche se ho appena notato che Link 1 è lo stesso numero di byte come il ripetere più convenzionale e unisciti: _2⁶ẋ“ ||“|”j)

JavaScript (ES6), 86 92 116

Quasi una sfida di complessità kolmogorv ... Con un po 'di pensiero laterale (ispirato alla risposta di @ Neil), può essere molto più breve. Basta ruotare di 90 °

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

Test

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>

Lotto, 216 byte

@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 sono imbarazzanti in Batch, quindi ho riflettuto invece ruotato gli esempi.

PHP, 99 byte

fino alle porte

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

PHP, 157 byte

porte a destra a sinistra

<?=($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 Grazie per minializzare i byte

JavaScript (ES6), 87 byte

Una funzione ricorsiva. Emette alcuni spazi finali.

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

Test

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 o 69 byte

Funzione lambda. Come mostrato, restituisce una stringa separata da nuova riga. Elimina * $ / per restituire un array di stringhe.

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

Disegna un labirinto ruotato di 90 gradi dagli esempi. Per ogni riga, viene selezionata una stringa di formato (ad esempio +%s |per la 1a riga (non esiste una riga zeroth) e %sviene sostituita con un numero appropriato di -o spazi usando l' %operatore (equivalente a sprintf, ma più breve).

Java 7, 228 byte

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;}

Utilizzato un output verticale simile alla risposta Jelly di @JonathanAllan .

Codice non testato e test:

Provalo qui.

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));
  }
}

Produzione:

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


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

Python 2, 89 byte

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

repl.it

Costruisce un muro interno x, come '+---- |'e un corridoio interno y, come '| |'
Quindi costruisce un elenco di [x,y,x[::-1],y]( x[::-1]è un rovescio di x)
Quindi ripete i ntempi di elenco (come un unico elenco), con *ne lo tronca alle prime nvoci, con (...)[:n], join l'elenco con feed di riga, con '\n'.join(...)e stampa il risultato.

Racchetta 187 byte

Utilizzo del modello di visualizzazione di @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)))

test:

(f 10)

Produzione:

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

GNU sed 140 byte

Include +1 per -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

Provalo online!

Riceve input in unario ( vedi questo consenso ).

Fondamentalmente inserisce il labirinto di dimensione 5, quindi aggiunge il 2o e 3o carattere di ogni riga all'inizio tutte le volte necessarie. Quindi duplica la terza riga (alternando| e ) tutte le volte che è necessario.

L'unica cosa interessante che ho usato è l' mopzione sulla riga 6 che consente ^e $di abbinare rispettivamente (oltre al comportamento normale) la stringa vuota dopo una nuova riga e la stringa vuota prima di una nuova riga.

T-SQL, 123/79 byte

golfed:

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

Se imbrogliate e create solo un labirinto stretto, la sceneggiatura può essere giocata a golf fino a 79 byte:

golfed:

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

Fiddle per la lunga risposta

JavaScript (ES6), 96 byte

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

Speravo che la ricorsione si sarebbe rivelata la via più breve, e apparentemente è ...