Twoim zadaniem jest odtworzenie tego dzieła sztuki:

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

Odpowiedź musi go odtworzyć i wydrukować. Wszystkie języki dozwolone, nie wymaga bezpośredniego drukowania dzieł sztuki, ofc, wymagany jest pewien poziom manipulacji. Odpowiedź z najmniej bajtami wygrywa.

Zamknięte w czwartek o 6:30 lub mniej więcej UTC.

Oryginalna rzecz została mi pokazana przez mojego przyjaciela, który zrobił to z Javą, odmówił pokazania mi kodu źródłowego, a teraz oszołomię go błyskotliwością innych języków. :RE

Nie możesz użyć żadnej alternatywnej postaci (ułatwia to?).

Obecna tablica wyników

1. Pyth - 28 bajtów - isaacg
2. CJam - 30 bajtów - Runer112
3. CJam - 32 bajty - Martin Büttner

Najwyższe głosy: C - 73 bajty - Paul R.

isaacg przejmuje koronę za zaliczenie wyzwania schodowego z Pyth. Uważaj na więcej takich wyzwań w PPCG!

Pyth, 29 28

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

Wypróbuj tutaj.

Całkiem proste rozwiązanie z trikiem „dodaj pięć spacji lub pięć znaków podkreślenia” z rozwiązania @ xnor, ale z pętlą od 0 do 20, a nie od 20 do 0.

C, 86 80 76 75 73 bajtów

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

Java, 198 158 156 146 bajtów

Prawdopodobnie można to znacznie skrócić. Jak zwykle sugestie są mile widziane.

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

Wcięte (trochę):

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

Dzięki Martin Büttner, Rainbolt i Geobits.

Brainfuck (1065 bajtów)

To nie jest ładne, nie jest krótkie ... ale zoptymalizuję później!

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

CJam, 36 30 bajtów

Wypróbuj online.

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

Moje początkowe 36-bajtowe rozwiązanie wygenerowało wynik w orientacji wyjściowej. Mimo moich prób wyciśnięcia większej ilości bajtów z algorytmu, nie mogłem. Potem zobaczyłem genialną strategię Martina, polegającą na generowaniu kolumn zamiast wierszy i transponowaniu wyniku. Zdałem sobie sprawę, że to prawdopodobnie lepsze podejście, więc postanowiłem stworzyć rozwiązanie oparte na transpozycji.

Moje podejście do wdrażania tej strategii jest jednak dość zróżnicowane. Zamiast generować pełne kolumny, używam iteracyjnego rozwiązania, które wcina wszelkie już wygenerowane „kroki” i dodaje nowy krok przy każdej iteracji. Tak więc pierwsza iteracja głównej pętli generuje to:

 |||||
_
_
_
_
_

Druga iteracja głównej pętli wcina istniejący krok i dodaje nowy po nim:

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

A pełne pięć iteracji głównej pętli generuje to:

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

Po tym wszystkim, co trzeba zrobić, to wyeliminować pierwszą linię, która w przeciwnym razie stałaby się niechcianym pionem dla dolnego stopnia i transponowała.

Python 2, 80 77 74 bajtów

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

Pozbyłem się podwójnego execi zmieściłeś wszystko w jednym print!

Klip, 46

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

Wyjaśnienie

{               .- 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 bajtów

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

Sprawdź to tutaj.

Próbowałem także użyć jawnej formuły, ale jest ona dłuższa w CJam ... może pomaga komuś innemu:

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

Wyjaśnienie

Odkryłem, że schody można zbudować o wiele łatwiej, jeśli a) transponujesz siatkę i b) odwrócisz linie:

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

Najpierw buduję to, potem odwracam, a następnie transponuję.

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

W 21 linie są indeksowane nw [20,19,...,1,0]. Najpierw wypisuje 6 spacji dla każdego „kroku”, który osiągamy (minus 1), obliczonego jako n/5*6. Następnie drukuje pięć spacji, ale zamiast nich są to podkreślenia dla wielokrotności pięciu. Na koniec drukuje linię pionową, z wyjątkiem górnej linii n=20.

JavaScript, 115 107 96 94 89 87 83 bajtów

To zbyt długo, aby wygrać, ale po raz pierwszy wymyśliłem odpowiedź na PCG.SE i jestem dumny, że stworzyłem coś do wysłania.

Z kilkoma przydatnymi radami składniowymi znacznie skróciłem kod - nawet poniżej progu paska przewijania!

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 bajtów

Specjalne podziękowania dla @ edc65 za naprawę tego.

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>

Logika oryginalnej wersji sprawdź komentarz @ edc65, jak się zmieniła.

((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 bajtów

Mam silne przeczucie, że MATLAB powinien być w stanie radzić sobie lepiej, ale nie mogę wymyślić żadnego sposobu.

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

Tworzy schody do góry nogami i przewraca je. Mój taumometr zepsuł się z powodu wszystkich magicznych stałych wokół.

'|'jest celowo pozostawiony w stanie, w jakim się znajduje (zamiast ascii codepoint) w celu zainicjowania pi wjako tablica char.

Ruby, 48

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

Stare podejście, 68

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

Julia, 83 bajty

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

W Julii konkatenację łańcuchów wykonuje się za pomocą *operatora, a powtarzanie łańcuchów wykonuje się za pomocą ^.

> <> , 108 104 100 bajtów

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

Proste rozwiązanie> <>, wykorzystujące tę samą strategię, co moja odpowiedź w języku Python . Główną różnicą jest to, że> <> nie ma mnożenia łańcuchów (ani nawet łańcuchów), więc wszystko to odbywa się za pomocą pętli.

Wyjaśnienie

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 bajtów

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

Jestem całkiem pewien, że można to jakoś zmniejszyć :) skrócone o @Score_Under

Perl, 50

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

Spróbuj mnie .

T-SQL, 276 bajtów

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 bajtów

n = liczba kroków

w sumie 175 znaków, ale musiał poprawnie wyświetlać dane wyjściowe do pliku, więc minus 43 znaki dla operacji na plikach = 132 znaki.

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)

Uwaga dla odpowiadającego: Liczba bajtów dotyczy absolutnie działającego kodu źródłowego, a licznik bajtów mówi, że jest to 261 bajtów, więc tak jest.

Bash (+ tac z coreutils): 110 bajtów

Można to wkleić bezpośrednio do terminala.

(n =; set {1..4}; dla i do echa "$ {n} _____ |"; n + = ''; dla i do echa "$ n |"; gotowe; n + = \; gotowe; echo " $ {n} _____ ") | tac

kod maszynowy x86, 48 bajtów

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

Odpowiednik kodu zestawu:

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

Wynik:

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

Przepraszam, że wynik jest inny; Mam nadzieję, że jest to do przyjęcia.

Zostało to uruchomione w DOSBOX