รับจำนวนเต็มบวกสองค่า W และ H ส่งออกกล่อง ASCII-art ซึ่งเส้นขอบทำจากเครื่องหมายทับ ( /และ\) ด้วย W "spikes" ที่ขอบด้านบนและด้านล่างและ H "spikes" ที่ขอบซ้ายและขวา การตกแต่งภายในของกล่องเต็มไปด้วยช่องว่าง

"ขัดขวาง" เป็นเพียงสองสแลชมารวมกันเพื่อสร้างรูปร่างลูกศร:

/\    \/

/      \
\      /

ดังนั้นผลลัพธ์สำหรับW = 4, H = 3จะเป็น

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

เนื่องจากมีหนามแหลมด้านบนชี้ขึ้น 4 ตัว 4 ที่ด้านล่างชี้ลง 3 ด้านซ้ายชี้ไปทางซ้ายและ 3 ทางขวาชี้

นี่คือคู่ของอินพุต / เอาท์พุตอื่น ๆ :

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

ไม่มีบรรทัดในผลลัพธ์ควรมีช่องว่างนำหน้าหรือต่อท้าย อาจมีทางเลือกขึ้นบรรทัดใหม่หนึ่งบรรทัด

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ถ่าน 9 ไบต์

ＢײＮײＮ/\

ลองออนไลน์!

คำอธิบาย

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

MATL , 18 ไบต์

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

ลองที่MATL Online!

คำอธิบาย

พิจารณาอินพุต W = 4 , H = 3. รหัสนี้สร้างเวกเตอร์แถว[1 2 3 4 5 6 7 8](ช่วงจาก1ถึง2*W) และ[1 2 3 4 5 6](ช่วงจาก1ถึง2*H) การสลับตำแหน่งหลังและเพิ่มเข้าไปในอดีตด้วยการออกอากาศจะให้เมทริกซ์

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

การทำดัชนีแบบแยกส่วนลงในสตริง\/จะสร้างผลลัพธ์ที่ต้องการในขอบเมทริกซ์:

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

ในการลบค่าที่ไม่ใช่เส้นขอบเราตั้งค่าเป็น0(เมื่อตีความว่าเป็นอักขระจะแสดงเป็นช่องว่าง):

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

รหัสความคิดเห็น:

'\/'    % 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 ไบต์

_{-1 ต้องขอบคุณKevin Cruijssen}

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

ลองออนไลน์!

Haskell , 90 88 87 82 ไบต์

1 6 ไบต์ได้รับการบันทึกด้วย Lynn

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

ลองออนไลน์!

ยังคงรู้สึกยาวจริงๆฉันจะเห็นสิ่งที่ฉันสามารถทำได้

05AB1E , 14 ไบต์

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

ลองออนไลน์!

คำอธิบาย

