Su tarea es crear un programa o función que tome, como entrada, un número natural ( n) entre 1 y 25 (inclusive) e imprima una representación isométrica de una diapositiva y una escalera con nnúmero de peldaños.

Especificaciones de escalera y tobogán

La escalera siempre está orientada a la izquierda y la corredera a la derecha. Lo estamos viendo desde el lado de la escalera, por lo que parte de la diapositiva está oculta en los tres niveles superiores. Los peldaños están representados por cuatro guiones ( ----) y los lados de la escalera y se deslizan por barras ( /y \). El siguiente es un diagrama para representar los patrones de espacios necesarios para una diapositiva con cinco peldaños.

Slide              Blank space count
    /----/\        1234/----/\ 
   /----/  \       123/----/12\ 
  /----/    \      12/----/1234\ 
 /----/ \    \     1/----/1\1234\ 
/----/   \    \    /----/123\1234\

Ejemplos

>>1
/----/\

>>3
  /----/\ 
 /----/  \ 
/----/    \ 

>>4
   /----/\ 
  /----/  \ 
 /----/    \ 
/----/ \    \ 

>>10
         /----/\ 
        /----/  \ 
       /----/    \ 
      /----/ \    \ 
     /----/   \    \ 
    /----/     \    \ 
   /----/       \    \ 
  /----/         \    \ 
 /----/           \    \ 
/----/             \    \ 

Este es el código de golf, por lo que gana la respuesta con el conteo de bytes más bajo.

Nota: el espacio en blanco final es aceptable en la salida, siempre que no exceda la longitud de la línea.

Retina , 81 72 52 bytes

El recuento de bytes asume la codificación ISO 8859-1.

.+
$* /\    \
^.

+` /(.+)$
$&¶$%`/  $1
/.{5}
/----/

Pruébalo en línea!

Explicación

El programa consta de cuatro etapas, todas las cuales son sustituciones de expresiones regulares (con un par de características específicas de Retina). Usaré la entrada 5como ejemplo para la explicación.

Nivel 1

.+
$* /\    \

Esto convierte la entrada nen nespacios seguidos por los /\ \cuales se convertirán en la parte superior de la escalera / diapositiva:

     /\    \

Por ahora, solo mostraremos la diapositiva en su totalidad y representaremos la escalera solo con su mano izquierda /.

Etapa 2

^.

Desafortunadamente, los nespacios son uno más de lo que necesitamos, por lo que eliminamos el primer carácter nuevamente. Ahora tenemos:

    /\    \

Etapa 3

+` /(.+)$
$&¶$%`/  $1

Es hora de expandir la estructura completa. Saber dónde está la parte superior es suficiente para construir todo, porque simplemente podemos extenderlo una línea a la vez, separando la escalera y el tobogán en dos espacios.

El +le dice a Retina que repita esta etapa en un bucle hasta que la salida deje de cambiar (en este caso, porque la expresión regular deja de coincidir). En cuanto a la expresión regular en sí, simplemente hacemos coincidir la /última línea y todo lo que está detrás de ella y también hacemos coincidir un espacio delante de ella, lo que significa que esto ya no puede coincidir una vez que /haya llegado a la primera columna.

Esto es con lo que reemplazamos esto:

 $&    The match itself. We don't want to remove the line we already have.
 ¶     A linefeed, because we want to append a new line.
 $%`   This is a very recent addition to Retina: it's like the normal $` but
      is bounded by linefeeds. That means this inserts everything in front
      of the match which is on the same line. In particular this one space
      less than the indentation of the matched line, hence we are shifting
      the / one column left.
 /     A literal /, representing the left edge of the ladder.
>  <   Two spaces, so that we can shift the slide one column right.
 $1    Capturing group 1 which contains the slide and its separation from
      the ladder.

Entonces, en cada iteración, esto agrega una línea a la cadena, hasta que terminamos con esto:

    /\    \
   /  \    \
  /    \    \
 /      \    \
/        \    \

Etapa 4

/.{5}
/----/

Todo lo que queda es conseguir la escalera correcta. Eso es realmente simple, simplemente combinamos los /siguientes 5 caracteres e insertamos la representación de escalera correcta, anulando así la diapositiva o los espacios que ya están allí:

    /----/\
   /----/  \
  /----/    \
 /----/ \    \
/----/   \    \

V , 38, 37, 36, 34, 33, 32, 31, 30 29 bytes

Àé r\2é/4é-òhYpX$2P^ò3GEòjlr\

Pruébalo en línea!

Yo podría ponerse al día con Osabie. Un byte más corto que Osabie. \o/Atado con 2sable! ¡Un byte más corto!

En otras noticias, este es definitivamente el encabezado tachado más largo que he hecho.

Explicación:

