İki pozitif tamsayı verildiğinde, W ve H, kenarları, üst ve alt kenarlarda W "çiviler" ve H ve sol ve sağ kenarlarda "çiviler" olan kenarları eğik çizgilerden ( /ve \) oluşan bir ASCII-sanat kutusu çıktılar . Kutunun içi boşluklarla dolu.

Bir "sivri" sadece bir ok şekli oluşturmak için bir araya gelen iki eğik çizgidir:

/\    \/

/      \
\      /

Yani için çıkış W = 4, H = 3olacağını

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

üstte 4 sivri, altta 4 sivri, solda 3 sivri ve sağda 3 sivri olduğu için.

İşte bazı diğer girdi / çıktı çiftleri:

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

Çıktıdaki hiçbir satırın başlarında ya da sonunda boşluk olmamalıdır. İsteğe bağlı olarak bir sondaki yeni satır olabilir.

Bayt cinsinden en kısa kod kazanır.

Kömür , 9 bayt

ＢײＮײＮ/\

Çevrimiçi deneyin!

açıklama

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

MATL , 18 bayt

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

MATL Online'da deneyin !

açıklama

Girişlerini düşünün W = 4, H = 3. Kod satır vektörleri inşa [1 2 3 4 5 6 7 8](kadar olan aralığın 1için 2*W) ve [1 2 3 4 5 6](kadar değişmektedir 1için 2*H). İkinciyi transpoze etmek ve yayınla bir öncekine eklemek matrisi verir

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

Dizeye modüler indeksleme \/, matris sınırında istenen sonucu üretir:

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

Kenarlık dışındaki değerleri kaldırmak için bunları şu şekilde ayarladık: 0(karakter olarak yorumlandığında boşluk olarak görüntülenir):

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

Yorumlanan kod:

'\/'    % 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 bayt

_{-1 Kevin Cruijssen sayesinde}

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

Çevrimiçi deneyin!

Haskell , 90 88 87 82 bayt

Lynn sayesinde 1 6 bayt kaydedildi

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

Çevrimiçi deneyin!

Hala çok uzun sürüyor, ne yapabilirim göreceğim.

05AB1E , 14 bayt

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

Çevrimiçi deneyin!

açıklama

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

Bu yalnızca sol üst köşeyi, x karakter genişliğini ve y karakter uzunluğunu oluşturur. Daha sonra bunu her iki eksende de yansıtır:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 bayt

Tımar sözdiziminde girişi Alır (w)(h).

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

gösteri

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 bayt

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

Tam test paketi.

Kapatma sürümü biraz daha uzun, ne yazık ki (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)}

Kapatma versiyonlu test takımı.

Retina , 77 73 bayt

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

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Biçiminde giriş alır <height> <width>. Açıklama:

\d+
$*

Girişleri birliğe dönüştürün.

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

Girdileri çarpın, ancak sonuç bir dikdörtgen olacak şekilde yeni bir satır ekleyin.

1
/\

Dikenli üst oluşturun.

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

Her sivri sırayı çoğaltın, ancak sivri uçları ikinci sıraya kaydırın.

¶$

Sondaki yeni satırları silin.

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

Kutunun içini silin. (Son satırdaki boşluğa dikkat edin.)

Excel, 95 bayt

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

APL (Dyalog) , 41 39 bayt

Listesi için bilgi istemi [H,W]

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

Çevrimiçi deneyin!

⎕-1 giriş istemi (anımsatıcı: stilize konsol) ve çıkarma 1

2× iki ile çarp

''⍴⍨ boş bir dize yeniden şekillendirmek için kullanın (boşluklu pedler)

⊢ verimini (ayırmak için hizmet eder 4)

{… }⍣4 Aşağıdaki işlevi dört kez uygulayın:

 ≢⍵ taksitli taksitli (uzunluğu)

 '/\'⍴⍨ siklik r eshape "/\"bu uzunlukta

 ⍵, bunu argümanın sağ tarafına ekle

 ⌽⍉ transpozisyon ve ayna (yani 90 ° döndür)

¯1⌽1 döngüsel 1 döndürmek ^st sağa satır bir adım

⊢ verimini (ayırmak için hizmet eder 1)

'\'@2@1 2'de ters eğik çizgi ^nd 1 pozisyonuna ^st önemli öğe.

C (gcc) ,170 166 158 155 108 105

Cleblanc sayesinde -3 bayt

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

Çevrimiçi deneyin!

Bunun daha az basit bir yaklaşımla daha fazla golf oynayabileceğini düşünüyorum, zamanı bulduğumda ne yapabileceğime bakacağım.

Tamam, bu kod için bayt sayısını azaltmanın başka bir yolunu bulamıyorum.

Açıklama: kutu char char char basit bir çift döngü.