„/\|∍`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

สิ่งนี้จะสร้างมุมซ้ายด้านบนกว้าง x ตัวอักษรและ y ตัวสูง จากนั้นจะสะท้อนสิ่งนี้บนแกนทั้งสอง:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 ไบต์

(w)(h)จะเข้าในไวยากรณ์ currying

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

การสาธิต

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>

สวิฟท์ 3 , 166 ไบต์

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

ชุดทดสอบเต็มรูปแบบ

เวอร์ชันปิดจะใช้เวลานานขึ้นโชคไม่ดี (175 ไบต์):

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

ชุดทดสอบที่มีรุ่นปิด

เรติน่า , 77 73 ไบต์

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

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ <height> <width>จะเข้าในรูปแบบ คำอธิบาย:

\d+
$*

แปลงอินพุตเป็น unary

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

คูณอินพุต แต่เพิ่มบรรทัดใหม่เพื่อให้ผลลัพธ์เป็นรูปสี่เหลี่ยมผืนผ้า

1
/\

สร้างยอดแหลม

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

ทำซ้ำแต่ละแถวแหลมคม แต่มียอดแหลมตรงข้ามกับแถวที่สอง

¶$

ลบการขึ้นบรรทัดใหม่

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

ลบด้านในของกล่อง (พื้นที่หมายเหตุบนบรรทัดสุดท้าย)

Excel, 95 ไบต์

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

APL (Dyalog) , 41 39 ไบต์

แจ้งให้รายการ [H,W]

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

ลองออนไลน์!

⎕-1 พรอมต์สำหรับการป้อนข้อมูล (ช่วยในการจำ: คอนโซลที่มีสไตล์) และลบ 1

2× คูณด้วยสอง

''⍴⍨ ใช้สิ่งนั้นเพื่อปรับรูปร่างสตริงว่าง (แผ่นที่มีช่องว่าง)

⊢ ให้ผลลัพธ์ที่ (ทำหน้าที่แยกจาก4)

{… }⍣4 ใช้ฟังก์ชั่นต่อไปนี้สี่ครั้ง:

 ≢⍵ tally (ยาว) อาร์กิวเมนต์

 '/\'⍴⍨ วนr eshape "/\"กับความยาวที่

 ⍵, ผนวกที่ด้านขวาของการโต้แย้ง

 ⌽⍉ ไขว้และกระจก (เช่นเลี้ยว 90 °)

¯1⌽1 วนหมุน 1 ^{เซนต์}ขั้นตอนหนึ่งแถวไปทางขวา

⊢ ให้ผลลัพธ์ที่ (ทำหน้าที่แยกจาก1)

'\'@2@1 ใส่เครื่องหมายที่ 2 ^{ครั้งที่}ตำแหน่งของ 1 ^{เซนต์}รายการที่สำคัญ

C (GCC) ,170 166 158 155 108 105

-3 ไบต์ขอบคุณ 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);}

ลองออนไลน์!

ฉันคิดว่าสิ่งนี้สามารถตีกอล์ฟต่อไปได้ด้วยวิธีการที่ตรงไปตรงมาน้อยกว่าฉันจะเห็นสิ่งที่ฉันสามารถทำได้เมื่อฉันหาเวลา

ตกลงฉันไม่สามารถหาวิธีอื่นเพื่อลดจำนวนไบต์สำหรับรหัสนั้น

คำอธิบาย: การพิมพ์สองรอบอย่างง่าย ๆ กล่องถ่านโดยถ่าน

เมื่อพิมพ์เส้นขอบ: หากทั้งพิกัด x และ y เป็นเลขคู่หรือคี่จะแสดงเป็น/หรือมิฉะนั้น a \จะปรากฏขึ้น

หากไม่ใช่เส้นขอบอักขระเว้นวรรคจะปรากฏขึ้นแทน

/// , 172 117 ไบต์

ดังนั้นเนื่องจากผลลัพธ์ประกอบด้วย///s และ whitespaces ควรมีการส่งใน 2 ภาษาเหล่านั้น

ใส่ข้อมูลที่ป้อนหลังจากโค้ดในW,Hรูปแบบหมายเลขเอกนารี ( อนุญาตให้เป็นเอกภาพสำหรับ /// ขอขอบคุณ Challenger5 สำหรับคำแนะนำ) (ใช้*เพื่อเป็นตัวแทนตัวเลขแยกต่างหากด้วย,) รูปแบบ

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

ลองออนไลน์! (พร้อมอินพุตW=4, H=3)

Python 3 , 87 82 ไบต์

แก้ไข:บันทึก 5 ไบต์ด้วย@officialaimm , @ Mr.Xcoderและ@tsh

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

ลองออนไลน์!

J, 48 ไบต์

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

ungolfed

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

คำอธิบาย

                       (+:@[ $ (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

ลองออนไลน์!

05AB1E , 19 ไบต์

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

ลองออนไลน์!

รับอาร์กิวเมนต์ที่กลับด้าน

Haskell , 84 79 ไบต์

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

ลองออนไลน์! ตัวอย่างการใช้งาน: 3%6ให้รายการของบรรทัด ใช้mapM putStrLn $ 3%6ในการพิมพ์กล่องสวย ๆ

Java 8, 141 ไบต์

แลมบ์ดาที่แกงจากความกว้างถึงความสูงถึงเอาท์พุท

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

ลองใช้ออนไลน์ (ไม่return t+i+o;ไม่ได้ตั้งใจ)

แลมบ์ดา

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

วิธีนี้เป็นเรื่องพิถีพิถันเกี่ยวกับขนาดอินพุตเนื่องจาก a charจะใช้ในการนับจนถึงความกว้างอินพุต โชคดีที่อัลกอริทึมแย่พอที่ขนาดโปรแกรมที่เสร็จสมบูรณ์แล้วอาจเป็นปัญหาอยู่แล้ว ฉันเลือกที่จะใช้สำหรับดัชนีห่วงดังนั้นฉันสามารถนำมาใช้ใหม่ได้ในภายหลังเป็นชื่อแทนราคาถูกสำหรับchar'\n'

SOGL V0.12 , 22 21 13 ไบต์

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

ลองที่นี่! (คาดว่าทั้งสองอินพุทจะซ้อนกัน.. (และ"เนื่องจากสตริงยังไม่ได้เริ่มต้นอย่างชัดเจน) - ใช้การป้อนหมายเลขสองครั้งเพื่อเพิ่มความสะดวกในการใช้งาน)

คำอธิบาย:

/\”            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 ไบต์

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

ลองใช้ในMathics (พิมพ์ช่องว่างเพิ่มเติมที่จุดเริ่มต้นของบรรทัดส่วนใหญ่ด้วยเหตุผลบางอย่าง) หรือที่Sandram Wolfram ! ใช้จำนวนเต็มสองจำนวนเป็นอินพุต

มันเป็นวิธีการแก้ปัญหาที่ไร้เดียงสา แต่สิ่งที่ฉลาดทั้งหมดที่ฉันได้ลองมีจำนวนไบต์มากกว่า สิ่งที่เกือบจะได้ผลคือ

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

ยกเว้นว่าจะล้มเหลวหากขนาดใดมิติหนึ่งเป็น 1 (อินพุตคือรายการที่มีมิติข้อมูล)

Pyth , 40 39 38 ไบต์

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

สิ่งนี้จะใช้จำนวนเต็มสองจำนวนคั่นด้วยการขึ้นบรรทัดใหม่

ชุดทดสอบเต็มรูปแบบ

Ruby , 62 61 60 ไบต์

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

-1 ไบต์ขอบคุณ Arnauld

ลองออนไลน์!

ที่จริงแล้ว 38 ไบต์

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

ลองออนไลน์!

J, 39 bytes

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

Try it online!

Takes two arguments as height on the LHS and width on the 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 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!

Thanks BLT for shaving off 8 bytes.

dc, 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.

Takes input as two space-separated integers.

Try it online!

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]}])&

V, 18 bytes

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

Answer wouldn't require the ll if <M-h>ollow left 2 char columns alone :(

Try it online!

C# (.NET Core), 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!

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

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

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

Try it online!