Diberi dua bilangan bulat positif, W dan H, menghasilkan kotak ASCII-art yang perbatasannya terbuat dari garis miring ( /dan \) dengan "paku" W di tepi atas dan bawah, dan H "paku" di tepi kiri dan kanan. Interior kotak dipenuhi dengan ruang.

"Spike" hanyalah dua garis miring yang bergabung membentuk bentuk panah:

/\    \/

/      \
\      /

Jadi hasilnya W = 4, H = 3adalah

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

karena ada 4 paku di atas menunjuk ke atas, 4 di bawah menunjuk ke bawah, 3 di kiri menunjuk ke kiri, dan 3 di kanan menunjuk ke kanan.

Berikut adalah beberapa pasangan input / output lainnya:

W H
[spiky slash box]

1 1
/\
\/

1 2
/\
\/
/\
\/

2 1
/\/\
\/\/

2 2
/\/\
\  /
/  \
\/\/

1 3
/\
\/
/\
\/
/\
\/

3 1
/\/\/\
\/\/\/

2 3
/\/\
\  /
/  \
\  /
/  \
\/\/

3 2
/\/\/\
\    /
/    \
\/\/\/

10 1
/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\/\/\/\/\/\/

10 2
/\/\/\/\/\/\/\/\/\/\
\                  /
/                  \
\/\/\/\/\/\/\/\/\/\/

4 5
/\/\/\/\
\      /
/      \
\      /
/      \
\      /
/      \
\      /
/      \
\/\/\/\/

Tidak ada garis dalam output yang harus memiliki spasi awal atau akhir. Secara opsional mungkin ada satu baris tambahan.

Kode terpendek dalam byte menang.

Arang , 9 byte

ＢײＮײＮ/\

Cobalah online!

Penjelasan

Ｂ           Box
  ײＮ       Next input as number * 2
      ײＮ   Next input as number * 2
          /\ With border "/\"

MATL , 18 byte

'\/',iE:]!+)O6Lt&(

Cobalah di MATL Online!

Penjelasan

Pertimbangkan input W = 4, H = 3. Kode membangun vektor baris [1 2 3 4 5 6 7 8](mulai dari 1ke 2*W) dan [1 2 3 4 5 6](mulai dari 1ke 2*H). Transposing yang terakhir dan menambahkan ke yang pertama dengan siaran memberikan matriks

2  3  4  5  6  7  8  9
3  4  5  6  7  8  9 10
4  5  6  7  8  9 10 11
5  6  7  8  9 10 11 12
6  7  8  9 10 11 12 13
7  8  9 10 11 12 13 14

Pengindeksan modular ke dalam string \/menghasilkan hasil yang diinginkan di perbatasan matriks:

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

Untuk menghapus nilai-nilai non-perbatasan, kami atur ke 0(ketika diartikan sebagai char, ditampilkan sebagai spasi):

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

Kode yang dikomentari:

'\/'    % Push this string. Will be indexed into
,       % Do twice
  i     %   Input a number
  E     %   Multiply by 2
  :     %   Range 
]       % End
!       % Transpose
+       % Add
)       % Index
O       % Push 0
6L      % Push [2 -1+1j]. As an index, this means 2:end
t       % Duplicate
&(      % Write 0 into the center rectangle. Implicit display

Python 2 , 69 68 byte

_{-1 terima kasih kepada Kevin Cruijssen}

lambda w,h:'/\\'*w+'\n'+'\\%s/\n/%s\\\n'%(('  '*~-w,)*2)*~-h+'\\/'*w

Cobalah online!

Haskell , 90 88 87 82 byte

1 6 byte disimpan berkat Lynn

a#b=[1..a]>>b
x!y|i<-(x-1)#"  "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]

Cobalah online!

Masih terasa sangat panjang, saya akan melihat apa yang bisa saya lakukan.

05AB1E , 14 byte

„/\|∍`S¦`).B∞∊

Cobalah online!

Penjelasan

„/\|∍`S¦`).B∞∊   Arguments: x, y
„/\              Push the string "/\"
   |             Push inputs as array: [x,y]
    ∍            Push the string extended/shortened to those lengths
     `           Flatten
      S          Push seperate chars of second string
       ¦`        Remove first char and flatten again
         )       Wrap stack to an array
          .B     Squarify
            ∞∊   Mirror on both axes

Ini hanya membuat sudut kiri atas, lebar x karakter dan tinggi karakter y. Kemudian mencerminkan ini pada kedua sumbu:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 byte

Mengambil input dalam sintaks currying (w)(h).

