Ihre Arbeit besteht darin, dieses Kunstwerk nachzubauen:

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

Die Antwort muss dies neu erstellen und als Ergebnis ausdrucken. Alle Sprachen erlaubt, kein direkter Druck von Kunstwerken, ofc, ein gewisses Maß an Manipulation ist erforderlich. Die Antwort mit den wenigsten Bytes gewinnt.

Schließt am Donnerstag, 6.30 Uhr UTC oder so.

Das Original wurde mir von meinem Freund gezeigt, der dies mit Java getan hat. Er weigerte sich, mir den Quellcode zu zeigen, und jetzt werde ich ihn möglicherweise mit der Brillanz anderer Sprachen blenden. : D

Sie können keine alternativen Zeichen verwenden (macht es einfacher?).

Aktuelle Rangliste

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

Höchste Stimmen: C - 73 Bytes - Paul R

isaacg erhält die krone, um die treppenhaus-herausforderung mit pyth zu bestehen. Achten Sie auf weitere Herausforderungen wie diese bei PPCG!

Pyth, 29 28

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

Probieren Sie es hier aus.

Eine ziemlich einfache Lösung, mit dem Trick "Fünf Leerzeichen oder fünf Unterstriche anhängen" aus der Lösung von @ xnor, aber mit der Schleife von 0 bis 20, nicht 20 bis 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

Dies kann wahrscheinlich viel verkürzt werden. Vorschläge sind wie immer willkommen.

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

Eingerückt (irgendwie):

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

Vielen Dank an Martin Büttner, Rainbolt und Geobits.

Brainfuck (1065 Bytes)

Es ist nicht schön, es ist nicht kurz ... aber ich werde später optimieren!

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

CJam, 36 30 Bytes

Probieren Sie es online aus.

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

Meine anfängliche 36-Byte-Lösung erzeugte das Ergebnis in der Ausgabeorientierung. Trotz meiner Versuche, mehr Bytes aus dem Algorithmus herauszuholen, konnte ich nicht. Dann sah ich Martins brillante Strategie, Spalten statt Zeilen zu generieren und das Ergebnis zu transponieren. Ich erkannte, dass dies wahrscheinlich ein besserer Ansatz war, und machte mich auf den Weg, um eine transpositionsbasierte Lösung zu finden.

Mein Ansatz zur Umsetzung dieser Strategie ist jedoch sehr unterschiedlich. Anstatt vollständige Spalten zu generieren, verwende ich eine iterative Lösung, die alle bereits generierten "Schritte" einrückt und bei jeder Iteration einen neuen Schritt hinzufügt. Die erste Iteration der Hauptschleife generiert also Folgendes:

 |||||
_
_
_
_
_

Die zweite Iteration der Hauptschleife rückt den vorhandenen Schritt ein und fügt einen neuen hinzu:

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

Und die vollen fünf Iterationen der Hauptschleife erzeugen dies:

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

Danach muss nur noch die erste Zeile entfernt werden, die andernfalls zum unerwünschten Riser für die unterste Stufe werden würde, und transponiert werden.

Python 2, 80 77 74 Bytes

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

Hab das Doppel los execund passe alles in das eine print!

Clip, 46

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

Erläuterung

{               .- 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 es hier.

Ich habe auch versucht, eine explizite Formel zu verwenden, aber diese ist in CJam länger ... Vielleicht hilft sie jemand anderem:

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

Erläuterung

Ich habe festgestellt, dass die Treppe viel einfacher gebaut werden kann, wenn Sie a) das Raster vertauschen und b) die Linien umkehren:

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

Also erst baue ich das, dann umkehren, dann transponieren.

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

Die 21 Zeilen sind mit nin indiziert [20,19,...,1,0]. Zuerst werden 6 Leerzeichen für jeden "Schritt" ausgegeben (minus 1), berechnet als n/5*6. Anschließend werden fünf Leerzeichen gedruckt, mit der Ausnahme, dass dies stattdessen Unterstriche für Vielfache von fünf sind. Zum Schluss wird eine vertikale Linie mit Ausnahme der obersten Linie gedruckt n=20.

JavaScript, 115 107 96 94 89 87 83 Bytes

Das ist zu lang, um zu gewinnen, aber es ist das erste Mal, dass ich auf PCG.SE eine Antwort finde, und ich bin irgendwie stolz darauf, etwas Postfähiges gemacht zu haben.

Mit hilfreichen syntaktischen Ratschlägen habe ich den Code erheblich verkürzt - sogar unterhalb der Bildlaufleistenschwelle!

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

Besonderer Dank geht an @ edc65 für die Überarbeitung.

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>

Die Logik der Originalversion überprüft den @ edc65-Kommentar auf seine Verwandlung.

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

Ich habe das starke Gefühl, dass MATLAB es besser machen sollte, aber mir fällt kein Weg ein.

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

Erstellt die Treppe kopfüber und dreht sie um. Mein Thaumometer ist wegen all der magischen Konstanten kaputt gegangen.

'|'wird absichtlich unverändert gelassen (anstelle des ASCII-Codepunkts), um es zu initialisieren pund wals Zeichen-Array.

Rubin, 48

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

Alter Ansatz, 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

In Julia wird die Verkettung von Zeichenfolgen mithilfe des *Operators und die Wiederholung von Zeichenfolgen mithilfe von ausgeführt ^.

> <> , 108 104 100 Bytes

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

Eine einfache> <> Lösung, die dieselbe Strategie wie meine Python-Antwort verwendet . Der Hauptunterschied besteht darin, dass> <> keine String-Multiplikation (oder gar Strings) hat. All dies geschieht also mit Schleifen.

Erläuterung

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

Ich bin mir ziemlich sicher, dass es irgendwie reduziert werden kann :) verkürzt durch @Score_Under

Perl, 50

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

Versuch es mit mir .

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 Byte

n = Anzahl der Schritte

Insgesamt 175 Zeichen, musste aber in eine Datei ausgegeben werden, um korrekt angezeigt zu werden - also minus 43 Zeichen für Dateioperationen = 132 Zeichen.

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)

Hinweis für den Antwortenden: Die Byteanzahl gilt für den absolut funktionierenden Quellcode, und der Byteanzahler gibt an, dass es sich um 261 Bytes handelt.

Bash (+ Tac von Coreutils): 110 Bytes

Dies kann direkt in das Terminal eingefügt werden.

(n =; setze {1..4}; für das Echo "$ {n} _____ |"; n + = ''; für das Echo "$ n |"; erledigt; n + = \; erledigt; Echo " $ {n} _____ ") | tac

x86-Maschinencode, 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

Assemblercode-Äquivalent:

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

Ausgabe:

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

Tut mir leid, dass die Ausgabe anders ist. Ich hoffe es ist akzeptabel.

Dies wurde in DOSBOX ausgeführt