Ваша робота полягає у відтворенні цього витвору мистецтва:

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

Відповідь має відтворити це і надрукувати це як результат. Усі мови дозволені, не потрібна пряма друк мистецтва, часто, певний рівень маніпуляцій. Відповідь з найменшими байтами виграє.

Закривається в четвер 6:30 ранку UTC або близько того.

Оригінальну річ мені показав мій друг, який це робив з Java, він відмовився показувати мені вихідний код, і тепер я засліплюю його блиску іншими мовами. : D

Ви не можете використовувати будь-який альтернативний символ (полегшує це?).

Поточна лідерська рада

1. Pyth - 28 байт - isaacg
2. CJam - 30 байт - Runer112
3. CJam - 32 байти - Мартін Бюттнер

Найвищі голоси: C - 73 байти - Paul R

isaacg бере корону для проходження Challenge Staircase with Pyth. Слідкуйте за такими викликами на PPCG!

Піта, 29 28

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

Спробуйте тут.

Досить просте рішення з фокусом "додавання п'яти пробілів або п'яти підкреслень" з рішення @ xnor, але з циклом від 0 до 20, а не від 20 до 0.

C, 86 80 76 75 73 байт

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 байт

Це, напевно, можна значно скоротити. Як завжди, пропозиції вітаються.

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

Відступ (свого роду):

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

Дякую Мартіну Бюттнеру, Rainbolt та Geobits.

Брейнфук (1065 байт)

Це не дуже, це не мало ... але я згодом оптимізую!

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

CJam, 36 30 байт

Спробуйте в Інтернеті.

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

Моє початкове 36-байтове рішення генерувало результат у вихідній орієнтації. Незважаючи на мої спроби видавити більше байтів з алгоритму, я не зміг. Тоді я побачив блискучу стратегію Мартіна - генерувати стовпці замість рядків та переносити результат. Я зрозумів, що це, мабуть, кращий підхід, і я взявся за створення рішення на основі транспозиції.

Однак мій підхід до реалізації цієї стратегії досить різниться. Замість того, щоб генерувати повні стовпці, я використовую ітеративне рішення, яке відступає від усіх вже створених "кроків" і додає додавання нового кроку при кожній ітерації. Отже, перша ітерація основного циклу породжує це:

 |||||
_
_
_
_
_

Друга ітерація основного циклу відступає від існуючого кроку та додає новий після нього:

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

І цілих п’ять ітерацій основного циклу генерують це:

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

Після цього все, що потрібно зробити, - це усунути перший рядок, який інакше став би небажаним стояком для нижнього кроку, і перемістити його.

Python 2, 80 77 74 байт

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

Позбувся подвійного execі помістив усе в одне print!

Кліп, 46

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

Пояснення

{               .- 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 байти

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

Тестуйте це тут.

Я також спробував використовувати явну формулу, але це більше в CJam ... можливо, це допомагає комусь іншому:

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

Пояснення

Я виявив, що сходи можна побудувати набагато простіше, якщо ви: a) перенесіть сітку та б) переверніть лінії:

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

Тож спочатку я будую це, потім реверсую, потім переношу.

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

Пітон 2, 59

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

21 рядок індексується nв [20,19,...,1,0]. Спочатку друкується 6 пробілів для кожного "кроку", який ми зробили (мінус 1), обчислюється як n/5*6. Потім виводиться п'ять пробілів, крім цього вони замість цього підкреслюють кратні п'ять. Нарешті, друкується вертикальна лінія, крім верхньої n=20.

JavaScript, 115 107 96 94 89 87 83 байт

Це занадто довго, щоб виграти, але вперше я придумав відповідь на PCG.SE, і я пишаюся тим, що зробив щось поштове.

За допомогою корисних синтаксичних порад я значно скоротив код - навіть нижче порогу прокрутки!

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 байт

Особлива подяка @ edc65 за те, що дійсно переробив це.

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>

Логіка оригінальної версії перевірити @ edc65 прокоментувати, як вона перетворилася.

((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 байт

У мене є сильне почуття, що MATLAB повинен вміти робити краще, але я не можу придумати спосіб.

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

Створює сходи догори дном і перевертає її. Мій таумометр зламався через усі магічні константи навколо.

'|'навмисно залишається як-є (замість кодової точки ascii) для ініціалізації pта wяк масив char.

Рубі, 48

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

Старий підхід, 68

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

Джулія, 83 байти

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

У Джулії конкатенація рядків виконується за допомогою *оператора, а повторення рядків виконується за допомогою ^.

> <> , 108 104 100 байт

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

Просте рішення, що використовує ту саму стратегію, що і моя відповідь Python . Основна відмінність полягає в тому, що у <<> немає множення рядків (або навіть рядків), тому все це робиться за допомогою циклів.

Пояснення

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 байт

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

Я впевнений, що це можна якось зменшити :) скорочено @Score_Under

Perl, 50

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

Спробуй мене .

T-SQL, 276 байт

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 байт

n = Кількість кроків

всього 175 символів, але довелося вивести файл у файл, щоб правильно відобразити - так мінус 43 символи для файлових операцій = 132 символів.

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)

Примітка до відповідача: кількість байтів - це абсолютний робочий вихідний код, а лічильник байтів говорить, що це 261 байт, так і є.

Bash (+ tac від coreutils): 110 байт

Це можна вставити безпосередньо в термінал.

(n =; встановити {1..4}; для я лунаю "$ {n} _____ |"; n + = ''; для я ехо "$ n |"; зроблено; n + = \; зроблено; відлуння " $ {n} _____ ") | такс

машинний код x86, 48 байт

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

Еквівалентний код складання:

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

Вихід:

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

Вибачте, що вихід відрізняється; Я сподіваюся, що це прийнятно.

Це було запущено в DOSBOX