Generar un laberinto de un camino

12

Dado un número entero impar N (5 <= N <= 51), genere un laberinto con una longitud lateral N que cumpla los siguientes requisitos:

El laberinto debe estar compuesto por los personajes | -y +. Debe usar el |personaje como un muro vertical, el -personaje como un muro horizontal, y si ese muro gira, +debe usarse el personaje .

El ancho de la ruta debe ser un carácter.

El laberinto debe girar al menos cuatro veces.

El laberinto debe tener paredes exteriores que se rompan en dos puntos: el inicio y el final.

El laberinto debe constar de un camino sin interrupciones, desde el principio hasta el final.

Por ejemplo, el siguiente es un laberinto válido: ( N = 5)

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

Y para N = 7:

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

Recuerde, este es el , por lo que gana el código con el menor número de bytes.

Oliver Ni
fuente
99
No es un laberinto, es un laberinto english.stackexchange.com/a/144103/199361
edc65
@ edc65 En realidad, está más cerca.
Oliver Ni
No tengo claro "El laberinto debe consistir en un camino sin interrupciones, desde el principio hasta el final". ¿Esto significa que solo hay una ruta y es de principio a fin, o que el número de rutas de principio a fin es 1? ¿Puede haber otros caminos con callejones sin salida? Bucles separados?
xnor
El entero impar debe ser <50, <= 49
pinkfloydx33
2
@ edc65 Supongo que OP significa que tampoco.
orlp

Respuestas:

10

Gelatina , 36 35 34 33 32 bytes

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

TryItOnline!

Construye un nighter ™ al revés con ejemplos como:

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

¿Cómo?

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

(cada byte ahorrado implicó cambios bastante no triviales, ver el historial de edición si está interesado, aunque acabo de notar que Link 1 es la misma cuenta de bytes como la repetición más convencional y unirse a: _2⁶ẋ“ ||“|”j)

Jonathan Allan
fuente
5

JavaScript (ES6), 86 92 116

Casi un desafío de complejidad kolmogorv ... Con un poco de pensamiento lateral (inspirado en la respuesta de @ Neil), puede ser muy corto. Solo gira 90 °

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

Prueba

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>

edc65
fuente
@Neil wow todos los días aprendo algo nuevo. Gracias
edc65
¡Increíble! Cuento 86 bytes , por cierto
ETHproductions
@ETHproductions bien. Gracias
edc65
4

Lote, 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 son torpes en lotes por lo que reflejó rotar los ejemplos en su lugar.

Neil
fuente
¿Quieres decir rotar 90 °? Lo intenté y ahorré mucho en JS. Gracias de nuevo
edc65
@ edc65 Originalmente iba por una reflexión, pero tienes razón en que terminé con una rotación en su lugar.
Neil
3

PHP, 99 bytes

puertas de arriba a abajo

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

PHP, 157 bytes

puertas derecha izquierda

<?=($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 Gracias por minializar los bytes

Jörg Hülsermann
fuente
1
ahorre 3 bytes asignando `$ n =" \ n "
Titus
1
$p("",$c*($c-4),...)en lugar de str_repeat(...,$c-4)(-2)
Tito
1
... y 3 bytes más con en $p($n,$c-1," | ")lugar de$p("\n ",$c-1," | ")
Titus
1
Parens innecesarios en ($c)%4(-2), eliminar $gdel código (-1)
Titus
1
versión de arriba a abajo; tercer parámetro innecesario para str_pad (-4), en $c=$argv[1]-1lugar de ($c=$argv[1])-1, en <=$clugar de <$cy en $clugar de $c-1(-3)
Titus
3

JavaScript (ES6), 87 bytes

Una función recursiva. Emite algunos espacios finales.

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

Prueba

Arnauld
fuente
Oh wow, solo intenté la recursión y terminé 9 bytes más. Bien hecho :-)
ETHproductions
2

Ruby 72 o 69 bytes

Función lambda. Como se muestra, devuelve una cadena separada por una nueva línea. Elimine * $ / para devolver una matriz de cadenas.

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

Dibuja un laberinto girado 90 grados de los ejemplos. Para cada línea, se selecciona una cadena de formato (por ejemplo, +%s |para la primera línea (no hay línea cero) y %sse sustituye con un número apropiado de -espacios usando el %operador (equivalente a sprintf, pero más corto).

Level River St
fuente
2

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

Se utilizó una salida vertical similar a la respuesta Jelly de @JonathanAllan .

Ungolfed y código de prueba:

Pruébalo aquí.

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

Salida:

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


+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
Kevin Cruijssen
fuente
disculpa, pero Given an odd integer N (5 <= N <= 51), generate a maze with side length N. Parece que tienes una longitud lateral superior e inferior diferente para la tuya ...
Destructible Lemon
@DestructibleWatermelon Leí más allá de eso. Sin embargo, mi código aún cumplía con todas las reglas / requisitos. Ah, bueno, he retrocedido a mi respuesta original que usaba el mismo ancho que la altura.
Kevin Cruijssen
1

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

Construye un muro interno x, como '+---- |'y un corredor interno y, como '| |'
Luego construye una lista de [x,y,x[::-1],y]( x[::-1]es un reverso de x)
Luego repite esa lista de nveces (como una sola lista), con *n, y la trunca a las primeras nentradas, con (...)[:n], une la lista con avances de línea, con '\n'.join(...)e imprime el resultado.

Jonathan Allan
fuente
1

Raqueta 187 bytes

Usando el patrón de visualización por @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))

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

Pruebas:

(f 10)

Salida:

+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
rnso
fuente
1

GNU sed 140 bytes

Incluye +1 para -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

Pruébalo en línea!

Toma aportes en unario ( ver este consenso ).

Básicamente, inserta el laberinto de tamaño 5, luego agrega el segundo y tercer carácter de cada línea al principio tantas veces como sea necesario. Luego duplica la tercera línea (alternando |y ) tantas veces como sea necesario.

Lo único interesante que utilicé es la mopción en la línea 6 que permite ^y $hacer coincidir respectivamente (además del comportamiento normal) la cadena vacía después de una nueva línea y la cadena vacía antes de una nueva línea.

Riley
fuente
1

T-SQL, 123/79 bytes

Golfizado:

DECLARE @i INT=7

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

Sin 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 haces trampa y solo haces un laberinto estrecho, el script puede reducirse a 79 bytes:

Golfizado:

DECLARE @i INT = 9

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

Sin golf:

DECLARE @i INT = 9

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

Violín por la respuesta larga

t-clausen.dk
fuente
0

JavaScript (ES6), 96 bytes

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

Esperaba que la recursión fuera la ruta más corta, y aparentemente es ...

ETHproductions
fuente