Àé              "Insert 'arg1' spaces
   r\           "Turn the last one into a '\'
     2é/        "Insert 2 '/'
        4é-     "Insert 4 '-'

ò        ò      "Recursivly:
 h              "  Move one to the left
  Yp            "  Duplicate this line
    X           "  Delete one space from the left
     $2P        "  Paste two spaces at the end of this line
        ^       "  Move back to the beginning of this line.

Esto se ejecutará hasta que ocurra un error, que gracias al comando "mover a la izquierda" ('h'), será 'arg1' veces.

Ahora solo necesitamos agregar la pierna interna

3GE             "Move to the second slash of line 3
   ò    ò       "Recursively: (The second 'ò' is implicit)
    jl          "  Move down and to the right
      r\        "  And replace the character under the cursor with a '\'

Versión no competitiva (28 bytes)

Pyth, 39 35 bytes

VQ++*dt-QN"/----/">+*+ddN"\    \\"5

Explicación:

VQ                                  # Interate over 0 -> Q-1 (Q is the input)
  +                                 # Concatenate the 2 halfs of the slide
   +                                # Concatenate the whitespace block and the ladder
    *d                              # Multiply d (whitespace) by this number \/
      t-QN                          # Calculate the amount of spaces before : input - step of the iterarion -1
          "/----/"                  # Ladder
                  >               5 # Remove the first 5 chars  from the string generated in the following lines 
                   +                # Concatenate the whitespace block and the slide
                    *+ddN           # Multiply "+dd" (2 whitespace) by the step of the iterarion to generate the space between the ladder and the slide
                         "\    \\"  # Slide

Prueba aquí

2sable , 40 36 32 30 bytes

Hmmm, V se acerca terriblemente ...

F¹N-<ð×…/--«ðð«N×…\  ««5F¦}¶

Utiliza la codificación CP-1252 . ¡Pruebe una versión compatible con 05AB1E! .

PowerShell v2 +, 99 90 82 bytes

