Seu trabalho é recriar esta obra de arte:

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

A resposta deve recriar isso e imprimi-lo como resultado. Todos os idiomas são permitidos, nenhuma impressão direta de arte, ofc, é necessário algum nível de manipulação. A resposta com o mínimo de bytes vence.

Fecha na quinta-feira às 06:30 UTC ou mais.

A coisa original foi mostrada para mim pelo meu amigo que fez isso com Java, ele se recusou a me mostrar o código-fonte e agora vou deslumbrá-lo com o brilho de outras linguagens. : D

Você não pode usar nenhum caractere alternativo (facilita isso?).

Quadro de líderes atual

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

Votos mais altos: C - 73 bytes - Paul R

isaacg leva a coroa por passar no Staircase Challenge com Pyth. Fique atento a mais desafios como estes no PPCG!

Pyth, 29 28

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

Experimente aqui.

Uma solução bastante direta, com o truque "acrescentar cinco espaços ou cinco sublinhados" da solução do @ xnor, mas com o loop de 0 a 20, não de 20 a 0.

C, 86 80 76 75 73 bytes

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

Java, 198 158 156 156 146 bytes

Provavelmente isso pode ser muito reduzido. Como sempre, sugestões são bem-vindas.

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

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

Obrigado Martin Büttner, Rainbolt e Geobits.

Brainfuck (1065 bytes)

Não é bonito, não é curto ... mas vou otimizar mais tarde!

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

CJam, 36 30 bytes

Experimente online.

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

Minha solução inicial de 36 bytes gerou o resultado na orientação da saída. Apesar de minhas tentativas de extrair mais bytes do algoritmo, não consegui. Então vi a brilhante estratégia de Martin de gerar colunas em vez de linhas e transpor o resultado. Percebi que provavelmente era uma abordagem melhor, então parti para criar uma solução baseada em transposição.

No entanto, minha abordagem para implementar essa estratégia varia bastante. Em vez de gerar colunas completas, eu uso uma solução iterativa que recua as "etapas" já geradas e adiciona uma nova etapa a cada iteração. Portanto, a primeira iteração do loop principal gera isso:

 |||||
_
_
_
_
_

A segunda iteração do loop principal recua a etapa existente e adiciona uma nova após:

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

E as cinco iterações completas do loop principal geram isso:

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

Depois disso, tudo o que precisa ser feito é eliminar a primeira linha, que de outra forma se tornaria o riser indesejado para a etapa inferior e transpor.

Python 2, 80 77 74 bytes

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

Livre-se do duplo exece encaixe tudo nele print!

Clip, 46

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

Explicação

{               .- 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 bytes

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

Teste aqui.

Eu também tentei usar uma fórmula explícita, mas é mais longa no CJam ... talvez ajude alguém:

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

Explicação

Descobri que a escada pode ser construída com muito mais facilidade se você a) transpuser a grade eb) inverter as linhas:

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

Então, primeiro estou construindo isso, depois invertendo e depois transpondo.

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

As 21 linhas são indexadas por nin [20,19,...,1,0]. Primeiro imprime 6 espaços para cada "passo" que subimos (menos 1), calculado como n/5*6. Em seguida, imprime cinco espaços, exceto que, em vez disso, são sublinhados para múltiplos de cinco. Por fim, imprime uma linha vertical, exceto a linha superior n=20.

JavaScript, 115 107 96 94 89 87 83 bytes

É muito longo para ganhar, mas é a primeira vez que recebo uma resposta no PCG.SE e estou orgulhoso de ter feito algo postável.

Com alguns conselhos sintáticos úteis, reduzi o código significativamente - mesmo abaixo do limite da barra de rolagem!

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 bytes

Agradecimentos especiais a @ edc65 por realmente reformular isso.

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>

A lógica da versão original, verifique o comentário @ edc65 para saber como se transformou.

((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 bytes

Tenho a forte sensação de que o MATLAB deve fazer melhor, mas não consigo pensar em uma maneira.

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

Cria as escadas de cabeça para baixo e vira-as. Meu thaumometer quebrou por causa de todas as constantes mágicas ao redor.

'|'é intencionalmente deixado como está (em vez do ponto de código ascii) para inicializar pe wcomo uma matriz de caracteres.

Ruby, 48

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

Abordagem antiga, 68

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

Julia, 83 bytes

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

Em Julia, a concatenação de sequência é realizada usando o *operador e a repetição de sequência é realizada usando ^.

> <> , 108 104 100 bytes

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

Uma solução>> simples, usando a mesma estratégia da minha resposta em Python . A principal diferença é que> <> não possui multiplicação de strings (ou mesmo strings), então tudo isso é feito com loops.

Explicação

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 bytes

// 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 ? '|' : '')
        )
    )
}    

Tenho certeza de que pode ser reduzido de alguma forma :) abreviado por @Score_Under

Perl, 50

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

Experimente- me .

T-SQL, 276 bytes

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 bytes

n = número de etapas

total de 175 caracteres, mas teve que gerar um arquivo para exibir corretamente - menos 43 caracteres para operações de arquivo = 132 caracteres.

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 para o respondente: A contagem de bytes é para o código fonte absoluto em funcionamento, e o contador de bytes diz que são 261 bytes, por isso é.

Bash (+ tac de coreutils): 110 bytes

Isso pode ser colado diretamente no terminal.

(n =; defina {1..4}; para eu fazer eco de "$ {n} _____ |"; n + = ''; para eu fazer eco de "$ n |"; pronto; n + = \; pronto; eco " $ {n} _____ ") | tac

código de máquina x86, 48 bytes

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

Código de montagem equivalente:

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

Saída:

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

Desculpe a saída ser diferente; Espero que seja aceitável.

Isso foi executado no DOSBOX