Ваша работа - воссоздать это произведение искусства:

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

Ответ должен воссоздать это и распечатать в результате. Все языки разрешены, прямая печать произведений искусства, ofc, некий уровень манипуляции не требуется. Ответ с наименьшим количеством байтов выигрывает.

Закрытие в четверг в 6:30 утра по Гринвичу или около того.

Оригинальную вещь мне показал мой друг, который делал это с Java, он отказался показывать мне исходный код, и теперь я, возможно, ослеплю его великолепием других языков. : D

Вы не можете использовать любой альтернативный символ (облегчает?).

Текущий список лидеров

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

Наивысшие голоса: C - 73 байта - Paul R

Исаак берет корону за прохождение Лестницы с Питом. Следите за новыми проблемами на 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);}

Ява, 198 158 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);
}

Спасибо Мартин Бюттнер, Рейнболт и Геобитс.

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

объяснение

Я обнаружил, что лестница может быть построена намного легче, если вы а) транспонируете сетку и б) переставляете линии:

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

Итак, сначала я это строю, потом наоборот, потом транспонирую.

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

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>

Логика оригинальной версии check @ 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как массив символов.

Руби, 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

В Julia конкатенация строк выполняется с помощью *оператора, а повторение строк - с помощью ^.

> <> , 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 + = \; сделано; эхо " $ {п} _____ ") | нолики

машинный код 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