Nhiệm vụ của bạn là tạo ra một chương trình hoặc hàm lấy, làm đầu vào, một số tự nhiên ( n) trong khoảng từ 1 đến 25 (đã bao gồm) và in một biểu diễn đẳng cự của một slide và bậc thang với nsố bậc.

Thông số kỹ thuật thang và trượt

Các bậc thang luôn được định hướng ở bên trái và trượt bên phải. Chúng tôi đang xem nó từ phía thang, vì vậy một phần của slide bị che khuất ở ba cấp cao nhất. Các nấc thang được thể hiện bằng bốn dấu gạch ngang ( ----) và các cạnh của thang và trượt bằng dấu gạch chéo ( /và \). Sau đây là sơ đồ để biểu diễn các mẫu không gian cần thiết cho một slide có năm nấc.

Slide              Blank space count
    /----/\        1234/----/\ 
   /----/  \       123/----/12\ 
  /----/    \      12/----/1234\ 
 /----/ \    \     1/----/1\1234\ 
/----/   \    \    /----/123\1234\

Ví dụ

>>1
/----/\

>>3
  /----/\ 
 /----/  \ 
/----/    \ 

>>4
   /----/\ 
  /----/  \ 
 /----/    \ 
/----/ \    \ 

>>10
         /----/\ 
        /----/  \ 
       /----/    \ 
      /----/ \    \ 
     /----/   \    \ 
    /----/     \    \ 
   /----/       \    \ 
  /----/         \    \ 
 /----/           \    \ 
/----/             \    \ 

Đây là môn đánh gôn, vì vậy câu trả lời có số byte thấp nhất sẽ thắng.

Lưu ý: khoảng trắng ở cuối được chấp nhận ở đầu ra, miễn là nó không vượt quá độ dài của dòng.

Võng mạc , 81 72 52 byte

Số lượng byte giả định mã hóa ISO 8859-1.

.+
$* /\    \
^.

+` /(.+)$
$&¶$%`/  $1
/.{5}
/----/

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

Giải trình

Chương trình bao gồm bốn giai đoạn, tất cả đều là sự thay thế regex (với một vài tính năng dành riêng cho Retina). Tôi sẽ sử dụng đầu vào 5làm ví dụ cho lời giải thích.

Giai đoạn 1

.+
$* /\    \

Điều này biến đầu nvào thành nkhoảng trắng theo sau /\ \sẽ trở thành đỉnh của thang / slide:

     /\    \

Hiện tại, chúng tôi sẽ chỉ hiển thị slide đầy đủ và chỉ đại diện cho thang bằng tay trái của nó /.

Giai đoạn 2

^.

Thật không may, nkhông gian là một trong nhiều hơn chúng ta cần, vì vậy chúng tôi loại bỏ ký tự đầu tiên một lần nữa. Bây giờ chúng ta đã có:

    /\    \

Giai đoạn 3

+` /(.+)$
$&¶$%`/  $1

Thời gian để mở rộng cấu trúc hoàn chỉnh. Biết vị trí của đỉnh là đủ để xây dựng toàn bộ, bởi vì chúng ta có thể chỉ cần mở rộng nó một dòng tại một thời điểm, di chuyển thang và trượt cách nhau bởi hai khoảng trống.

Yêu cầu +Retina lặp lại giai đoạn này trong một vòng lặp cho đến khi đầu ra dừng thay đổi (trong trường hợp này, vì regex dừng khớp). Đối với bản thân regex, chúng tôi chỉ đơn giản khớp với /dòng cuối cùng và mọi thứ sau nó và chúng tôi cũng khớp một khoảng trống phía trước nó, điều đó có nghĩa là điều này không còn có thể khớp khi /đã đạt đến cột đầu tiên.

Đây là những gì chúng tôi thay thế bằng:

 $&    The match itself. We don't want to remove the line we already have.
 ¶     A linefeed, because we want to append a new line.
 $%`   This is a very recent addition to Retina: it's like the normal $` but
      is bounded by linefeeds. That means this inserts everything in front
      of the match which is on the same line. In particular this one space
      less than the indentation of the matched line, hence we are shifting
      the / one column left.
 /     A literal /, representing the left edge of the ladder.
