Công việc của bạn là tái tạo tác phẩm nghệ thuật này:

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

Câu trả lời phải tạo lại điều này và in kết quả này. Tất cả các ngôn ngữ được phép, không in trực tiếp nghệ thuật, ofc, một số mức độ thao tác được yêu cầu. Câu trả lời với ít byte nhất sẽ thắng.

Đóng cửa vào Thứ Năm 6:30 AM UTC hoặc hơn.

Điều ban đầu được chỉ ra cho tôi bởi người bạn của tôi đã làm điều này với Java, anh ta từ chối cho tôi xem mã nguồn và bây giờ tôi sẽ làm cho anh ta lóa mắt với sự thông minh của các ngôn ngữ khác. : D

Bạn không thể sử dụng bất kỳ ký tự thay thế nào (làm cho nó dễ dàng hơn?).

Ban lãnh đạo hiện tại

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

Số phiếu cao nhất: C - 73 byte - Paul R

isaacg giành vương miện để vượt qua Thử thách cầu thang với Pyth. Xem ra cho nhiều thách thức như thế này trên PPCG!

Bình thường, 29 28

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

Hãy thử nó ở đây.

Một giải pháp khá đơn giản, với thủ thuật "nối năm dấu cách hoặc năm dấu gạch dưới" từ giải pháp của @ xnor, nhưng với vòng lặp từ 0 đến 20, không phải từ 20 đến 0.

C, 86 80 76 75 73 byte

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

Java, 198 158 156 146 byte

Điều này có lẽ có thể được rút ngắn rất nhiều. Như thường lệ, đề xuất được chào đón.

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

Thụt lề (kinda):

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

Cảm ơn Martin Büttner, Rainbolt và Geobits.

Brainfuck (1065 byte)

Nó không đẹp, nó không ngắn ... nhưng tôi sẽ tối ưu hóa sau này!

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

CJam, 36 30 byte

Hãy thử trực tuyến.

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

Giải pháp 36 byte ban đầu của tôi tạo ra kết quả theo hướng đầu ra. Mặc dù tôi đã cố gắng thu thập nhiều byte hơn từ thuật toán, tôi không thể. Sau đó, tôi thấy chiến lược tuyệt vời của Martin là tạo các cột thay vì các hàng và hoán chuyển kết quả. Tôi nhận ra rằng đó có lẽ là một cách tiếp cận tốt hơn, vì vậy tôi đã bắt đầu tạo ra một giải pháp dựa trên chuyển vị.

Tuy nhiên, cách tiếp cận của tôi để thực hiện chiến lược đó thay đổi khá nhiều. Thay vì tạo các cột đầy đủ, tôi sử dụng một giải pháp lặp để thụt vào bất kỳ "bước" nào đã được tạo và thêm các bước mới vào mỗi lần lặp. Vì vậy, lần lặp đầu tiên của vòng lặp chính tạo ra điều này:

 |||||
_
_
_
_
_

Lặp lại thứ hai của vòng lặp chính thụt vào bước hiện có và thêm một bước mới sau nó:

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

Và năm lần lặp đầy đủ của vòng lặp chính tạo ra điều này:

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

Sau này, tất cả những gì cần làm là loại bỏ dòng đầu tiên, nếu không sẽ trở thành riser không mong muốn cho bước dưới cùng và chuyển vị.

Python 2, 80 77 74 byte

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

Loại bỏ gấp đôi execvà phù hợp với tất cả mọi thứ vào một print!

Clip, 46

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

Giải trình

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

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

Kiểm tra nó ở đây.

Tôi cũng đã thử sử dụng một công thức rõ ràng, nhưng nó dài hơn ở CJam ... có lẽ nó giúp người khác:

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

Giải trình

Tôi thấy rằng cầu thang có thể được xây dựng dễ dàng hơn nhiều nếu bạn a) hoán đổi lưới và b) đảo ngược các dòng:

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

Vì vậy, đầu tiên tôi đang xây dựng nó, sau đó đảo ngược, sau đó chuyển vị.

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

Con trăn 2, 59

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

21 dòng được lập chỉ mục bởi ntrong [20,19,...,1,0]. Đầu tiên in 6 khoảng trắng cho mỗi "bước" chúng tôi lên (trừ 1), được tính là n/5*6. Sau đó, in năm khoảng trắng, ngoại trừ những khoảng này thay vào đó là dấu gạch dưới cho bội số của năm. Cuối cùng, in một dòng dọc, ngoại trừ dòng trên cùng n=20.

JavaScript, 115 107 96 94 89 87 83 byte

Điều này quá dài để giành chiến thắng, nhưng đây là lần đầu tiên tôi đưa ra câu trả lời trên PCG.SE, và tôi rất tự hào đã làm được điều gì đó có thể đăng được.

Với một số lời khuyên cú pháp hữu ích, tôi đã rút ngắn mã đáng kể - ngay cả dưới ngưỡng thanh cuộn!

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 byte

Đặc biệt cảm ơn @ edc65 vì đã thực sự làm lại điều này.

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>

Logic của phiên bản gốc kiểm tra @ edc65 nhận xét về cách nó biến đổi.

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

Tôi có cảm giác mạnh mẽ MATLAB sẽ có thể làm tốt hơn, nhưng tôi không thể nghĩ ra cách nào.

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

Tạo cầu thang lộn ngược và lật nó. Máy đo tốc độ của tôi bị vỡ vì tất cả các hằng số ma thuật xung quanh.

'|'được cố ý để nguyên trạng (thay vì mã hóa ascii) để khởi tạo pvà wnhư một mảng char.

Ruby, 48

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

Cách tiếp cận cũ, 68

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

Julia, 83 byte

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

Trong Julia, nối chuỗi được thực hiện bằng *toán tử và lặp lại chuỗi được thực hiện bằng cách sử dụng ^.

> <> , 108 104 100 byte

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

Một giải pháp> <> đơn giản, sử dụng chiến lược giống như câu trả lời Python của tôi . Sự khác biệt chính là> <> không có phép nhân chuỗi (hoặc thậm chí chuỗi), vì vậy tất cả điều đó được thực hiện bằng các vòng lặp.

Giải trình

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 byte

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

Tôi khá chắc chắn, bằng cách nào đó nó có thể được giảm bớt :) rút ngắn bằng @Score_Under

Perl, 50

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

Hãy thử tôi .

T-SQL, 276 byte

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 = Số bước

tổng cộng 175 ký tự, nhưng phải xuất ra tệp để hiển thị chính xác - vì vậy trừ 43 ký tự cho các thao tác tệp = 132 ký tự.

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)

Lưu ý cho người trả lời: Số byte là dành cho mã nguồn làm việc tuyệt đối và bộ đếm byte nói rằng đó là 261 byte, vì vậy nó là.

Bash (+ tac từ coreutils): 110 byte

Điều này có thể được dán trực tiếp vào thiết bị đầu cuối.

(n =; đặt {1..4}; đối với tôi thực hiện tiếng vang "$ {n} $ {n} _____ ") | tac

mã máy x86, 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

Mã hội tương đương:

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

Đầu ra:

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

Xin lỗi về đầu ra là khác nhau; Tôi hy vọng nó được chấp nhận.

Điều này đã được chạy trong DOSBOX