Il tuo lavoro è ricreare quest'opera d'arte:

                        _____
                       |
                       |
                       |
                       |
                  _____| 
                 |
                 |
                 |
                 |
            _____|
           |
           |
           |
           |
      _____|
     |
     |
     |
     |
_____|

La risposta deve ricreare questo e stampare questo come risultato. Sono consentite tutte le lingue, nessuna stampa diretta di arte, spesso, un certo livello di manipolazione. Vince la risposta con il minor numero di byte.

Chiude giovedì 6:30 UTC o giù di lì.

La cosa originale mi è stata mostrata dal mio amico che ha fatto questo con Java, si è rifiutato di mostrarmi il codice sorgente e ora lo abbaglierò con lo splendore di altre lingue possibilmente. : D

Non puoi usare nessun personaggio alternativo (lo rende più facile?).

Classifica attuale

1. Pyth - 28 byte - isaacg
2. CJam - 30 byte - Runer112
3. CJam - 32 byte - Martin Büttner

Voti più alti: C - 73 byte - Paul R

isaacg prende la corona per aver superato la Staircase Challenge con Pyth. Fai attenzione a più sfide come queste su PPCG!

Pyth, 29 28

V21++**6/-20N5d*5?d%N5\_<\|N

Provalo qui.

Una soluzione piuttosto semplice, con il trucco "aggiungi cinque spazi o cinque trattini bassi" dalla soluzione di @ xnor, ma con il loop da 0 a 20, non da 20 a 0.

C, 86 80 76 75 73 byte

c;main(i){for(i=21;i--;c='|')printf("%*s%c\n",i/5*6+5,i%5?"":"_____",c);}

Java, 198 158 156 146 byte

Questo probabilmente può essere abbreviato molto. Come al solito, i suggerimenti sono ben accetti.

void a(){String a="",b="_____",c=b;for(int i=-1;i<20;b=i%5<1?b.replace(c,"     "):i%5>3?b+" "+c:b)a=b+(++i>19?"":"|")+"\n"+a;System.out.print(a);}

Rientrato (tipo):

void a(){
    String a="",b="_____",c=b;
    for(int i=-1;i<20;b=i%5<1?b.replace(c,"     "):i%5>3?b+" "+c:b)
        a=b+(++i>19?"":"|")+"\n"+a;
    System.out.print(a);
}

Grazie Martin Büttner, Rainbolt e Geobits.

Brainfuck (1065 byte)

Non è carino, non è breve ... ma lo ottimizzerò più avanti!

++++[->++++++++<]>........................
[->+++<]>-.....>++++++++++.[->+++<]>++....
...................-[->++++<]>.>++++++++++
.[->+++<]>++.......................-[->+++
+<]>.>++++++++++.[->+++<]>++..............
.........-[->++++<]>.>++++++++++.[->+++<]>
++.......................-[->++++<]>.>++++
++++++.[->+++<]>++..................[->+++
<]>-.....[->++++<]>.>++++++++++.[->+++<]>+
+.................-[->++++<]>.>++++++++++.
[->+++<]>++.................-[->++++<]>.>+
+++++++++.[->+++<]>++.................-[->
++++<]>.>++++++++++.[->+++<]>++...........
......-[->++++<]>.>++++++++++.[->+++<]>++.
...........[->+++<]>-.....[->++++<]>.>++++
++++++.[->+++<]>++...........-[->++++<]>.>
++++++++++.[->+++<]>++...........-[->++++<
]>.>++++++++++.[->+++<]>++...........-[->+
+++<]>.>++++++++++.[->+++<]>++...........-
[->++++<]>.>++++++++++.[->+++<]>++......[-
>+++<]>-.....[->++++<]>.>++++++++++.[->+++
<]>++.....-[->++++<]>.>++++++++++.[->+++<]
>++.....-[->++++<]>.>++++++++++.[->+++<]>+
+.....-[->++++<]>.>++++++++++.[->+++<]>++.
....-[->++++<]>.>++++++++++.[--->++<]>+++.
....[->++++<]>.

CJam, 36 30 byte

Provalo online.

