Étant donné un entier impair N (5 <= N <= 51), générez un labyrinthe de longueur latérale N qui respecte les exigences suivantes:

Le labyrinthe doit être composé des personnages | -et +. Il doit utiliser le |personnage comme un mur vertical, le -personnage comme un mur horizontal, et si ce mur tourne, le personnage +doit être utilisé.

La largeur du chemin doit être d'un caractère.

Le labyrinthe doit tourner au moins quatre fois.

Le labyrinthe doit avoir des murs extérieurs qui se cassent en deux points: le début et la fin.

Le labyrinthe doit consister en un chemin incassable, du début à la fin.

Par exemple, ce qui suit est un labyrinthe valide: ( N = 5)

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

Et pour N = 7:

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

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le moins d'octets gagne.

Gelée , 36 35 34 33 32 octets

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

TryItOnline!

Construit un nighter ™ à l'inverse des exemples comme:

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

Comment?

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

(chaque octet impliqué des changements assez épargné non triviales, voir l'historique des modifications si vous êtes intéressé, bien que je viens de remarquer que Link 1 est le nombre d'octets même que la répétition plus classique et rejoindre: _2⁶ẋ“ ||“|”j)

JavaScript (ES6), 86 92 116

Presque un défi de complexité kolmogorv ... Avec un peu de réflexion latérale (inspirée de la réponse de @ Neil), il peut être très court. Il suffit de tourner à 90 °

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

Tester

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>

Lot, 216 octets

@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 sont maladroits dans Batch, j'ai donc réfléchi à la rotation des exemples.

PHP, 99 octets

portes de haut en bas

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

PHP, 157 octets

portes gauche droite

<?=($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 Merci d'avoir minialisé les octets

JavaScript (ES6), 87 octets

Une fonction récursive. Génère quelques espaces de fin.

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

Tester

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 ou 69 octets

Fonction lambda. Comme indiqué, renvoie une chaîne séparée par des sauts de ligne. Supprimez * $ / pour renvoyer un tableau de chaînes.

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

Dessine un labyrinthe tourné de 90 degrés à partir des exemples. Pour chaque ligne, une chaîne de format est sélectionnée (par exemple +%s |pour la 1ère ligne (il n'y a pas de ligne zéro) et la %sest remplacée par un nombre approprié d' -espaces ou utilisant l' %opérateur (équivalent à sprintf, mais plus court.)

Java 7, 228 octets

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

Utilisé une sortie verticale similaire à la réponse Jelly de @JonathanAllan .

Code non testé et testé:

Essayez-le ici.

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

Production:

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


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

Python 2, 89 octets

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

repl.it

Construit un mur interne x, comme '+---- |'et un couloir interne y, comme '| |'
Puis construit une liste de [x,y,x[::-1],y]( x[::-1]est l'inverse de x)
Puis répète cette liste nfois (comme une seule liste), avec *net la tronque aux premières nentrées, avec (...)[:n], jointures la liste avec les sauts de ligne, avec '\n'.join(...)et imprime le résultat.

Raquette 187 octets

Utilisation du modèle d'affichage par @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))

Non golfé:

(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)))

Essai:

(f 10)

Production:

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

GNU sed 140 octets

Comprend +1 pour -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

Essayez-le en ligne!

Prend la contribution en unaire ( voir ce consensus ).

Fondamentalement, il insère le labyrinthe de taille 5, puis ajoute le deuxième et le troisième caractère de chaque ligne au début autant de fois que nécessaire. Duplique ensuite la 3e ligne (en alternance |et ) autant de fois que nécessaire.

La seule chose intéressante que j'ai utilisée est l' moption sur la ligne 6 qui permet ^et fait $correspondre respectivement (en plus du comportement normal) la chaîne vide après une nouvelle ligne, et la chaîne vide avant une nouvelle ligne.

T-SQL, 123/79 octets

Golfé:

DECLARE @i INT=7

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

Non golfé:

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

Si vous trichez et ne faites qu'un étroit labyrinthe, le script peut être joué jusqu'à 79 octets:

Golfé:

DECLARE @i INT = 9

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

Non golfé:

DECLARE @i INT = 9

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

Violon pour la réponse longue

JavaScript (ES6), 96 octets

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

J'espérais que la récursivité serait la voie la plus courte, et apparemment c'est ...