w=>h=>'/\\'[R='repeat'](w)+`
${`\\${p='  '[R](w-1)}/
/${p}\\
`[R](h-1)}`+'\\/'[R](w)

Demo

let f =

w=>h=>'/\\'[R='repeat'](w)+`
${`\\${p='  '[R](w-1)}/
/${p}\\
`[R](h-1)}`+'\\/'[R](w)

function upd() { O.innerHTML = W.value+'x'+H.value+'\n\n'+f(W.value)(H.value) }
upd()

<input id=W type=range value=5 min=1 max=10 oninput="upd()">
<input id=H type=range value=5 min=1 max=10 oninput="upd()">
<pre id=O>

Swift 3 , 166 byte

func f(a:Int,b:Int){let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",a-1)+"/";print(k("/\\",a)+n+k(r+n+String(r.characters.reversed())+n,b-1)+k("\\/",a))}

Paket tes lengkap.

Versi penutupan sedikit lebih lama, sayangnya (175 byte):

var g:(Int,Int)->String={let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",$0-1)+"/";return k("/\\",$0)+n+k(r+n+String(r.characters.reversed())+n,$1-1)+k("\\/",$0)}

Test suite dengan versi penutupan.

Retina , 77 73 byte

\d+
$*
 1+|1(?=1* (1+))
$1¶
1
/\
.((..)*.)
/$1¶$1/
¶$

(?<=¶.+).(?=.+¶)
 

Cobalah online! Tautan termasuk kasus uji. Mengambil input dalam format <height> <width>. Penjelasan:

\d+
$*

Konversikan input ke unary.

 1+|1(?=1* (1+))
$1¶

Lipat gandakan input, tetapi tambahkan baris baru sehingga hasilnya adalah persegi panjang.

1
/\

Buat bagian atas yang runcing.

.((..)*.)
/$1¶$1/

Gandakan setiap baris runcing, tetapi dengan paku diimbangi di baris kedua.

¶$

Hapus baris baru yang tertinggal.

(?<=¶.+).(?=.+¶)
 

Hapus bagian dalam kotak. (Catat ruang pada baris terakhir.)

Excel, 95 byte

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)

APL (Dyalog) , 41 39 byte

Meminta daftar [H,W]

'\'@2@1⊢¯1⌽@1{⌽⍉⍵,'/\'⍴⍨≢⍵}⍣4⊢''⍴⍨2×⎕-1

Cobalah online!

⎕-1 meminta input (mnemonic: konsol bergaya) dan kurangi 1

2× kalikan dengan dua

''⍴⍨ gunakan itu untuk membentuk kembali string kosong (bantalan dengan spasi)

⊢ hasilkan itu (berfungsi untuk memisahkannya dari 4)

{... }⍣4 terapkan fungsi berikut empat kali:

 ≢⍵ tally (panjang) argumen

 '/\'⍴⍨ siklis r eshape "/\"untuk panjang yang

 ⍵, tambahkan itu ke sisi kanan argumen

 ⌽⍉ transpos dan cermin (yaitu putar 90 °)

¯1⌽1 siklis memutar 1 ^st baris satu langkah ke kanan

⊢ hasilkan itu (berfungsi untuk memisahkannya dari 1)

'\'@2@1 menempatkan garis miring terbalik di 2 ^nd posisi 1 ^st item yang besar.

C (gcc) ,170 166 158 155 108 105

-3 byte berkat cleblanc

x,y;f(w,h){for(y=h*=2;y--;puts(""))for(x=w*2;x--;)putchar(!x|x==w*2-1|!y|y==h-1?x&y&1|~x&~y&1?47:92:32);}

Cobalah online!

Saya pikir ini bisa bermain golf lebih lanjut dengan pendekatan yang tidak langsung, saya akan melihat apa yang bisa saya lakukan ketika saya menemukan waktu.

Oke, saya tidak bisa menemukan cara lain untuk mengurangi jumlah byte untuk kode itu.

Penjelasan: pencetakan loop-sederhana dua kotak char by char.

Saat mencetak batas: jika koordinat x dan y baik genap atau ganjil, ini akan menampilkan a /, jika tidak, a \ditampilkan

Jika bukan perbatasan, karakter spasi malah ditampilkan

/// , 172 117 byte

Jadi, karena output terdiri dari ///s dan whitespaces, harus ada pengiriman dalam 2 bahasa tersebut.

Masukkan input setelah kode W,Hsebagai nomor unary (unary untuk /// diizinkan , terima kasih kepada Challenger5 untuk saran) (gunakan *untuk mewakili ,format digit, pisahkan dengan ).

/W/VV//V/\\\///`/\\\\\\\\\\\\\V/,/W>+  V`/`\>+W  !V!``WV>+WV-  V`\
`\W+  V`/
`/W-!V`\
W``\\V`\V>!//!*/+%-%!//*/  //%/

Cobalah online! (dengan input W=4, H=3)

Python 3 , 87 82 byte

Sunting: Disimpan 5 byte berkat @officialaimm , @ Mr.Xcoder dan @tsh

def f(a,b,n="\n"):r="\\"+"  "*~-a+"/";print("/\\"*a+n+(r+n+r[::-1]+n)*~-b+"\\/"*a)

Cobalah online!

J, 48 byte

' '&((<,~<<0 _1)})@(+:@[$(1&|.,:])@('\/'$~+:)@])

ungolfed

' '&((< ,~ <<0 _1)}) @ (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])

penjelasan

                       (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])    creates box, but interior filled with slashes
                                           ('\/' $~ +:)@]       take right arg, W, doubles it, then fills that
                                          @                       many characters with '\/' repeating
                               (1&|. ,: ])                      stacks (,:) the above on top of itself rotated 
                                                                  by one char, producing top and bottom spikes
                              $                                 reshape to..
                       (+:@[                                    double the length of the left arg, height
                                                                  this creates the sides, as well as a filled interior
                     @                                    
' '&((< ,~ <<0 _1)})                                          removes slashes from interior by using the complement               
                                                                form of amend }.  ie, replace everything but the first
                                                                and last row and first and last col with a space

Cobalah online!

05AB1E , 19 byte

4FNÈi¹}·„\/NÉiR}N·Λ

Cobalah online!

Membawa argumen terbalik.

Haskell , 84 79 byte

w%h=[[last$"/\\"!!mod(x+y)2:[' '|x>1,y>1,x<2*w,y<2*h]|x<-[1..2*w]]|y<-[1..2*h]]

Cobalah online! Contoh penggunaan: 3%6menghasilkan daftar garis. Gunakan mapM putStrLn $ 3%6untuk mencetak kotak dengan cantik.

Java 8, 141 byte

Lambda kari dari lebar ke tinggi ke keluaran.

w->h->{String f="/",b="\\",t=f,o=b,p="";char i=1;for(;i++<w;t+=b+f,o+=f+b)p+="  ";t+=b;o+=f;for(i=10;--h>0;)t+=i+b+p+f+i+f+p+b;return t+i+o;}

Coba Online (tidak, return t+i+o;tidak disengaja)

Lambda yang tidak tersentuh

w ->
    h -> {
        String
            f = "/",
            b = "\\",
            t = f,
            o = b,
            p = ""
        ;
        char i = 1;
        for (; i++ < w; t += b + f, o += f + b)
            p += "  ";
        t += b;
        o += f;
        for (i = 10; --h > 0; )
            t += i + b + p + f + i + f + p + b;
        return t + i + o;
    }

Solusi ini biasanya pilih-pilih tentang ukuran input karena a chardigunakan untuk menghitung hingga lebar input. Untungnya, algoritme ini cukup buruk sehingga pada ukuran tersebut penyelesaian program mungkin sudah menjadi masalah. Saya memilih untuk menggunakan charuntuk indeks loop sehingga saya bisa menggunakannya kembali nanti sebagai alias murah untuk '\n'.

SOGL V0.12 , 22 21 13 byte

/\”m;HΙ»mč+╬¡

Coba Di Sini! (mengharapkan kedua input pada stack jadi ..(dan "karena string belum dimulai secara eksplisit) - ambil input nomor dua kali ditambahkan untuk kemudahan penggunaan)

Penjelasan:

/\”            push "/\"
   m           mold to the 1st inputs length
    ;          get the other input ontop of stack
     H         decrease it
      Ι        push the last string - "/\"
       »       rotate it right - convert to "\/"
        m      mold "\/" to the length of 2nd input - 1
         č     chop into characters
          +    prepend the 1st molded string to the character array of the 2nd
           έ  quad-palindromize

Mathematica, 87 byte

Table[Which[1<i<2#2&&1<j<2#," ",OddQ[i+j],"\\",1>0,"/"],{i,2#2},{j,2#}]~Riffle~"
"<>""&

Cobalah dalam Matematika (mencetak ruang ekstra di awal sebagian besar garis untuk beberapa alasan), atau di kotak pasir Wolfram ! Mengambil dua bilangan bulat sebagai input.

Ini solusi yang cukup naif, tetapi semua hal pintar yang saya coba memiliki lebih banyak byte. Sesuatu yang hampir berhasil adalah

ArrayPad[Array[" "&,2#-2],1,{{"/",s="\\"},{s,"/"}}]~Riffle~"\n"<>""&

kecuali gagal jika salah satu dimensi adalah 1 (input adalah daftar yang berisi dimensi).

Pyth , 40 39 38 byte

+++*Q"/\\"b*tE+++K++\\*d*2tQ\/b_Kb*"\/

Ini mengambil dua bilangan bulat yang dipisahkan oleh baris baru.

Paket tes lengkap.

Ruby , 62 61 60 byte

->r,c{["/\\"*c]+["\\#{w="  "*~-c}/",?/+w+?\\]*~-r+["\\/"*c]}

-1 byte terima kasih kepada Arnauld

Cobalah online!

Sebenarnya , 38 byte

"/\"*;.R;l¬' *"\/"@j;R(D(╗WD(;.(;.(Wé╜

Cobalah online!

J , 39 byte

(' \/'{~=/&(2&|)(*>:)~0=*/&(*|.))&i.&+:

Cobalah online!

Membawa dua argumen seperti heightpada LHS dan widthpada RHS.

VBA (Excel), 161 Bytes

Sub a()
c=[A2]*2
r=[B2]*2
For i=1To r
For j=1To c
b=IIf(i=1 Or j=1 Or i=r Or j=c,IIf((i+j) Mod 2,"\","/")," ")
d=d & b
Next
d=d & vbCr
Next
Debug.Print d
End Sub

R, 160 byte 152 byte

p=function(x,n){paste(rep(x,n),collapse='')}
function(w,h){f=p(' ',w*2-2)
cat(paste0(p('/\\',w),'\n',p(paste0('\\',f,'/\n/',f,'\\\n'),h-1),p('\\/',w)))}

Cobalah online!

Terima kasih BLT untuk mencukur 8 byte.

dc , 123 byte

?1-sesf[/\]su[lfsh[lunlh1-dsh0<q]dsqx]dsrx[[
\]P[lf2*2-st[32Plt1-dst0<z]dszx]dsmx[/
/]Plmx92Ple1-dse0<l]slle0<l10P[\/]sulrx

Ini jauh dari yang terpendek, tetapi, jika seseorang mengambil dua baris terakhir dan memutarnya pi/2radian searah jarum jam ke posisi "tegak", itu terlihat seperti tiang totem .

Mengambil input sebagai dua bilangan bulat yang dipisahkan oleh spasi.

Cobalah online!

Mathematica, 116 byte

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&

V , 18 byte

Ài/\Ùæ$Àäkllòjjkè

Jawaban tidak akan memerlukan kolom char lljika <M-h>ollowdibiarkan sendiri :(

Cobalah online!

C # (.NET Core) , 188 byte

a=>b=>string.Join("\n",new int[2*b].Select((x,i)=>string.Concat(string.Concat(new int[a].Select(y=>i%2==0?"/\\":"\\/")).Select((y,j)=>i>0&i<2*b-1&j>0&j<2*a-1?" ":""+y))))

Hitungan byte juga mencakup:

using System.Linq;

Cobalah online!

Saya mulai membuat penjelasan perintah demi perintah tetapi berhenti masuk akal di tengah ... Inti dasar adalah membuat kotak penuh runcing, dan kemudian melubangi tengah. Saya menggunakan Linq demi menggunakan Linq, mungkin bisa lebih pendek hanya menggunakan iterasi standar.

Berikut ini penjelasan cara keluar-ke-tengah (perintah paling-dalam dulu):
Pertama, buat baris untuk kotak penuh, dan gabungkan menjadi satu string

string.Concat(new int[a].Select(y => i % 2 == 0 ? "/\\" : "\\/"))

Lalu dapatkan setiap karakter dalam satu baris, dan jika itu bukan garis besar kotak, ganti dengan spasi, gabungkan mereka kembali menjadi satu string untuk setiap baris

string.Concat(PREVIOUS_STEP.Select((y, j) => i > 0 & i < 2 * b - 1 & j > 0 & j < 2 * a - 1 ? " " : "" + y))

Akhirnya, dapatkan setiap baris dan gabungkan mereka bersama-sama dengan baris baru (juga termasuk menghasilkan koleksi untuk baris)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));

Perl 5 , 83 + 1 (-n) = 84 byte

say"/\\"x($q=$F[0]);print(("\\".($s=$"x(2*$q-2))."/$//$s\\$/")x--$F[1]);say"\\/"x$q

Cobalah online!