L{{S5*\+}/S'|5*+]'_5*+}5*1>zN*

La mia soluzione iniziale a 36 byte ha generato il risultato nell'orientamento dell'output. Nonostante i miei tentativi di spremere più byte dall'algoritmo, non ci sono riuscito. Poi ho visto la brillante strategia di Martin di generare colonne anziché righe e trasporre il risultato. Mi sono reso conto che probabilmente era un approccio migliore, quindi ho iniziato a creare una soluzione basata sulla trasposizione.

Tuttavia, il mio approccio all'attuazione di tale strategia varia un po '. Invece di generare colonne complete, utilizzo una soluzione iterativa che rientra tutti i "passaggi" già generati e aggiunge un nuovo passaggio ad ogni iterazione. Quindi la prima iterazione del ciclo principale genera questo:

 |||||
_
_
_
_
_

La seconda iterazione del ciclo principale rientra il passaggio esistente e ne aggiunge uno nuovo dopo:

      |||||
     _
     _
     _
     _
     _
 |||||
_
_
_
_
_

E le cinque iterazioni complete del ciclo principale generano questo:

                     |||||
                    _
                    _
                    _
                    _
                    _
                |||||
               _
               _
               _
               _
               _
           |||||
          _
          _
          _
          _
          _
      |||||
     _
     _
     _
     _
     _
 |||||
_
_
_
_
_

Dopo ciò, tutto ciò che deve essere fatto è eliminare la prima linea, che altrimenti diventerebbe il montante indesiderato per il gradino inferiore e trasporre.

Python 2, 80 77 74 byte

n=24;exec"print' '*n+'_'*5+'|'*(n<24)+('\\n'+~-n*' '+'|')*4*(n>0);n-=6;"*5

Sbarazzati del doppio exece metti tutto in quello print!

Clip, 46

