Il tuo compito è creare un programma o una funzione che accetta, come input, un numero naturale ( n) tra 1 e 25 (incluso) e stampa una rappresentazione isometrica di una diapositiva e una scala con il nnumero di pioli.

Specifiche scala e scivolo

La scala è sempre orientata a sinistra e la diapositiva a destra. Lo stiamo osservando dal lato della scala, quindi parte della diapositiva è oscurata nei primi tre livelli. I pioli sono rappresentati da quattro trattini ( ----) e dai lati della scala e scorrono da barre ( /e \). Di seguito è riportato un diagramma per rappresentare i motivi degli spazi necessari per una diapositiva con cinque gradini.

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

Esempi

>>1
/----/\

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

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

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

Questo è code-golf, quindi vince la risposta con il numero di byte più basso.

Nota: lo spazio bianco finale è accettabile nell'output, purché non superi la lunghezza della linea.

Retina , 81 72 52 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

.+
$* /\    \
^.

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

Provalo online!

Spiegazione

Il programma consiste in quattro fasi, tutte sostituzioni regex (con un paio di funzioni specifiche per Retina). Userò l'input 5come esempio per la spiegazione.

Fase 1

.+
$* /\    \

Questo trasforma l'input nin nspazi seguiti da quelli /\ \che diventeranno la cima della scala / diapositiva:

     /\    \

Per ora, mostreremo la diapositiva per intero e rappresenteremo la scala solo con la sua mano sinistra / .

Fase 2

^.

Sfortunatamente, gli nspazi sono uno in più del necessario, quindi rimuoviamo di nuovo il primo personaggio. Ora abbiamo:

    /\    \

Fase 3

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

È ora di espandere la struttura completa. Sapere dove la cima è sufficiente per costruire l'intera cosa, perché possiamo semplicemente estenderla di una linea alla volta, spostando la scala e lo scivolo di due spazi.

Questo +dice a Retina di ripetere questo stadio in un ciclo fino a quando l'uscita smette di cambiare (in questo caso, perché il regex smette di abbinare). Per quanto riguarda la regex stessa, abbiniamo semplicemente /l'ultima riga e tutto ciò che segue e abbiniamo anche uno spazio davanti ad esso, il che significa che non può più abbinare una volta /raggiunta la prima colonna.

Ecco cosa lo sostituiamo con:

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

Quindi ad ogni iterazione, questo aggiunge una riga alla stringa, fino a quando non finiamo con questo:

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

Fase 4

/.{5}
/----/

Tutto ciò che rimane è ottenere la scala giusta. È davvero semplice, abbiniamo solo /i successivi 5 caratteri e inseriamo la rappresentazione ladder corretta, sovrascrivendo così la diapositiva o gli spazi che sono già lì:

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

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

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

Provalo online!

Ho potuto recuperare il ritardo con Osabie. Un byte più corto di Osabie.\o/Legato con 2sable! Un byte in meno!

In altre notizie, questa è sicuramente l'intestazione barrata più lunga che abbia mai fatto.

Spiegazione:

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

Questo verrà eseguito fino a quando si verifica un errore, che grazie al comando "sposta a sinistra" ('h'), sarà 'arg1' volte.

Ora dobbiamo solo aggiungere la gamba 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 '\'

Versione non competitiva (28 byte)

Pyth, 39 35 byte

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

Spiegazione:

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

Prova qui

2sable , 40 36 32 30 byte

Hmmm, V si sta avvicinando terribilmente ...

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

Utilizza la codifica CP-1252 . Prova una versione compatibile 05AB1E! .

PowerShell v2 +, 99 90 82 byte

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

Accetta input $n, avvia un loop da 1a $ncon |%{...}. Ogni iterazione, stiamo costruendo una stringa. Iniziamo con il numero appropriato di spazi " "*($n-$_)e la scala "/----/".

A ciò, aggiungiamo un'altra stringa che è stata tagliata [...]e -joinrimessa insieme. La seconda stringa è la diapositiva e supponiamo che l'intera diapositiva sia sempre visibile. È il numero di spazi prima dell'inizio della diapositiva " "*($_+$i++), seguito dalla diapositiva stessa "\ \". Questo è suddiviso in un intervallo calcolato come parte degli "spazi più diapositiva" che è parzialmente nascosto dalla scala.

Esempi

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 byte

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

Grazie a Hubert Grzeskowiak per "squalificarmi" da quando ho fatto la stampa del mio programma effettivamente salvato 3 byte! Grazie anche a Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ per aver salvato 1 byte in più!

Vim, 71 sequenze di tasti

Questo è un modo così stupido di farlo, ma è un po 'divertente. L'input viene fornito come file di testo con una singola riga contenente un numero intero. Questo è probabilmente abbastanza giocabile, ma per ora lo farà ( modifica: cambio di stile dei caratteri di controllo su richiesta ):

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>sono tutti i singoli tasti; ctrl + v, escape e ritorno a capo (invio) rispettivamente. Per una versione semplice da digerire con i valori letterali corretti, ecco il file ladder.keyseseguito però 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                         \\...

Per provarlo (supponendo un nix con gli strumenti appropriati) prendere quanto sopra, eseguirlo xxd -re inserire il file ladder.keys. Crea un file ladder.txtcon un numero intero al suo interno. Quindi fa:

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

bash, 61

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

dov'è ^Mun ritorno letterale in carrozza

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

JavaScript (ES6), 79 byte

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

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

Funziona prendendo una serie di nspazi, quindi facendo una sostituzione esotica per ottenere la diapositiva con un supporto, quindi sostituendo il supporto con una scala.

Rubino, 61 byte

->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, "/" ]
  }
}

Potrei salvare due byte usando '%*s\ \^M%*s----/'(dove ^Mè un ritorno a capo letterale) per la stringa di formato, ma poi Ruby stampa l'avviso " warning: encountered \r in middle of line, treated as a mere space". ¯ \ _ (ツ) _ / ¯

Soluzione precedente (64 byte)

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

Lotto, 194 byte

@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%

Si è rivelato ragionevolmente semplice: rientrare la diapositiva, rimuovere i primi 7 caratteri, rientrare nella scala, rimuovere lo spazio iniziale. Quest'ultima parte implica un piccolo trucco!

Java, 116 byte

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

Sfortunatamente, non è possibile [facilmente] duplicare stringhe in Java, quindi finisco per abusare della funzione di formattazione.

Scala, 95 byte

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

Haskell, 81 byte

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

eacal , non competitivo, 386 byte

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

Ho reso ufficialmente il linguaggio più dettagliato possibile.Ho fatto il commento per scherzo e per sarcasmo. Per favore calmati. Istruzioni su come eseguire il repository github collegato nell'intestazione.

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