Cho hai số nguyên dương, W và H, xuất ra hộp nghệ thuật ASCII có đường viền được tạo bởi các dấu gạch chéo ( /và \) với W "gai" ở cạnh trên và dưới và H "gai" ở cạnh trái và phải. Nội thất của chiếc hộp chứa đầy không gian.

Một "mũi nhọn" chỉ đơn giản là hai dấu gạch chéo kết hợp với nhau để tạo thành hình mũi tên:

/\    \/

/      \
\      /

Vì vậy, đầu ra cho W = 4, H = 3sẽ là

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

vì có 4 gai trên đỉnh chỉ lên, 4 ở dưới cùng chỉ xuống, 3 ở bên trái chỉ bên trái và 3 ở bên phải chỉ bên phải.

Dưới đây là một số cặp đầu vào / đầu ra khác:

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

Không có dòng nào trong đầu ra nên có khoảng trắng ở đầu hoặc cuối. Có thể tùy chọn có một dòng mới.

Mã ngắn nhất tính bằng byte thắng.

Than , 9 byte

ＢײＮײＮ/\

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

Giải trình

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

MATL , 18 byte

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

Hãy thử nó tại MATL Online!

Giải trình

Xem xét đầu vào W = 4, H = 3. Mã xây dựng các vectơ hàng [1 2 3 4 5 6 7 8](phạm vi từ 1đến 2*W) và [1 2 3 4 5 6](phạm vi từ 1đến 2*H). Chuyển đổi cái sau và thêm vào cái trước với phát sóng cho ma trận

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

Lập chỉ mục mô-đun vào chuỗi \/tạo ra kết quả mong muốn trong viền ma trận:

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

Để xóa các giá trị không biên giới, chúng tôi đặt chúng thành 0(khi được hiểu là char, nó được hiển thị dưới dạng khoảng trắng):

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

Mã nhận xét:

'\/'    % 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 cảm ơn Kevin Cruijssen}

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

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

Haskell , 90 88 87 82 byte

1 6 byte được lưu nhờ Lynn

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

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

Vẫn cảm thấy rất dài, tôi sẽ thấy những gì tôi có thể làm.

05AB1E , 14 byte

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

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

Giải trình

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

Điều này chỉ tạo góc trên cùng bên trái, x ký tự rộng và y cao. Sau đó, nó phản chiếu điều này trên cả hai trục:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 byte

Đưa đầu vào theo cú pháp currying (w)(h).

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

Bản giới thiệu

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

Bộ kiểm tra đầy đủ.

Phiên bản đóng cửa dài hơn một chút, thật không may (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)}

Bộ thử nghiệm với phiên bản đóng cửa.

Võng mạc , 77 73 byte

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

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đưa đầu vào theo định dạng <height> <width>. Giải trình:

\d+
$*

Chuyển đổi các đầu vào để unary.

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

Nhân các đầu vào, nhưng thêm một dòng mới để kết quả là một hình chữ nhật.

1
/\

Tạo đỉnh nhọn.

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

Sao chép từng hàng nhọn, nhưng với phần bù nhọn trên hàng thứ hai.

¶$

Xóa các dòng mới.

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

Xóa bên trong hộp. (Lưu ý không gian trên dòng cuối cùng.)

Excel, 95 byte

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

APL (Dyalog) , 41 39 byte

Nhắc cho một danh sách [H,W]

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

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

⎕-1 lời nhắc cho đầu vào (mnemonic: giao diện điều khiển cách điệu) và trừ 1

2× nhân với hai

''⍴⍨ sử dụng điều đó để định hình lại một chuỗi rỗng (phần đệm có khoảng trắng)

⊢ mang lại (phục vụ để tách nó khỏi 4)

{... }⍣4 áp dụng các chức năng sau bốn lần:

 ≢⍵ kiểm đếm (độ dài) của đối số

 '/\'⍴⍨ chu kỳ r eshape "/\"đến chiều dài đó

 ⍵, nối nó vào bên phải của đối số

 ⌽⍉ chuyển vị và gương (tức là quay 90 °)

¯1⌽1 xoay vòng theo hàng ^thứ nhất một bước sang phải

⊢ mang lại (phục vụ để tách nó khỏi 1)

'\'@2@1 đặt dấu gạch chéo ngược ở vị trí ^{thứ 2} của mục chính ^thứ 1 .

C (gcc) ,170 166 158 155 108 105

-3 byte nhờ 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);}

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

Tôi nghĩ rằng điều này có thể được đánh gôn hơn nữa với cách tiếp cận ít đơn giản hơn, tôi sẽ thấy những gì tôi có thể làm khi tìm thấy thời gian.

Ok tôi không thể tìm thấy bất kỳ cách nào khác để giảm số lượng byte cho mã đó.

Giải thích: một vòng lặp đơn giản in hộp char bằng char.