{:24S:5'_m[z{*4,:+5*6zS"|
":*6zS:5'_"|
"`}vR4`

Spiegazione

{               .- Put everything in a list -.
 :24S           .- 24 spaces                -.
 :5'_           .- 5 underscores            -.
 m[z            .- Map...                   -.
    {           .- A list                   -.
     *4         .- 4 of the following       -.
       ,        .- Append                   -.
        :+5*6zS .- 5 + 6 * the iteration of spaces  -.
        "|      .- A pipe and newline       -.
"
     :*6zS      .- 6 * the iteration of spaces      -.
     :5'_       .- 5 underscores            -.
     "|         .- A pipe and newline       -.
"
    `           .- End list (per iteration  -.
   }vR4         .- The mapping is onto {3,2,1,0}    -.

CJam, 36 32 byte

{5*S*'_+a5*~_W<S+5'|*+}5/;]W%zN*

Provalo qui.

Ho anche provato a usare una formula esplicita, ma è più lunga in CJam ... forse aiuta qualcun altro:

21,29,ff{_2$5/)6*(=@@6/5*=_++" |_|"=}W%N*

Spiegazione

Ho scoperto che la scala può essere costruita molto più facilmente se a) trasponi la griglia eb) inverti le linee:

_
_
_
_
_
 |||||
     _
     _
     _
     _
     _
      |||||
          _
          _
          _
          _
          _
           |||||
               _
               _
               _
               _
               _
                |||||
                    _
                    _
                    _
                    _
                    _

Quindi prima lo sto costruendo, poi invertendo, quindi trasponendo.

{                     }5/        "For i in [0 .. 4].";
 5*S*'_+                         "Get a string of 5*i spaces and append _.";
        a5*~                     "Get five such lines.";
            _W<S+                "Duplicate the last, remove the _, add a space.";
                 5'|*+           "Add 5 copies of |.";
                         ;       "The above creates a row too many, so discard the last one.";
                          ]W%zN* "Wrap everything in an array, reverse, transpose, riffle
                                  with newlines.";

Python 2, 59

n=21
exec"n-=1;print n/5*6*' '+' _'[n%5<1]*5+'|'*(n<20);"*n

Le 21 righe sono indicizzate da nin [20,19,...,1,0]. Prima stampa 6 spazi per ogni "passo" che ci troviamo su (meno 1), calcolato come n/5*6. Quindi, stampa cinque spazi, tranne per il fatto che questi sono invece trattini bassi per multipli di cinque. Infine, stampa una linea verticale, ad eccezione della linea superiore n=20.

JavaScript, 115 107 96 94 89 87 83 byte

È troppo lungo per vincere, ma è la prima volta che mi viene in mente una risposta su PCG.SE, e sono orgoglioso di aver reso qualcosa di postabile.

Con alcuni utili consigli sintattici ho abbreviato il codice in modo significativo, anche al di sotto della soglia della barra di scorrimento!

for(s='',y=22;--y;s+='\n')for(x=0;++x<29;)s+=6*~(~-y/5)-~x?4+5*~(x/6)+y?' ':'_':'|'

ECMAScript 6, 142 138 129 91 byte

Un ringraziamento speciale a @ edc65 per averlo davvero rielaborato.

a=o='',[for(x of!0+o)(o=(a+'     |\n').repeat(4)+a+'_____|\n'+o,a+='      ')],a+'_____\n'+o

out.value=(a=o='',[for(x of!0+o)(o=(a+'     |\n').repeat(4)+a+'_____|\n'+o,a+='      ')],a+'_____\n'+o)

textarea{
  width:300px;
  height:400px;
}

<textarea id="out";></textarea>

La logica della versione originale controlla il commento @ edc65 per come si è trasformato.

((f,l,p)=>                  //variables
f(24)+l+p[1]+               //add the non pattern line
[0,1,2,3].map(b=>f(18-6*b)) //add the right number of spaces in front of the 4 steps
.map((a,b)=>f(4,a+f(5)+p)   //the four repeating lines of the step 
+a+l)                       //the landing line
.join(p)+p)                 //put it all together
((n,s=' ')=>s.repeat(n)     //create an variable array of some character
,'_____','|\n')             //string literals

MATLAB, 68 byte

Ho la forte sensazione che MATLAB dovrebbe essere in grado di fare meglio, ma non riesco a pensare a un modo.

p(1:5,6)='|';p(1,1:5)=95;w=blkdiag(p,p,p,p);w(21,25:29)=95;flipud(w)

Crea le scale sottosopra e le capovolge. Il mio taumometro si è rotto a causa di tutte le costanti magiche intorno.

'|'viene lasciato intenzionalmente così com'è (invece del punto di codice ASCII) da inizializzare pe wcome array di caratteri.

Ruby, 48

25.times{|i|puts" "*(4-i/6)*5+(i%6==0??_*5:?|)}

Vecchio approccio, 68

4.times{|i|(?_*5+"
|"*5).each_line{|l|puts" "*(4-i)*5+l}}
puts"_"*5

Julia, 83 byte

for n=24:-6:0 print(" "^n*"_"^5*"|"^(n<24)*"\n"*(" "^(n>0?n-1:0)*"|\n"^(n>0))^4)end

In Julia, la concatenazione di stringhe viene eseguita utilizzando l' *operatore e la ripetizione di stringa viene eseguita utilizzando ^.

> <> , 108 104 100 byte

cc+::?v~'_____'o\/' 'o  \
?:o'|'\' 'o1-30.o\v!?:-1<}:{oav!?:<4;!
-20.12^?(+cc:ooo/ \~1-'!|'o1. \~ao6

Una soluzione> <> semplice, usando la stessa strategia della mia risposta Python . La differenza principale è che> <> non ha una moltiplicazione di stringhe (o persino stringhe), quindi tutto ciò viene fatto con loop.

Spiegazione

cc+                  Push 24 (call this "n")

[outer loop]
[loop 1, print n spaces]

:                    Copy n (call this "i")
:?                   If i is not zero...
' 'o1-30.                Print space, decrement i and go to start of loop 1

~'_____'ooooo        Pop i and print five underscores
:cc+(?               If n < 24...
'|'o                     Print a pipe
21.                  Otherwise skip pipe printing

[loop 2: print vertical parts of stairs]

?!;                  If n is zero, halt
4                    Push 4 (call this "j")
?!                   If j is zero...
~ao6-20.                 Pop j, print a newline, minus 6 from n and go to start of outer loop
ao                   Print a newline
}:{                  Copy n (call this "k")

[loop 3: print n-1 spaces]

1-                   Decrement k
:?!                  If k is zero...
    ~1-'!|'o1.           Pop k, decrement j, print a pipe and go to start of loop 2
' 'o                 Otherwise print a space and go to start of loop 3

Groovy, 98 71 byte

// old: (25..5).each{i->println((1..(i-(i-1)%5)).collect{' '}.join()+(i%5?'|':('_____'+(i==25?'':'|'))))}

(25..5).each{i->println(' '*(i-(i-1)%5)+(i%5?'|':'_'*5+(i%25?'|':'')))}

(25..5).each { i ->
    println(
        ' '*(i - (i - 1) % 5) + (
            i % 5 ? 
            '|' : 
            '_'*5 + (i % 25 ? '|' : '')
        )
    )
}    

Sono abbastanza sicuro, che può essere ridotto in qualche modo :) abbreviato da @Score_Under

Perl, 50

#!perl -l
print$"x6x(-$_/5),($_%5?$":_)x5,"|"x$|++for-20..0

Prova a me .

T-SQL, 276 byte

declare @x int declare @y int declare @w varchar(30) declare @l char(5) set @l='_____' set @x=23 while @x > 4 begin set @w=replicate(' ',@x) set @y=0 if @x=23 print @w+' '+@l else print @w+' '+@l+'|' while @y < 4 begin set @y=1+@y print @w+'|' end set @x=@x-6 end print @l+'|'

Visual FoxPro 9.0, 261 byte

n = Numero di passaggi

totale di 175 caratteri, ma è stato necessario eseguire l'output sul file per visualizzarlo correttamente, quindi meno 43 caratteri per le operazioni sui file = 132 caratteri.

n=10
c=CHR(13)
f="st.t"
ERAS (f)    
FOR i=n TO 1 STEP -1
    p=(i-1)*6
    =STRTO(PADL("_____",p+5)+IIF(i<n,"|","")+c+IIF(i>1,REPLI(PADL("|"+c,p+1),4),""),f,.t.)
    ?PADL("_____",p+5)+IIF(i<n,"|","")+c+IIF(i>1,REPLI(PADL("|"+c,p+1),4),"")
ENDFOR
MODI COMM (f)

Nota per il risponditore: il conteggio dei byte è per il codice sorgente di lavoro assoluto e il contatore di byte indica che è 261 byte, quindi lo è.

Bash (+ tac da coreutils): 110 byte

Questo può essere incollato direttamente nel terminale.

(n =; imposta {1..4}; per l'eco "$ {n} _____ |"; n + = ''; per l'eco "$ n |"; fatto; n + = \; fatto; echo " $ {} n _____ ") | tac

codice macchina x86, 48 byte

B1 05 B4 0E 80 E9 01 B0 5F B5 05 80 ED 01 CD 10 80 FD 00 75 F6 B5 05 80 ED 01 B0 0A CD 10 B0 08 CD 10 B0 7C CD 10 80 FD 00 75 EC 80 F9 00 75 D4

Codice equivalente assemblaggio:

mov cl, 5
mov ah, 0Eh
main:
    sub cl, 1

print_step:
    mov al, '_'
    mov ch, 5

.loop:
    sub ch, 1

    int 10h

    cmp ch, 0
    jne .loop

print_stoop:
    mov ch, 5

.loop:
    sub ch, 1

    mov al, 0Ah;    ascii newline
    int 10h

    mov al, 8;      ascii backspace
    int 10h

    mov al, '|'
    int 10h

    cmp ch, 0
    jne .loop

cmp cl, 0
jne main

Produzione:

_____
    |
    |
    |
    |
    |_____
         |
         |
         |
         |
         |_____
              |
              |
              |
              |
              |_____
                   |
                   |
                   |
                   |
                   |_____
                        |
                        |
                        |
                        |
                        |

Mi dispiace che l'output sia diverso; Spero sia accettabile

Questo è stato eseguito in DOSBOX