[Question]
  [
Given two positive integers, W and H, output an ASCII-art box whose border is made of slashes (`/` and `\`) with W "spikes" on the top and bottom edges, and H "spikes" on the left and right edges. The box's interior is filled with spaces.
A "spike" is simply two slashes coming together to form an arrow shape:
```
/\    \/
/      \
\      /
```
So the output for `W = 4, H = 3` would be
```
/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/
```
as there are 4 spikes on the top pointing up, 4 on the bottom pointing down, 3 on the left pointing left, and 3 on the right pointing right.
Here are some other input/output pairs:
```
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
/\/\/\/\
\      /
/      \
\      /
/      \
\      /
/      \
\      /
/      \
\/\/\/\/
```
No lines in the output should have leading or trailing spaces. There may optionally be one trailing newline.
**The shortest code in bytes wins.**
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
Ｂ×²Ｎ×²Ｎ/\
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98pv0JDS8NIR8Ezr6C0xK80Nym1SENTU0cBq6CSfkyMkqb1//@GCkb/dcv@6xbnAAA "Charcoal – Try It Online")
### Explanation
```
Ｂ           Box
  ×²Ｎ       Next input as number * 2
      ×²Ｎ   Next input as number * 2
          /\ With border "/\"
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 18 bytes
```
'\/',iE:]!+)O6Lt&(
```
Try it at [MATL Online!](https://matl.io/?code=%27%5C%2F%27%2CiE%3A%5D%21%2B%29O6Lt%26%28&inputs=4%0A3&version=20.2.2)
### Explanation
Consider inputs `W = 4`, `H = 3`. The code builds the row vectors `[1 2 3 4 5 6 7 8]` (range from `1` to `2*W`) and `[1 2 3 4 5 6]` (range from `1` to `2*H`). Transposing the latter and adding to the former with broadcast gives the matrix
```
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
```
Modular indexing into the string `\/` produces the desired result in the matrix border:
```
/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/
```
To remove the non-border values, we set them to `0` (when interpreted as char it is displayed as space):
```
/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/
```
Commented code:
```
'\/'    % 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
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~69~~ 68 bytes
-1 thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
```
lambda w,h:'/\\'*w+'\n'+'\\%s/\n/%s\\\n'%(('  '*~-w,)*2)*~-h+'\\/'*w
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaFcJ8NKXT8mRl2rXFs9Jk8dSMSoFuvH5OmrFsfEAAVUNTTUFRTUtep0y3U0tYw0gYwMkCJ9oI7/BUWZeSUKaRqGOoaaXBCOujoXQtQIi6gRVrVGOsZYRE11TDX/AwA "Python 2 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~90~~ ~~88~~ ~~87~~ 82 bytes
*~~1~~ 6 bytes saved thanks to Lynn*
```
a#b=[1..a]>>b
x!y|i<-(x-1)#"  "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1E5yTbaUE8vMdbOLomrQrGyJtNGV6NC11BTWUlBQcm2QllJPyZGyUqjEiQUrR4To26Vqa2tpK@ko64PYQKlY7W1o4EqY2L0lWL/5yZm5tkWlJYElxT55KmU5uVk5qUWq5gpmvwHAA "Haskell – Try It Online")
Still feels really long, I'll see what I can do.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 14 bytes
```
„/\|∍`S¦`).B∞∊
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcM8/ZiaRx29CcGHliVo6jk96pj3qKPr/39DLmMA "05AB1E – Try It Online")
### Explanation
```
„/\|∍`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
```
This only creates the top left corner, x characters wide and y characters tall. It then mirrors this on both axes:
```
x=3, y=2
/\/|
\  |
---+
```
[Answer]
## JavaScript (ES6), 84 bytes
Takes input in currying syntax `(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>
```
[Answer]
# [Swift 3](https://www.swift.org), 166 bytes
```
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))}
```
**[Full test suite.](http://swift.sandbox.bluemix.net/#/repl/598c093a3d85b53110d41c94)**
The closure version is a bit longer, unfortunately (175 bytes):
```
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 with the closure version.](http://swift.sandbox.bluemix.net/#/repl/598c097d3d85b53110d41c95)**
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~77~~ 73 bytes
```
\d+
$*
 1+|1(?=1* (1+))
$1¶
1
/\
.((..)*.)
/$1¶$1/
¶$
(?<=¶.+).(?=.+¶)
 
```
[Try it online!](https://tio.run/##HUs7DsIwDN3fKTwEyU4kp07ajapjL9GhSDCwMCBGzpUD5GIhYXhf@70fn@fr1i68n@24BzgPsvA13lbzxBZE4KwWGOIBZVYVr4I4SmcRnQHermstGkT7TkMtAmot0wwjQ@owSl0T8t/nriPncZ/Gw4SF5h8 "Retina – Try It Online") Link includes test cases. Takes input in the format `<height> <width>`. Explanation:
```
\d+
$*
```
Convert the inputs to unary.
```
 1+|1(?=1* (1+))
$1¶
```
Multiply the inputs, but add a newline so that the result is a rectangle.
```
1
/\
```
Create the spiky top.
```
.((..)*.)
/$1¶$1/
```
Duplicate each spiky row, but with the spikes offset on the second row.
```
¶$
```
Delete trailing newlines.
```
(?<=¶.+).(?=.+¶)
 
```
Delete the inside of the box. (Note space on last line.)
[Answer]
# Excel, 95 bytes
```
=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~41~~ 39 bytes
Prompts for a list of `[H,W]`
```
'\'@2@1⊢¯1⌽@1{⌽⍉⍵,'/\'⍴⍨≢⍵}⍣4⊢''⍴⍨2×⎕-1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM9uCAzu9Ipv@K/eoy6g5GD4aOuRYfWGz7q2etgWA0kH/V2PurdqqOuH6P@qHfLo94VjzoXAQVqH/UuNgEqVYeKGh2e/qhvqq4hyMT/CmAAM5jLWMGEC03IUMEQXcgIU8hQwQhTFYaQMTaNxpiqsJhljMVdBlgchiFmqmACAA "APL (Dyalog Unicode) – Try It Online")
`⎕-1` prompt for input (mnemonic: stylized console) and subtract 1
`2×` multiply by two
`''⍴⍨` use that to reshape an empty string (pads with spaces)
`⊢` yield that (serves to separate it from `4`)
`{`…`}⍣4` apply the following function four times:
 `≢⍵` tally (length of) the argument
 `'/\'⍴⍨` cyclically **r**eshape `"/\"` to that length
 `⍵,` append that to the right side of the argument
 `⌽⍉` transpose and mirror (i.e. turn 90°)
`¯1⌽1` cyclically rotate the 1st row one step to the right
`⊢` yield that (serves to separate it from `1`)
`'\'@2@1` put a backslash at the 2nd position of the 1st major item.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~170~~ ~~166~~ ~~158~~ ~~155~~ ~~108~~ 105
*-3 bytes thanks to 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);}
```
[Try it online!](https://tio.run/##hY5BDoMgEEX3ngJdGDCQCLZpKiFepBtja3VRNFQrRPTqFl1Xu5rJe/kzvyDPolgWjQ0v4YArNJaNgkZUkWDcEMLbvnvDIEBo5VoMEePaYeR4UeUK@tpqsWJCrW@sEaIiNNOhCamddTi7mZ0u6ZWlCUN8WmrZgVdeS/hp6jsCowdACSkGFHG3tsr5EgaEkJsMNrRZtm/ZYZYdZt3lZN8mx63iv/rg8wmD82/rmHp0vZIg5t7kLV8 "C (gcc) – Try It Online")
~~I think this can be golfed further with a less straightforward approach, I'll see what I can do when I find the time.~~
Ok I cannot find any other way to reduce the number of bytes for that code.
Explanation: a simple double-loop printing the box char by char.
When printing a border: if both x and y coordinates are either even or odd, it displays a `/`, otherwise, a `\` is displayed
If not a border, a space character is displayed instead
[Answer]
# [///](https://esolangs.org/wiki////), ~~172~~ 117 bytes
So, because the output consists of `///`s and `whitespace`s, there should be submissions in those 2 languages.
Put the input after the code in `W,H` as unary number (unary for /// is [allowed](https://codegolf.meta.stackexchange.com/questions/5343/can-numeric-input-output-be-in-unary), thanks to Challenger5 for suggestion) (use `*` to represent digit, separate with `,`) format.
```
/W/VV//V/\\\///`/\\\\\\\\\\\\\V/,/W>+  V`/`\>+W  !V!``WV>+WV-  V`\
`\W+  V`/
`/W-!V`\
W``\\V`\V>!//!*/+%-%!//*/  //%/
```
[Try it online!](https://tio.run/##RYsxCsUwDEP3nsIesiQNukGOYS8e9IdCh265P6lDhy8QeghpPr95X3MtOMwAQ0QA4M6/DCd8NBEjGKO5iJqSbsnWdx8Hw7/FQXjXXTmZZ4YNBbSilV6SKkSAgpo602u9 "/// – Try It Online") (with input `W=4, H=3`)
[Answer]
# [Python 3](https://docs.python.org/3.6/), 87 82 bytes
**Edit:** Saved 5 bytes thanks to [@officialaimm](https://codegolf.stackexchange.com/users/59523/officialaimm), [@Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder) and [@tsh](https://codegolf.stackexchange.com/users/44718/tsh)
```
def f(a,b,n="\n"):r="\\"+"  "*~-a+"/";print("/\\"*a+n+(r+n+r[::-1]+n)*~-b+"\\/"*a)
```
[Try it online!](https://tio.run/##LY6xDsIwDETn9isiT3GSKk1SliAk/oMytIKILm4VdWHh14MJXZ5PvrN123t/rRRKeTyTSHIys6ELjAQYM88RNAgB6tNNGiyct7zQLsGyoSZNWmZGvsXYubsm5Nys@cqyiyWtWfBDsZCQ0hmHhumZvmpfdTg2oeofXf@P9tUZzAkxtk3thm1zNLiC8j2WLw)
[Answer]
# J, 48 bytes
```
' '&((<,~<<0 _1)})@(+:@[$(1&|.,:])@('\/'$~+:)@])
```
## ungolfed
```
' '&((< ,~ <<0 _1)}) @ (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])
```
## explanation
```
                       (+:@[ $ (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
```
[Try it online!](https://tio.run/##y/r/P81WT0FdQV1NQ8NGp87GxkAh3lCzVtNBQ9vKIVpFw1CtRk/HKhbIV4/RV1ep07bSdIjV5EpNzshXMFRIUzCEMNXVIbQRUMgIVcgYKGTy/z8A "J – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 19 bytes
```
4FNÈi¹}·„\/NÉiR}N·Λ
```
[Try it online!](https://tio.run/##ASgA1/8wNWFiMWX//zRGTsOIacK5fcK34oCeXC9Ow4lpUn1OwrfOm///Mwo0 "05AB1E – Try It Online")
Takes arguments reversed.
[Answer]
# [Haskell](https://www.haskell.org/), ~~84~~ 79 bytes
```
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]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v1w1wzY6OiexuERFST8mRklRMTc/RaNCu1LTyCpaXUG9psLOUKcSiCtsjLTKdSqBZEZsTYWNbrShnh5QJDa2phLGyYiN/Z@bmJmnYKuQm1jgq1BQWhJcUuSTp6CiYKxq8h8A "Haskell – Try It Online") Example usage: `3%6` yields a list of lines. Use `mapM putStrLn $ 3%6` to pretty-print the box.
[Answer]
# Java 8, 141 bytes
A curried lambda from width to height to output.
```
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;}
```
[Try It Online](https://tio.run/##fZA9b8IwEIZn8itOnhI5cYPazThjpQ6dGIHBDjYYgm05lyCE@O2p@ehWdTjJ99x70j0@yFFWPmh32B4newo@IhwSYwPajpnBtWi9Y5@vB8@yMKjOttB2su/hW1oH12wWoh0lauhRYhr@xhdfDvVOx/IPssRo3a5pwICYzlWzr5rrk4ER5I2USpD1mpQoTOmFKoMghLd7GcGKOTc@5txSujhzpELRlKHCUFUEKggAeVB@Z49oWql5Ve2bmhdpYqmigRpqUwWqeNQ4RAeYgOe3acaT0VPzJTR6u4VTks2fJ642IOOuL@7us@WlR31ifkCW/sFhbpgMobvkL1cWZOx1avL7zqreFMW/gXkKFOmEW3abpo/p/Qc) (no, `return t+i+o;` was not intentional)
## Ungolfed lambda
```
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;
    }
```
This solution is atypically picky about input size since a `char` is used to count up to the width input. Fortunately, the algorithm is bad enough that at those sizes program completion is probably already an issue. I chose to use `char` for the loop index so I could reuse it later as a cheap alias for `'\n'`.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~22~~ ~~21~~ 13 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
/\”m;HΙ»mč+╬¡
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=Li4lMjIvJTVDJXUyMDFEbSUzQkgldTAzOTklQkJtJXUwMTBEKyV1MjU2QyVBMQ__,inputs=MyUwQTQ_) (expects both inputs on stack so `..` (and `"` because a string hasn't been explicitly started) - take number input twice is added for ease-of-use)
Explanation:
```
/\”            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
```
[Answer]
# Mathematica, 87 bytes
```
Table[Which[1<i<2#2&&1<j<2#," ",OddQ[i+j],"\\",1>0,"/"],{i,2#2},{j,2#}]~Riffle~"
"<>""&
```
Try it in [Mathics](https://tio.run/##y00sychMLv6fZvs/JDEpJzU6HMjNiDa0ybQxUjZSUzO0yQIydJQUlHT8U1ICozO1s2J1lGJilHQM7Qx0lPSVYnWqM3WASmt1qrOAdG1sXVBmWlpOap0Sl5KNnZKS2v@Aosy8EgUHhbRoEx3T2P8A "Mathics – Try It Online") (it prints extra spaces at the start of most lines for some reason), or at the [Wolfram sandbox](https://sandbox.open.wolframcloud.com/)! Takes two integers as input.
It's a fairly naïve solution, but all of the clever things I tried had more bytes. Something that nearly works is
```
ArrayPad[Array[" "&,2#-2],1,{{"/",s="\\"},{s,"/"}}]~Riffle~"\n"<>""&
```
except it fails if either dimension is 1 (input is a list containing the dimensions).
[Answer]
# [Pyth](https://pyth.readthedocs.io), ~~40 39~~ 38 bytes
```
+++*Q"/\\"b*tE+++K++\\*d*2tQ\/b_Kb*"\/
```
This takes the two integers separated by a newline.
**[Full test suite.](https://pyth.herokuapp.com/?code=%2B%2B%2B%2aQ%22%2F%5C%5C%22b%2atE%2B%2B%2BK%2B%2B%5C%5C%2ad%2a2tQ%5C%2Fb_Kb%2a%22%5C%2F&input=5%0A3&test_suite=1&test_suite_input=1%0A1%0A%0A1%0A2%0A%0A2%0A1%0A%0A2%0A2%0A%0A1%0A3%0A%0A3%0A1%0A%0A2%0A3%0A%0A3%0A2%0A%0A10%0A1%0A%0A10%0A2%0A%0A4%0A5%0A&debug=0&input_size=3)**
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~62 61~~ 60 bytes
```
->r,c{["/\\"*c]+["\\#{w="  "*~-c}/",?/+w+?\\]*~-r+["\\/"*c]}
```
-1 byte thanks to Arnauld
[Try it online!](https://tio.run/##KypNqvyfZvtf165IJ7k6Wkk/JkZJKzlWO1opJka5utxWSUFBSatON7lWX0nHXl@7XNs@JiYWKFAEVqEPUlv7v6C0pFghLdpExySWC8xW1wUCdS6ouKGOIVZxExzihkBz/gMA "Ruby – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 38 bytes
```
"/\"*;.R;l¬' *"\/"@j;R(D(╗WD(;.(;.(Wé╜
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/19JP0ZJy1ovyDrn0Bp1BS2lGH0lhyzrIA0XjUdTp4e7aFjrgVD44ZWPps75/9@YywQA "Actually – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 39 bytes
```
(' \/'{~=/&(2&|)(*>:)~0=*/&(*|.))&i.&+:
```
[Try it online!](https://tio.run/##y/r/P03B1kpBQ10hRl@9us5WX03DSK1GU0PLzkqzzsBWC8jXqtHT1FTL1FPTtuLiSk3OyFcwUkhTMDT4/x8A "J – Try It Online")
Takes two arguments as `height` on the LHS and `width` on the RHS.
[Answer]
# ><>, 180 Bytes
```
0&0\
a*+>i68*-:0(?v$
/)\^0&1v?)0&~/
? 0 v:$<
/ \:<-1oo'/\'
\~$:@2*0&\
'/'1>&o1->a\ /'/'>o$:2*>1-:1)?\~$&1=?\
'\'0//?(3:o/?/'\'/     \o*48  /      \
/?)0\ &:&1=/;
\  \:~
'/'/\<oo'\'
```
[Answer]
**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
```
[Answer]
# R, ~~160 bytes~~ 152 bytes
```
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)))}
```
[Try it online!](https://tio.run/##TYxBCsMgEEX3OYW7mSkTbEO7zE3ciCgpBCPRkkDI2e1EKHQ3/73/Z601qVGFT3TlvUTcOdKRbC4eV59aZLfMs03ZjwB0dvm/vvFERxCSEBTwdhv6gTpnC7YfdxSujRFDDCYCp5@AiwYWG3U7jBFPPPUPkpZEfa2IzprxyS@qXw "R – Try It Online")
Thanks BLT for shaving off 8 bytes.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 123 bytes
```
?1-sesf[/\]su[lfsh[lunlh1-dsh0<q]dsqx]dsrx[[
\]P[lf2*2-st[32Plt1-dst0<z]dszx]dsmx[/
/]Plmx92Ple1-dse0<l]slle0<l10P[\/]sulrx
```
It's far from the shortest, but, if one takes the last two lines and rotates them `pi/2` radians clockwise to an "upright" position, it kind of looks like a [totem pole](https://s-media-cache-ak0.pinimg.com/736x/58/e4/79/58e4791f09400e842056c0aa7682f18d--vancouver-bc-canada-vancouver-british-columbia.jpg).
Takes input as two space-separated integers.
[Try it online!](https://tio.run/##Fc29CsMwDATgPU/RuWD8UwotGPoK3mVNtYMHpZDIAZGXd@XlbrgPrnzH@HjDlVewGfkEWrkBnT9q3hRuLu5YeBeNQwCWjElJuAfDHR4hUZ@su3ipuCbbBOxiMdEmb93r3KuLhEw027sE2eoVHTLG8/b6Aw "dc – Try It Online")
[Answer]
# Mathematica, 116 bytes
```
(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 18 bytes
```
Ài/\Ùæ$Àäkllòjjkè
```
Answer wouldn't require the `ll` if `<M-h>ollow` left 2 char columns alone :(
[Try it online!](https://tio.run/##ASIA3f92///DgGkvXBvDmcOmJMOAw6RrbGzDsmpqa8Oo////OP84 "V – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 188 bytes
```
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))))
```
Byte count also includes:
```
using System.Linq;
```
[Try it online!](https://tio.run/##ZVBNT4NAED13f8VIYt21lALVi3VpGhMPRhNjTTxIDyuuug1dKrv9IE1/Ow5UMegkMG8@3puZTUw/yXJZrozS7zAtjJUL71bpzxEhWiykWYpEfufJjgBakgpjYFLjQ6YyY4VVCawz9Qp3QmnKmtKOdDrXK51cKm1d@EXG5jg0iuANeCl49MKjQ8q7yVDAibXjarkBbH4OT19m3lSmMrGUbl3Fmt6rTCfC0nb0QxMNqeCROg4598fOII6dCyeOBw5jjWbhzlFTRX5XXeKwftCdI54jFv1g7AAynF7B0MpRc9nh8GowTluubLuy@VCpBErrEnDA3UyWSu9Bild8YkkZgyMOepWmrEXctaLK1iIHhRK1lDddpsrSE/ekWX@Lq2vr3YvcSLrFsx6zSZ6LgrLRP62fNZ5yZWW9xxtVz/6M4T@YMehB9fJ/iHvSRnuyL8/cIQncAL@QhOhD9AHmhjWuPMZ@1eAjOnPPvwA "C# (.NET Core) – Try It Online")
I started making explanation command-by-command but it stopped making sense midway... Basic gist is to make full spiky box, and then hollow out the middle. I used Linq for the sake of using Linq, probably can be shorter using just standard iterations.
Here's explanation going middle-out (the inner-most command first):  
First, create rows for the full box, and concatenate to a single string
```
string.Concat(new int[a].Select(y => i % 2 == 0 ? "/\\" : "\\/"))
```
Then get each character in a row, and if it isn't the outline of the box, replace with space, concatenate them back into one string for each row
```
string.Concat(PREVIOUS_STEP.Select((y, j) => i > 0 & i < 2 * b - 1 & j > 0 & j < 2 * a - 1 ? " " : "" + y))
```
Finally, get each row and concatenate them together with newlines (also includes generating of a collection for rows)
```
string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));
```
]