Sua tarefa é criar um programa ou função que obtenha, como entrada, um número natural ( n) entre 1 e 25 (inclusive) e imprima uma representação isométrica de um slide e escada com nnúmero de degraus.

Especificações de escada e corrediça

A escada está sempre orientada à esquerda e a corrediça à direita. Como a visualizamos pelo lado da escada, parte do slide fica oculta nos três níveis superiores. Os degraus são representados por quatro traços ( ----) e os lados da escada e deslizam por barras ( /e \). A seguir, é apresentado um diagrama para representar os padrões de espaços necessários para um slide com cinco degraus.

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

Exemplos

>>1
/----/\

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

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

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

Isso é código-golfe, então a resposta com a menor contagem de bytes vence.

Nota: o espaço em branco à direita é aceitável na saída, desde que não exceda o comprimento da linha.

Retina , 81 72 52 bytes

A contagem de bytes assume a codificação ISO 8859-1.

.+
$* /\    \
^.

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

Experimente online!

Explicação

O programa consiste em quatro etapas, todas substituições de expressões regulares (com alguns recursos específicos da Retina). Vou usar a entrada 5como um exemplo para a explicação.

Estágio 1

.+
$* /\    \

Isso transforma a entrada nem nespaços seguidos pelos /\ \quais se tornarão o topo da escada / slide:

     /\    \

Por enquanto, apenas mostraremos o slide na íntegra e representamos a escada apenas pela mão esquerda /.

Etapa 2

^.

Infelizmente, os nespaços são um a mais do que precisamos, então removemos o primeiro caractere novamente. Agora temos:

    /\    \

Etapa 3

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

Hora de expandir a estrutura completa. Saber onde está o topo é suficiente para construir a coisa toda, porque podemos simplesmente estendê-la uma linha de cada vez, afastando a escada e o escorregador por dois espaços.

O +instrui o Retina a repetir esse estágio em um loop até que a saída pare de mudar (nesse caso, porque o regex para de corresponder). Quanto ao regex em si, simplesmente combinamos o /na última linha e tudo o que está depois dele e também o espaço na frente dele, o que significa que isso não pode mais corresponder depois /que a primeira coluna for atingida.

Aqui está o que substituímos por:

 $&    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.

Portanto, a cada iteração, isso adiciona uma linha à string, até que terminemos com isso:

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

Etapa 4

/.{5}
/----/

Tudo o que resta é acertar a escada. Isso é realmente simples: basta combinar os /5 caracteres seguintes e inserir a representação correta da escada, substituindo assim o slide ou os espaços que já estão lá:

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

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

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

Experimente online!

Eu posso conversar com Osabie. Um byte menor que Osabie. \o/Amarrado com 2sable! Um byte mais curto!

Em outras notícias, esse é definitivamente o cabeçalho tachado mais longo que eu já fiz.

Explicação:

Àé              "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.

Isso será executado até que ocorra um erro que, graças ao comando "mover para a esquerda" ('h'), será 'arg1' vezes.

Agora só precisamos adicionar a perna 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 '\'

Versão não concorrente (28 bytes)

Pitão, 39 35 bytes

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

Explicação:

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

Teste aqui

2sable , 40 36 32 30 bytes

Hmmm, V está chegando muito perto ...

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

Usa a codificação CP-1252 . Experimente uma versão compatível com 05AB1E! .

PowerShell v2 +, 99 90 82 bytes

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

Recebe entrada $n, inicia um loop de 1para $ncom |%{...}. A cada iteração, estamos construindo uma string. Começamos com o número apropriado de espaços " "*($n-$_)e a escada "/----/".

Para isso, adicionamos outra string que foi fatiada [...]e -joinedificada novamente. A segunda string é o slide, e assumimos que o slide inteiro esteja sempre visível. É o número de espaços antes do início do slide " "*($_+$i++), seguido pelo próprio slide "\ \". Isso é fatiado por um intervalo calculado como sendo a parte dos "espaços mais slide" que está parcialmente oculta pela escada.

Exemplos

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:]

Agradeço a Hubert Grzeskowiak por me "desqualificar", pois a impressão do meu programa realmente salvou 3 bytes! Agradecemos também a Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ por economizar mais 1 byte!

Vim, 71 pressionamentos de tecla

É uma maneira tão estúpida de fazê-lo, mas é um pouco divertido. A entrada é fornecida como um arquivo de texto com uma única linha contendo um número inteiro. Provavelmente isso é bastante jogável, mas funcionará por enquanto ( editar: estilo alternado de caracteres de controle mediante solicitação ):

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>e <cr>são todas as teclas individuais; ctrl + v, escape e retorno de carro (enter) respectivamente. Para uma versão simples de digerir com os literais corretos, aqui está o arquivo ladder.keysexecutado xxd:

00000000: 4140 7179 7950 6767 1616 476b 4920 161b  A@qyyPgg..GkI ..
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 testá-lo (assumindo um nix com as ferramentas apropriadas), execute o procedimento acima, execute-o xxd -re coloque-o no arquivo ladder.keys. Crie um arquivo ladder.txtcom um número inteiro. Então faça:

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

festança, 61

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

onde ^Mé um 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 ocupando uma série de nespaços, fazendo uma substituição exótica para obter o slide com um suporte e substituindo o suporte por uma escada.

Ruby, 61 bytes

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

Ungolfed

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

Eu poderia salvar dois bytes usando '%*s\ \^M%*s----/'(onde ^Mestá um retorno de carro literal) para a string de formato, mas Ruby imprime o aviso " warning: encountered \r in middle of line, treated as a mere space". ¯ \ _ (ツ) _ / ¯

Solução 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%

Acabou sendo razoavelmente simples: recue o slide, remova os 7 primeiros caracteres, recue a escada, remova o espaço inicial. Este último pedaço envolve um pouco de truque!

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?"":"\\");};

Infelizmente, você não pode [facilmente] duplicar seqüências de caracteres em Java, então acabo abusando da função de formatação.

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 , não-competitivo, 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

Tornei oficialmente a linguagem mais detalhada possível. Fiz o comentário em tom de brincadeira e sarcasmo. Por favor acalme-se. Instruções sobre como executar no repositório github vinculado no cabeçalho.

Ungolfed

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