param($n)1..$n|%{" "*($n-$_)+"/----/"+-join(" "*($_+$i++)+"\    \")[6..(6+$_+$i)]}

Toma entrada $n, inicia un ciclo de 1a $ncon |%{...}. Cada iteración, estamos construyendo una cadena. Comenzamos con el número apropiado de espacios " "*($n-$_)y la escalera "/----/".

A eso, agregamos otra cadena que ha sido cortada [...]y -joineditada nuevamente. La segunda cadena es la diapositiva, y suponemos que toda la diapositiva siempre es visible. Es la cantidad de espacios antes de que comience la diapositiva " "*($_+$i++), seguida de la diapositiva misma "\ \". Esto se divide en un rango calculado como parte de los "espacios más diapositivas" que está parcialmente oculto por la escalera.

Ejemplos

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 7
      /----/\
     /----/  \
    /----/    \
   /----/ \    \
  /----/   \    \
 /----/     \    \
/----/       \    \

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 15
              /----/\
             /----/  \
            /----/    \
           /----/ \    \
          /----/   \    \
         /----/     \    \
        /----/       \    \
       /----/         \    \
      /----/           \    \
     /----/             \    \
    /----/               \    \
   /----/                 \    \
  /----/                   \    \
 /----/                     \    \
/----/                       \    \

Python 2 - 79 76 75 bytes

x=input()
for i in range(x):print(x-i)*' '+'/----/'+(i*'  '+'\\    \\')[5:]

Gracias a Hubert Grzeskowiak por "descalificarme" ya que la impresión de mi programa realmente ahorró 3 bytes. ¡Gracias también a Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ por guardar 1 byte más!

Vim, 71 pulsaciones de teclas

Esta es una forma tan estúpida de hacerlo, pero es un poco divertido. La entrada se proporciona como un archivo de texto con una sola línea que contiene un número entero. Es probable que esto sea bastante golfable, pero lo hará por ahora ( editar: estilo de caracteres de control cambiados a pedido ):

A@qyyPgg<c-v><c-v>GkI <c-v><esc>G$i  <c-v><esc><esc>
Tq"qDI/----/\^[lD@"ddh<c-v>god:%s/     \\/\\    \\<cr>

<c-v>, <esc>y <cr>son todas las pulsaciones de teclas individuales; ctrl + v, escape y retorno de carro (enter) respectivamente. Para una versión simple de digerir con los literales correctos, aquí está el archivo ladder.keysejecutado xxd:

00000000: 4140 7179 7950 6767 1616 476b 4920 161b  [email protected] ..
00000010: 4724 6920 2016 1b1b 5471 2271 4449 2f2d  G$i  ...Tq"qDI/-
00000020: 2d2d 2d2f 5c1b 6c44 4022 6464 6816 676f  ---/\.lD@"ddh.go
00000030: 643a 2573 2f20 2020 2020 5c5c 2f5c 5c20  d:%s/     \\/\\
00000040: 2020 205c 5c0d 0d0a                         \\...

Para probarlo (suponiendo un nix con las herramientas apropiadas), tome lo anterior, ejecútelo xxd -ry póngalo en el archivo ladder.keys. Crea un archivo ladder.txtcon un número entero. Entonces hazlo:

vim -s ladder.keys -u NONE ladder.txt

golpe, 61

for((;i<$1;)){ printf "%$[$1+i]s\    \^M%$[$1-++i]s/----/\n";}

donde ^Mes un retorno de carro literal

$ ./ladder 1
/----/\
$ ./ladder 4
   /----/\
  /----/  \
 /----/    \
/----/ \    \
$ ./ladder 10
         /----/\
        /----/  \
       /----/    \
      /----/ \    \
     /----/   \    \
    /----/     \    \
   /----/       \    \
  /----/         \    \
 /----/           \    \
/----/             \    \

JavaScript (ES6), 79 bytes

f=
n=>" ".repeat(n).replace(/./g,"$'/$`$`\\    \\\n").replace(/\/...../g,"/----/")
;

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Funciona tomando una serie de nespacios, luego haciendo una sustitución exótica para obtener el tobogán con un soporte, luego reemplazando el soporte con una escalera.

Ruby, 61 bytes

->n{n.times{|i|puts"%*s\\    \\\r%*s----/"% [n+i,"",n-i,?/]}}

Sin golf

->(num_rows) {
  num_rows.times {|row_idx|
    puts "%*s\\    \\\r%*s----/" % [ num_rows + row_idx, "", num_rows - row_idx, "/" ]
  }
}

Podría guardar dos bytes usando '%*s\ \^M%*s----/'(donde ^Mes un retorno de carro literal) para la cadena de formato, pero luego Ruby imprime la advertencia " warning: encountered \r in middle of line, treated as a mere space". ¯ \ _ (ツ) _ / ¯

Solución anterior (64 bytes)

->n{n.times{|i|puts" "*(n+i)+"\\    \\\r"+" "*(n-i-1)+"/----/"}}

Lote, 194 bytes.

@echo off
for /l %%i in (1,1,%1)do call:l %1 %%i
exit/b
:l
set s=\    \
for /l %%j in (1,1,%2)do call set s=  %%s%%
set s=/----/%s:~7%
for /l %%j in (%2,1,%1)do call set s= %%s%%
echo%s%

Resultó ser razonablemente sencillo: sangrar la diapositiva, eliminar los primeros 7 caracteres, sangrar la escalera, eliminar el espacio inicial. ¡Sin embargo, esta última parte implica un pequeño truco!

Java, 116 bytes

c->{for(int i=0;i<c;i++)System.out.format("%"+(5+c-i)+"s%"+(i<3?i*2+1:2*(i-2))+"s%5s\n","/----/","\\",i<3?"":"\\");};

Desafortunadamente, no puedes [fácilmente] duplicar cadenas en Java, así que termino abusando de la función de formato.

Scala, 95 bytes

def l(n:Int)=for(i<- 0 to n-1){println(" "*(n-i-1)+"/----/"+("  "*i+"\\    \\").substring(5))}

Haskell, 81 bytes

a n=[1..n]>>" "
f n=[1..n]>>=(\i->a(n-i)++"/----/"++drop 7(a(2*i)++"\\    \\\n"))

eacal , sin competencia, 386 bytes

init .
define @ curry push .
define ~ curry exec .--func
alias $ strap
alias ' string
set n set m cast number arg number 0
set s empty string
label l
@ get n
set n ~ dec
@ space
@ get n
$ ~ repeat
$ ' /----/
@ space
@ get m
@ get n
@ ~ sub
@ ~ dec
@ number 2
@ ~ mul
$ ~ repeat
$ ' \
$ newline
@ get n
@ number 0
if ~ more
goto l
@ $
@ regex gm '   ( {4})(?=.$)
@ '  \$1
print ~ replace

Oficialmente he hecho el lenguaje más detallado posible.Hice el comentario en broma y en sarcasmo. Por favor calmate. Instrucciones sobre cómo ejecutar en el repositorio de github vinculado en el encabezado.

Sin golf

init .
set n set m cast number arg number 0
set s empty string
label loop
    push . get n
    set n exec .--func dec
    push . space
    push . get n
    strap exec .--func repeat
    strap string /----/
    push . space
    push . get m
    push . get n
    push . exec .--func sub
    push . exec .--func dec
    push . number 2
    push . exec .--func mul
    strap exec .--func repeat
    strap string \
    strap newline
    push . get n
    push . number 0
    if exec .--func more
        goto loop

push . strap
push . regex gm string   ( {4})(?=.$)
push . string  \$1
print exec .--func replace