Tugas Anda adalah membuat program atau fungsi yang mengambil, sebagai input, bilangan alami ( n) antara 1 dan 25 (inklusif) dan mencetak representasi isometrik dari slide dan tangga dengan njumlah anak tangga.

Spesifikasi tangga dan slide

Tangga selalu berorientasi di sebelah kiri dan slide di sebelah kanan. Kami melihatnya dari sisi tangga, jadi bagian dari slide dikaburkan di tiga tingkat teratas. Anak tangga diwakili oleh empat garis ( ----) dan sisi tangga dan meluncur dengan garis miring ( /dan \). Berikut ini adalah diagram untuk mewakili pola ruang yang dibutuhkan untuk slide dengan lima anak tangga.

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

Contohnya

>>1
/----/\

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

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

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

Ini adalah kode-golf, jadi jawabannya dengan jumlah byte terendah menang.

Catatan: membuntuti spasi putih dapat diterima dalam output, asalkan tidak melebihi panjang garis.

Retina , 81 72 52 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

.+
$* /\    \
^.

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

Cobalah online!

Penjelasan

Program ini terdiri dari empat tahap, yang semuanya adalah penggantian regex (dengan beberapa fitur khusus Retina). Saya akan menggunakan input 5sebagai contoh untuk penjelasan.

Tahap 1

.+
$* /\    \

Ini mengubah input nmenjadi nspasi diikuti oleh /\ \yang akan menjadi bagian atas tangga / slide:

     /\    \

Untuk saat ini, kami hanya akan menunjukkan slide secara penuh dan mewakili tangga hanya dengan tangan kirinya /.

Tahap 2

^.

Sayangnya, nspasi lebih dari yang kita butuhkan, jadi kita menghapus karakter pertama lagi. Kami sekarang punya:

    /\    \

Tahap 3

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

Saatnya memperluas struktur yang lengkap. Mengetahui di mana puncaknya, sudah cukup untuk membangun semuanya, karena kita bisa memperpanjangnya satu baris pada satu waktu, memindahkan tangga dan seluncuran dengan dua spasi.

The +memberitahu Retina mengulangi tahap ini dalam satu lingkaran sampai output berhenti berubah (dalam hal ini, karena regex berhenti pencocokan). Adapun regex itu sendiri, kami cukup mencocokkan /pada baris terakhir dan semuanya setelahnya dan kami juga mencocokkan satu spasi di depannya, yang berarti ini tidak bisa lagi cocok setelah /mencapai kolom pertama.

Inilah yang kami gantikan dengan ini:

 $&    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.

Jadi pada setiap iterasi, ini menambahkan satu baris ke string, sampai kita berakhir dengan ini:

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

Tahap 4

/.{5}
/----/

Yang tersisa hanyalah menaiki tangga dengan benar. Itu sangat sederhana, kami hanya mencocokkan /dan 5 karakter berikutnya dan memasukkan representasi tangga yang benar, dengan demikian menimpa slide atau spasi yang sudah ada di sana:

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

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

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

Cobalah online!

Saya mungkin mengejar ketinggalan dengan Osabie. Satu byte lebih pendek dari Osabie.\o/Terikat dengan 2sable! Satu byte lebih pendek!

Dalam berita lain, ini jelas merupakan tandukan dicoret terpanjang yang pernah saya buat.

Penjelasan:

Àé              "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.

Ini akan berjalan sampai terjadi kesalahan, yang berkat perintah "pindah ke kiri" ('h'), akan menjadi waktu 'arg1'.

Sekarang kita hanya perlu menambahkan kaki bagian dalam

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 '\'

Versi tidak bersaing (28 byte)

Pyth, 39 35 byte

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

Penjelasan:

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

Tes di sini

2sable , 40 36 32 30 byte

Hmmm, V akan datang sangat dekat ...

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

Menggunakan pengkodean CP-1252 . Coba versi yang kompatibel dengan 05AB1E! .

PowerShell v2 +, 99 90 82 byte

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

Mengambil input $n, memulai perulangan dari 1ke $ndengan |%{...}. Setiap iterasi, kami membangun string. Kami mulai dengan jumlah ruang yang sesuai" "*($n-$_) dan tangga yang sesuai "/----/".

Untuk itu, kami menambahkan string lain yang telah diiris [...]dan -joindisatukan kembali. String kedua adalah slide, dan kami menganggap bahwa seluruh slide selalu terlihat. Ini jumlah ruang sebelum slide dimulai " "*($_+$i++), diikuti oleh slide itu sendiri"\ \" . Ini diiris oleh rentang yang dihitung sebagai bagian dari "spasi plus slide" yang sebagian disembunyikan oleh tangga.

Contohnya

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:]

Terima kasih kepada Hubert Grzeskowiak karena "mendiskualifikasi" saya karena membuat program cetak saya benar-benar menyelamatkan 3 byte! Terima kasih juga kepada Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ karena telah menghemat 1 byte lagi!

Vim, 71 penekanan tombol

Ini adalah cara yang bodoh untuk melakukannya, tetapi ini sedikit menyenangkan. Input diberikan sebagai file teks dengan satu baris berisi integer. Ini sepertinya cukup golf, tetapi akan berlaku untuk saat ini ( edit: gaya karakter kontrol yang diganti berdasarkan permintaan ):

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>dan <cr>semua penekanan tombol individu; ctrl + v, escape, dan carriage return (enter) masing-masing. Untuk versi yang sederhana untuk dicerna dengan literal yang benar, berikut adalah file yang ladder.keysdijalankan 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                         \\...

Untuk mencobanya (dengan asumsi nix dengan alat yang sesuai) ambil yang di atas, jalankan melalui xxd -rdan dimasukkan ke dalam file ladder.keys. Buat file ladder.txtdengan integer di dalamnya. Lalu lakukan:

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

bash, 61

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

di mana ^Mkereta kembali secara literal

$ ./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>

Bekerja dengan mengambil serangkaian nruang, kemudian melakukan beberapa penggantian eksotis untuk mendapatkan slide dengan dukungan, lalu mengganti dukungan dengan tangga.

Ruby, 61 byte

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

Tidak disatukan

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

Saya bisa menyimpan dua byte dengan menggunakan '%*s\ \^M%*s----/'(di mana ^Mliteral carriage return) untuk string format, tetapi kemudian Ruby mencetak peringatan " warning: encountered \r in middle of line, treated as a mere space". ¯ \ _ (ツ) _ / ¯

Solusi sebelumnya (64 byte)

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

Batch, 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%

Ternyata cukup mudah: lekukan slide, hapus 7 karakter pertama, lekukan tangga, hapus ruang terkemuka. Bit terakhir ini memang melibatkan sedikit tipu daya!

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?"":"\\");};

Sayangnya, Anda tidak dapat [dengan mudah] menduplikasi string di Java, jadi saya akhirnya menyalahgunakan fungsi format.

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 bytes

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

Saya telah secara resmi membuat bahasa yang paling lisan mungkin.Saya membuat komentar di lelucon dan sarkasme. Tolong tenanglah. Petunjuk tentang cara menjalankan repo github yang tertaut di header.

Tidak disatukan

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