Votre travail consiste à recréer cette œuvre d'art:

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

La réponse doit recréer cela et l'imprimer en conséquence. Toutes les langues sont autorisées, aucune impression directe d'art, ofc, un certain niveau de manipulation est requis. La réponse avec le moins d'octets l'emporte.

Ferme le jeudi 6 h 30 UTC environ.

La chose originale m'a été montrée par mon ami qui a fait ça avec Java, il a refusé de me montrer le code source et maintenant je vais l'éblouir avec l'éclat d'autres langages éventuellement. :RÉ

Vous ne pouvez pas utiliser de caractère alternatif (le rend plus facile?).

Tableau actuel des leaders

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

Votes les plus élevés: C - 73 octets - Paul R

isaacg prend la couronne pour avoir réussi le Staircase Challenge avec Pyth. Méfiez-vous de plus de défis comme ceux-ci sur PPCG!

Pyth, 29 28

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

Essayez-le ici.

Une solution assez simple, avec l'astuce "ajouter cinq espaces ou cinq traits de soulignement" de la solution @ xnor, mais avec la boucle de 0 à 20, pas de 20 à 0.

C, 86 80 76 75 73 octets

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

Java, 198 158 156 146 octets

Cela peut probablement être beaucoup raccourci. Comme d'habitude, les suggestions sont les bienvenues.

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

En retrait (un peu):

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

Merci Martin Büttner, Rainbolt et Geobits.

Brainfuck (1065 octets)

Ce n'est pas joli, ce n'est pas court ... mais j'optimiserai plus tard!

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

CJam, 36 30 octets

Essayez-le en ligne.

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

Ma solution initiale de 36 octets a généré le résultat dans l'orientation de sortie. Malgré mes tentatives pour extraire plus d'octets de l'algorithme, je n'ai pas pu. Puis j'ai vu la brillante stratégie de Martin de générer des colonnes au lieu de lignes et de transposer le résultat. J'ai réalisé que c'était probablement une meilleure approche, alors j'ai décidé de créer une solution basée sur la transposition.

Cependant, mon approche de la mise en œuvre de cette stratégie varie beaucoup. Au lieu de générer des colonnes complètes, j'utilise une solution itérative qui indente toutes les «étapes» déjà générées et ajoute ajoute une nouvelle étape à chaque itération. La première itération de la boucle principale génère donc ceci:

 |||||
_
_
_
_
_

La deuxième itération de la boucle principale indente l'étape existante et en ajoute une nouvelle après celle-ci:

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

Et les cinq itérations complètes de la boucle principale génèrent ceci:

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

Après cela, tout ce qui doit être fait est d'éliminer la première ligne, qui autrement deviendrait la contremarche indésirable pour l'étape inférieure, et de transposer.

Python 2, 80 77 74 octets

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

Débarrassé du double execet tout ranger dans l'un print!

Clip, 46

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

Explication

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

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

Testez-le ici.

J'ai également essayé d'utiliser une formule explicite, mais c'est plus long dans CJam ... peut-être que cela aide quelqu'un d'autre:

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

Explication

J'ai trouvé que l'escalier peut être construit beaucoup plus facilement si vous a) transposez la grille et b) inversez les lignes:

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

Donc, je construis d'abord cela, puis je inverse, puis je transpose.

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

Les 21 lignes sont indexées par nin [20,19,...,1,0]. Imprime d'abord 6 espaces pour chaque "étape" vers le haut (moins 1), calculé comme n/5*6. Imprime ensuite cinq espaces, sauf que ceux-ci sont plutôt des traits de soulignement pour des multiples de cinq. Enfin, imprime une ligne verticale, à l'exception de la ligne supérieure n=20.

JavaScript, 115 107 96 94 89 87 83 octets

C'est trop long pour gagner, mais c'est la première fois que je trouve une réponse sur PCG.SE, et je suis un peu fier d'avoir fait quelque chose de postable.

Avec quelques conseils syntaxiques utiles, j'ai raccourci le code de manière significative - même en dessous du seuil de la barre de défilement!

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 octets

Un merci spécial à @ edc65 pour avoir vraiment retravaillé cela.

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 logique de la version originale vérifie @ edc65 commente son évolution.

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

J'ai le fort sentiment que MATLAB devrait pouvoir faire mieux, mais je ne vois pas de moyen.

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

Crée l'escalier à l'envers et le retourne. Mon thaumomètre s'est cassé à cause de toutes les constantes magiques autour.

'|'est intentionnellement laissé tel quel (au lieu du point de code ascii) pour initialiser pet wcomme un tableau de caractères.

Rubis, 48

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

Ancienne approche, 68

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

Julia, 83 octets

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

Dans Julia, la concaténation de chaînes est effectuée à l'aide de l' *opérateur et la répétition de chaînes est effectuée à l'aide de ^.

> <> , 108 104 100 octets

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

Une solution simple> <>, utilisant la même stratégie que ma réponse Python . La principale différence est que> <> n'a pas de multiplication de chaînes (ni même de chaînes), donc tout cela se fait avec des boucles.

Explication

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 octets

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

Je suis sûr que cela peut être réduit d'une manière ou d'une autre :) raccourci par @Score_Under

Perl, 50

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

Essayez- moi .

T-SQL, 276 octets

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 octets

n = nombre d'étapes

total de 175 caractères, mais a dû sortir dans un fichier pour s'afficher correctement - donc moins 43 caractères pour les opérations sur les fichiers = 132 caractères.

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)

Note au répondeur: le nombre d'octets est pour le code source de travail absolu, et le compteur d'octets indique que c'est 261 octets, donc c'est le cas.

Bash (+ tac de coreutils): 110 octets

Cela peut être collé directement dans le terminal.

(n =; set {1..4}; car je fais écho "$ {n} _____ |"; n + = ''; pour je fais écho "$ n |"; fait; n + = \; fait; écho " $ {n} _____ ") | tac

code machine x86, 48 octets

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

Équivalent du code d'assemblage:

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

Production:

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

Désolé que la sortie soit différente; J'espère que c'est acceptable.

Cela a été exécuté dans DOSBOX