>  <   Two spaces, so that we can shift the slide one column right.
 $1    Capturing group 1 which contains the slide and its separation from
      the ladder.

Vì vậy, ở mỗi lần lặp, điều này sẽ thêm một dòng vào chuỗi, cho đến khi chúng ta kết thúc với điều này:

    /\    \
   /  \    \
  /    \    \
 /      \    \
/        \    \

Giai đoạn 4

/.{5}
/----/

Tất cả những gì còn lại là nhận được thang bên phải. Điều đó thực sự đơn giản, chúng tôi chỉ cần khớp /5 ký tự tiếp theo và chèn biểu diễn bậc thang chính xác, từ đó ghi đè lên trang chiếu hoặc khoảng trắng đã có:

    /----/\
   /----/  \
  /----/    \
 /----/ \    \
/----/   \    \

V , 38, 37, 36, 34, 33, 32, 31, 30 29 byte

Àé r\2é/4é-òhYpX$2P^ò3GEòjlr\

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

Tôi có thể bắt kịp Osabie. Một byte ngắn hơn Osabie. \o/Gắn chặt với 2sable! Một byte ngắn hơn!

Trong một tin tức khác, đây chắc chắn là tiêu đề tấn công dài nhất mà tôi từng thực hiện.

Giải trình:

Àé              "Insert 'arg1' spaces
   r\           "Turn the last one into a '\'
     2é/        "Insert 2 '/'
        4é-     "Insert 4 '-'

ò        ò      "Recursivly:
 h              "  Move one to the left
  Yp            "  Duplicate this line
    X           "  Delete one space from the left
     $2P        "  Paste two spaces at the end of this line
        ^       "  Move back to the beginning of this line.

Điều này sẽ chạy cho đến khi xảy ra lỗi, nhờ lệnh "di chuyển sang trái" ('h'), sẽ là 'arg1' lần.

Bây giờ chúng ta chỉ cần thêm chân bên trong

3GE             "Move to the second slash of line 3
   ò    ò       "Recursively: (The second 'ò' is implicit)
    jl          "  Move down and to the right
      r\        "  And replace the character under the cursor with a '\'

Phiên bản không cạnh tranh (28 byte)

Bình thường, 39 35 byte

VQ++*dt-QN"/----/">+*+ddN"\    \\"5

Giải trình:

VQ                                  # Interate over 0 -> Q-1 (Q is the input)
  +                                 # Concatenate the 2 halfs of the slide
   +                                # Concatenate the whitespace block and the ladder
    *d                              # Multiply d (whitespace) by this number \/
      t-QN                          # Calculate the amount of spaces before : input - step of the iterarion -1
          "/----/"                  # Ladder
                  >               5 # Remove the first 5 chars  from the string generated in the following lines 
                   +                # Concatenate the whitespace block and the slide
                    *+ddN           # Multiply "+dd" (2 whitespace) by the step of the iterarion to generate the space between the ladder and the slide
                         "\    \\"  # Slide

Kiểm tra tại đây

2sable , 40 36 32 30 byte

Hmmm, V đang đến rất gần ...

F¹N-<ð×…/--«ðð«N×…\  ««5F¦}¶

Sử dụng mã hóa CP-1252 . Hãy thử phiên bản tương thích 05AB1E! .

PowerShell v2 +, 99 90 82 byte

