Tu trabajo es recrear esta obra de arte:

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

La respuesta debe recrear esto e imprimir esto como resultado. Todos los idiomas están permitidos, no se requiere impresión directa de arte, ofc, se requiere algún nivel de manipulación. La respuesta con la menor cantidad de bytes gana.

Cierra el jueves a las 6:30 a.m. UTC más o menos.

Mi amigo, que hizo esto con Java, me mostró lo original, se negó a mostrarme el código fuente y ahora posiblemente lo deslumbraré con la brillantez de otros idiomas. :RE

No puede usar ningún personaje alternativo (¿lo hace más fácil?).

Tabla de líderes actual

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

Mayores votos: C - 73 bytes - Paul R

isaacg se lleva la corona por pasar el desafío de la escalera con Pyth. ¡Cuidado con más desafíos como estos en PPCG!

Pyth, 29 28

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

Pruébalo aquí

Una solución bastante sencilla, con el truco "agregar cinco espacios o cinco guiones bajos" de la solución de @ xnor, pero con el bucle de 0 a 20, no 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 146 bytes

Esto probablemente se puede acortar mucho. Como de costumbre, las sugerencias son bienvenidas.

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

Sangrado (un poco):

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

Gracias Martin Büttner, Rainbolt y Geobits.

Brainfuck (1065 bytes)

No es bonito, no es corto ... ¡pero lo optimizaré más adelante!

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

CJam, 36 30 bytes

Pruébalo en línea.

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

Mi solución inicial de 36 bytes generó el resultado en la orientación de salida. A pesar de mis intentos de exprimir más bytes del algoritmo, no pude. Entonces vi la brillante estrategia de Martin de generar columnas en lugar de filas y transponer el resultado. Me di cuenta de que probablemente era un mejor enfoque, así que partí para crear una solución basada en la transposición.

Sin embargo, mi enfoque para implementar esa estrategia varía bastante. En lugar de generar columnas completas, uso una solución iterativa que sangra cualquier "paso" ya generado y agrega agrega un nuevo paso en cada iteración. Entonces, la primera iteración del bucle principal genera esto:

 |||||
_
_
_
_
_

La segunda iteración del bucle principal sangra el paso existente y agrega uno nuevo después:

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

Y las cinco iteraciones completas del bucle principal generan esto:

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

Después de esto, todo lo que hay que hacer es eliminar la primera línea, que de lo contrario se convertiría en el elevador no deseado para el paso inferior, y transponer.

Python 2, 80 77 74 bytes

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

¡Eliminé el doble execy encajé todo en uno print!

Clip, 46

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

Explicación

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

Pruébalo aquí.

También intenté usar una fórmula explícita, pero es más larga en CJam ... tal vez ayude a alguien más:

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

Explicación

Descubrí que la escalera se puede construir mucho más fácilmente si a) transpone la cuadrícula yb) invierte las líneas:

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

Así que primero estoy construyendo eso, luego revertir, luego transponer.

{                     }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.";

Pitón 2, 59

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

Las 21 líneas están indexadas por nin [20,19,...,1,0]. Primero imprime 6 espacios para cada "paso" que estamos arriba (menos 1), calculado como n/5*6. Luego, imprime cinco espacios, excepto que estos son guiones bajos para múltiplos de cinco. Finalmente, imprime una línea vertical, excepto la línea superior n=20.

JavaScript, 115 107 96 94 89 87 83 bytes

Esto es demasiado largo para ganar, pero es la primera vez que encuentro una respuesta en PCG.SE, y estoy un poco orgulloso de haber hecho algo posible.

Con algunos consejos sintácticos útiles, acorté el código significativamente, ¡incluso por debajo del umbral de la barra de desplazamiento!

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

Un agradecimiento especial a @ edc65 por realmente reelaborar esto.

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 lógica de la versión original revisa el comentario @ edc65 sobre cómo se transformó.

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

Tengo la fuerte sensación de que MATLAB debería poder hacerlo mejor, pero no puedo pensar en una manera.

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

Crea las escaleras al revés y las voltea. Mi taumómetro se rompió debido a todas las constantes mágicas alrededor.

'|'se deja intencionalmente como está (en lugar de punto de código ascii) para inicializar py wcomo una matriz de caracteres.

Rubí, 48

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

Enfoque antiguo, 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

En Julia, la concatenación de cadenas se realiza con el *operador y la repetición de cadenas con ^.

> <> , 108 104 100 bytes

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

Una solución simple> <>, usando la misma estrategia que mi respuesta de Python . La principal diferencia es que> <> no tiene multiplicación de cadenas (o incluso cadenas), por lo que todo eso se hace con bucles.

Explicación

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

Estoy bastante seguro de que se puede reducir de alguna manera :) acortado por @Score_Under

Perl, 50

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

Trate de mí .

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 pasos

total de 175 caracteres, pero tuvo que salir al archivo para mostrar correctamente, por lo que menos 43 caracteres para operaciones de archivo = 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 el respondedor: el recuento de bytes es para el código fuente de trabajo absoluto, y el contador de bytes dice que son 261 bytes, por lo que es así.

Bash (+ tac de coreutils): 110 bytes

Esto se puede pegar directamente en la terminal.

(n =; set {1..4}; porque sí echo "$ {n} _____ |"; n + = ''; porque sí echo "$ n |"; hecho; n + = \; hecho; 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 ensamblaje 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

Salida:

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

Lamento que la salida sea diferente; Espero que sea aceptable.

Esto se ejecutó en DOSBOX