Khi in đường viền: nếu cả hai tọa độ x và y là chẵn hoặc lẻ, nó sẽ hiển thị a /, nếu không, a \được hiển thị

Nếu không phải là viền, một ký tự khoảng trắng được hiển thị thay thế

/// , 172 117 byte

Vì vậy, vì đầu ra bao gồm ///s và whitespaces, nên có các bài nộp trong 2 ngôn ngữ đó.

Đặt đầu vào sau mã W,Hdưới dạng số đơn (unary cho /// được cho phép , nhờ Challenger5 cho đề xuất) (sử dụng *để biểu thị chữ số, tách biệt với ,) định dạng.

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

Hãy thử trực tuyến! (có đầu vào W=4, H=3)

Python 3 , 87 82 byte

Chỉnh sửa: Đã lưu 5 byte nhờ @officialaimm , @ Mr.Xcoder và @tsh

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

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

J, 48 byte

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

vô dụng

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

giải trình

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

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

05AB1E , 19 byte

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

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

Đưa ra lập luận đảo ngược.

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

Hãy thử trực tuyến! Ví dụ sử dụng: 3%6mang lại một danh sách các dòng. Sử dụng mapM putStrLn $ 3%6để in đẹp hộp.

Java 8, 141 byte

Một lambda cuộn từ chiều rộng đến chiều cao để đầu ra.

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

Dùng thử trực tuyến (không, return t+i+o;không cố ý)

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

Giải pháp này rất kén chọn về kích thước đầu vào vì a charđược sử dụng để đếm đến đầu vào chiều rộng. May mắn thay, thuật toán đủ tệ đến mức ở những kích thước đó, việc hoàn thành chương trình có lẽ đã là một vấn đề. Tôi đã chọn sử dụng charcho chỉ mục vòng lặp để tôi có thể sử dụng lại sau này như một bí danh giá rẻ cho '\n'.

SOGL V0.12 , 22 21 13 byte

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

Hãy thử nó ở đây! (mong đợi cả hai đầu vào trên stack vì vậy ..(và "vì một chuỗi chưa được bắt đầu rõ ràng) - hãy thêm số đầu vào hai lần để dễ sử dụng)

Giải trình:

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

Toán học, 87 byte

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

Hãy thử nó trong Mathics (nó in thêm khoảng trắng ở đầu hầu hết các dòng vì một số lý do) hoặc tại hộp cát Wolfram ! Lấy hai số nguyên làm đầu vào.

Đó là một giải pháp khá ngây thơ, nhưng tất cả những điều thông minh mà tôi đã thử có nhiều byte hơn. Một cái gì đó gần như hoạt động là

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

ngoại trừ thất bại nếu một trong hai chiều là 1 (đầu vào là danh sách chứa các kích thước).

Bình thường , 40 39 38 byte

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

Điều này có hai số nguyên cách nhau bởi một dòng mới.

Bộ kiểm tra đầy đủ.

Ruby , 62 61 60 byte

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

-1 byte nhờ Arnauld

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

Trên thực tế , 38 byte

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

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

J , 39 byte

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

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

Có hai đối số như heighttrên LHS và widthtrên RHS.

VBA (Excel), 161 byte

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

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

Cảm ơn BLT đã cạo sạch 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

Nó cách xa ngắn nhất, nhưng, nếu người ta lấy hai dòng cuối cùng và xoay chúng pi/2theo chiều kim đồng hồ đến vị trí "thẳng đứng", thì nó trông giống như một cột totem .

Lấy đầu vào là hai số nguyên cách nhau không gian.

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

Toán học, 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è

Trả lời sẽ không yêu cầu llnếu chỉ <M-h>ollowcòn lại 2 cột char :(

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

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

Số lượng byte cũng bao gồm:

using System.Linq;

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

Tôi bắt đầu đưa ra lời giải thích theo từng mệnh lệnh nhưng nó đã ngừng có ý nghĩa giữa chừng ... Ý chính cơ bản là tạo ra một hộp đầy gai nhọn, và sau đó rỗng ra giữa. Tôi đã sử dụng Linq vì mục đích sử dụng Linq, có thể ngắn hơn khi chỉ sử dụng các lần lặp tiêu chuẩn.

Đây là lời giải thích đi ra giữa (lệnh bên trong nhất trước tiên):
Đầu tiên, tạo các hàng cho hộp đầy đủ và nối với một chuỗi

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

Sau đó, nhận từng ký tự trong một hàng và nếu đó không phải là phác thảo của hộp, hãy thay thế bằng khoảng trắng, nối chúng lại thành một chuỗi cho mỗi hàng

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

Cuối cùng, nhận từng hàng và nối chúng với các dòng mới (cũng bao gồm việc tạo bộ sưu tập cho các hàng)

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

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