param($n)1..$n|%{" "*($n-$_)+"/----/"+-join(" "*($_+$i++)+"\    \")[6..(6+$_+$i)]}

Đưa đầu vào $n, bắt đầu một vòng lặp từ 1đến $nvới |%{...}. Mỗi lần lặp, chúng tôi đang xây dựng một chuỗi. Chúng tôi bắt đầu với số lượng không gian thích hợp " "*($n-$_)và thang "/----/".

Do đó, chúng tôi thêm một chuỗi khác đã được cắt [...]và -joined lại với nhau. Chuỗi thứ hai là slide và chúng tôi giả định rằng toàn bộ slide luôn hiển thị. Đó là số lượng không gian trước khi slide bắt đầu " "*($_+$i++), tiếp theo là chính slide "\ \". Điều này được cắt bởi một phạm vi được tính toán là một phần của "khoảng trắng cộng với slide" bị ẩn một phần bởi thang.

Ví dụ

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 7
      /----/\
     /----/  \
    /----/    \
   /----/ \    \
  /----/   \    \
 /----/     \    \
/----/       \    \

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 15
              /----/\
             /----/  \
            /----/    \
           /----/ \    \
          /----/   \    \
         /----/     \    \
        /----/       \    \
       /----/         \    \
      /----/           \    \
     /----/             \    \
    /----/               \    \
   /----/                 \    \
  /----/                   \    \
 /----/                     \    \
/----/                       \    \

Python 2 - 79 76 75 byte

x=input()
for i in range(x):print(x-i)*' '+'/----/'+(i*'  '+'\\    \\')[5:]

Cảm ơn Hubert Grzeskowiak đã "loại bỏ" tôi kể từ khi thực hiện chương trình in của tôi thực sự tiết kiệm được 3 byte! Cũng xin cảm ơn Eʀɪᴋ Gᴏʟғᴇʀ vì đã tiết kiệm thêm 1 byte!

Vim, 71 tổ hợp phím

Đây là một cách làm ngu ngốc như vậy, nhưng nó có một chút thú vị. Đầu vào được đưa ra dưới dạng tệp văn bản với một dòng chứa một số nguyên. Điều này có thể khá dễ chơi, nhưng bây giờ nó sẽ được thực hiện ( chỉnh sửa: chuyển đổi kiểu ký tự điều khiển theo yêu cầu ):

A@qyyPgg<c-v><c-v>GkI <c-v><esc>G$i  <c-v><esc><esc>
Tq"qDI/----/\^[lD@"ddh<c-v>god:%s/     \\/\\    \\<cr>

<c-v>, <esc>Và <cr>đều là những tổ hợp phím cá nhân; ctrl + v, thoát và trả lại vận chuyển (enter) tương ứng. Đối với một phiên bản đơn giản để tiêu hóa với các chữ chính xác, đây là tập tin ladder.keyschạy mặc dù xxd:

00000000: 4140 7179 7950 6767 1616 476b 4920 161b  A@qyyPgg..GkI ..
00000010: 4724 6920 2016 1b1b 5471 2271 4449 2f2d  G$i  ...Tq"qDI/-
00000020: 2d2d 2d2f 5c1b 6c44 4022 6464 6816 676f  ---/\.lD@"ddh.go
00000030: 643a 2573 2f20 2020 2020 5c5c 2f5c 5c20  d:%s/     \\/\\
00000040: 2020 205c 5c0d 0d0a                         \\...

Để dùng thử (giả sử một nix với các công cụ thích hợp), hãy thực hiện ở trên, chạy qua xxd -rvà đặt vào tệp ladder.keys. Tạo một tập tin ladder.txtvới một số nguyên trong đó. Sau đó làm:

vim -s ladder.keys -u NONE ladder.txt

bash, 61

for((;i<$1;)){ printf "%$[$1+i]s\    \^M%$[$1-++i]s/----/\n";}

nơi ^Mtrở lại vận chuyển theo nghĩa đen

$ ./ladder 1
/----/\
$ ./ladder 4
   /----/\
  /----/  \
 /----/    \
/----/ \    \
$ ./ladder 10
         /----/\
        /----/  \
       /----/    \
      /----/ \    \
     /----/   \    \
    /----/     \    \
   /----/       \    \
  /----/         \    \
 /----/           \    \
/----/             \    \

JavaScript (ES6), 79 byte

f=
n=>" ".repeat(n).replace(/./g,"$'/$`$`\\    \\\n").replace(/\/...../g,"/----/")
;

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Hoạt động bằng cách lấy một chuỗi các nkhoảng trắng, sau đó thực hiện một số thay thế kỳ lạ để có được slide với sự hỗ trợ, sau đó thay thế sự hỗ trợ bằng một cái thang.

Ruby, 61 byte

->n{n.times{|i|puts"%*s\\    \\\r%*s----/"% [n+i,"",n-i,?/]}}

Bị đánh cắp

->(num_rows) {
  num_rows.times {|row_idx|
    puts "%*s\\    \\\r%*s----/" % [ num_rows + row_idx, "", num_rows - row_idx, "/" ]
  }
}

Tôi có thể lưu hai byte bằng cách sử dụng '%*s\ \^M%*s----/'(trong đó ^Mlà trả về vận chuyển theo nghĩa đen) cho chuỗi định dạng, nhưng sau đó Ruby in cảnh báo " warning: encountered \r in middle of line, treated as a mere space". ¯ \ _ (ツ) _ /

Giải pháp trước đó (64 byte)

->n{n.times{|i|puts" "*(n+i)+"\\    \\\r"+" "*(n-i-1)+"/----/"}}

Hàng loạt, 194 byte

@echo off
for /l %%i in (1,1,%1)do call:l %1 %%i
exit/b
:l
set s=\    \
for /l %%j in (1,1,%2)do call set s=  %%s%%
set s=/----/%s:~7%
for /l %%j in (%2,1,%1)do call set s= %%s%%
echo%s%

Hóa ra khá đơn giản: thụt lề, xóa 7 ký tự đầu tiên, thụt lề thang, xóa khoảng trắng ở đầu. Điều cuối cùng này không liên quan đến một chút mánh khóe!

Java, 116 byte

c->{for(int i=0;i<c;i++)System.out.format("%"+(5+c-i)+"s%"+(i<3?i*2+1:2*(i-2))+"s%5s\n","/----/","\\",i<3?"":"\\");};

Thật không may, bạn không thể [dễ dàng] sao chép các chuỗi trong Java, vì vậy tôi cuối cùng đã lạm dụng chức năng định dạng.

Scala, 95 byte

def l(n:Int)=for(i<- 0 to n-1){println(" "*(n-i-1)+"/----/"+("  "*i+"\\    \\").substring(5))}

Haskell, 81 byte

a n=[1..n]>>" "
f n=[1..n]>>=(\i->a(n-i)++"/----/"++drop 7(a(2*i)++"\\    \\\n"))

eacal , noncompeting, 386 byte

init .
define @ curry push .
define ~ curry exec .--func
alias $ strap
alias ' string
set n set m cast number arg number 0
set s empty string
label l
@ get n
set n ~ dec
@ space
@ get n
$ ~ repeat
$ ' /----/
@ space
@ get m
@ get n
@ ~ sub
@ ~ dec
@ number 2
@ ~ mul
$ ~ repeat
$ ' \
$ newline
@ get n
@ number 0
if ~ more
goto l
@ $
@ regex gm '   ( {4})(?=.$)
@ '  \$1
print ~ replace

Tôi đã chính thức thực hiện ngôn ngữ dài dòng nhất có thể. Tôi đã bình luận trong sự hài hước và châm biếm. Hãy bình tĩnh. Hướng dẫn cách chạy trong repo github được liên kết trong tiêu đề.

Bị đánh cắp

init .
set n set m cast number arg number 0
set s empty string
label loop
    push . get n
    set n exec .--func dec
    push . space
    push . get n
    strap exec .--func repeat
    strap string /----/
    push . space
    push . get m
    push . get n
    push . exec .--func sub
    push . exec .--func dec
    push . number 2
    push . exec .--func mul
    strap exec .--func repeat
    strap string \
    strap newline
    push . get n
    push . number 0
    if exec .--func more
        goto loop

push . strap
push . regex gm string   ( {4})(?=.$)
push . string  \$1
print exec .--func replace