Kenarlık yazdırırken: hem x hem de y koordinatları çift veya tek ise, a /, aksi takdirde a \görüntülenir

Kenarlık değilse, bunun yerine boşluk karakteri görüntülenir.

/// , 172 117 bayt

Dolayısıyla, çıktı ///s ve whitespaces'den oluştuğu için, bu 2 dilde gönderimler yapılmalıdır.

Koddan sonra girişi W,Hunary sayıya koyun ( öneri için Challenger5 sayesinde unary / // için izin verilir ) ( *rakamı temsil etmek için kullanın ,).

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

Çevrimiçi deneyin! (giriş ile W=4, H=3)

Python 3 , 87 82 bayt

Düzenleme: @officialaimm , @ Mr.Xcoder ve @tsh sayesinde 5 bayt kaydedildi

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

Çevrimiçi deneyin!

J, 48 bayt

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

ungolfed

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

açıklama

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

Çevrimiçi deneyin!

05AB1E , 19 bayt

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

Çevrimiçi deneyin!

Argümanları tersine çevirir.

Haskell , 84 79 bayt

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

Çevrimiçi deneyin! Örnek kullanım: 3%6satırların bir listesini verir. mapM putStrLn $ 3%6Kutuyu güzel yazdırmak için kullanın .

Java 8, 141 bayt

Genişlikten yükseğe çıkan bir köreli 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;}

Çevrimiçi Deneyin (hayır, return t+i+o;kasıtlı değildi)

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

Bu çözüm giriş genişliği konusunda tipik olarak seçicidir çünkü a char, genişlik girişine kadar saymak için kullanılır. Neyse ki, algoritma bu boyutlarda program tamamlama muhtemelen zaten bir sorun olacak kadar kötü. charDöngü endeksi için kullanmayı seçtim, böylece daha sonra ucuz bir takma ad olarak yeniden kullanabildim '\n'.

SOGL V0.12 , 22 21 13 bayt

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

Burada dene! (yığın üzerinde her iki girişi de bekler ..(ve "bir dize açıkça başlatılmadığı için) - kullanım kolaylığı için iki kez sayı girişi eklenir)

Açıklama:

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

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

Matematikte deneyin (nedense çoğu satırın başında ekstra boşluklar basar) veya Wolfram sanal alanında ! Giriş olarak iki tamsayı alır.

Oldukça saf bir çözüm, ancak denediğim tüm zekice şeylerin daha fazla baytı vardı. Neredeyse işe yarayan bir şey

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

her iki boyut da 1 ise başarısız olursa (giriş, boyutları içeren bir listedir).

Pyth , 40 39 38 bayt

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

Bu, yeni bir satırla ayrılmış iki tamsayı alır.

Tam test paketi.

Ruby , 62 61 60 bayt

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

Arnauld sayesinde -1 bayt

Çevrimiçi deneyin!

Aslında , 38 bayt

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

Çevrimiçi deneyin!

J , 39 bayt

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

Çevrimiçi deneyin!

heightLHS ve RHS'deki gibi iki argüman alır width.

VBA (Excel), 161 Bayt

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 bayt 152 bayt

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

Çevrimiçi deneyin!

8 byte'ı tıraş ettiğiniz için teşekkürler.

dc , 123 bayt

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

En kısa mesafeden uzak, ancak son iki çizgiyi alan ve bunları pi/2saat yönünde radyanı "dik" bir konuma döndürürse, bir tür totem direğine benziyor .

Girdiyi iki boşlukla ayrılmış tam sayı olarak alır.

Çevrimiçi deneyin!

Mathematica, 116 bayt

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

V , 18 bayt

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

Cevap gerektiren olmaz lleğer <M-h>ollowyalnız 2 karakter sütunları sol :(

Çevrimiçi deneyin!

C # (.NET Core) , 188 bayt

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

Bayt sayısı ayrıca şunları içerir:

using System.Linq;

Çevrimiçi deneyin!

Komut-by açıklama yapmaya başladım ama ortada mantıklı durdu ... Temel yumruk tam dikenli kutu yapmak ve sonra ortayı oymak. Linq'i kullanmak için Linq'i kullandım, muhtemelen sadece standart yinelemeleri kullanarak daha kısa olabilirdi.

İşte ortasındaki açıklama (ilk önce en içteki komut):
Önce, tüm kutu için satırlar oluşturun ve tek bir dizgeyle birleştirin.

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

Ardından her karakteri bir satırda alın ve kutunun dış çizgisi değilse, boşlukla değiştirin, bunları her satır için bir dizeye geri birleştirin

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

Son olarak, her satırı alın ve bunları yeni satırlarla birleştirin (ayrıca satırlar için bir koleksiyon oluşturmayı da içerir)

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

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

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

Çevrimiçi deneyin!