Biorąc pod uwagę dwie dodatnie liczby całkowite, W i H, generuje pole ASCII-art, którego ramka składa się z ukośników ( /i \) z W „pikami” na górnej i dolnej krawędzi oraz H „pikami” na lewej i prawej krawędzi. Wnętrze skrzynki jest wypełnione spacjami.

„Kolec” to po prostu dwa ukośniki łączące się w kształt strzałki:

/\    \/

/      \
\      /

Więc wynik W = 4, H = 3byłby

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

ponieważ na górze znajdują się 4 kolce skierowane w górę, 4 na dole skierowane w dół, 3 po lewej skierowane w lewo i 3 po prawej skierowane w prawo.

Oto kilka innych par wejścia / wyjścia:

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

Żadne wiersze na wyjściu nie powinny mieć spacji wiodących ani końcowych. Opcjonalnie może istnieć jedna nowa linia.

Najkrótszy kod w bajtach wygrywa.

Węgiel , 9 bajtów

ＢײＮײＮ/\

Wypróbuj online!

Wyjaśnienie

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

MATL , 18 bajtów

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

Wypróbuj w MATL Online!

Wyjaśnienie

Rozważmy wejść W = 4, H = 3. Kod buduje wektory wierszowe [1 2 3 4 5 6 7 8](zakres od 1do 2*W) i [1 2 3 4 5 6](zakres od 1do 2*H). Przeniesienie tego drugiego i dodanie do tego pierwszego z transmisją daje macierz

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

Modułowe indeksowanie w łańcuchu \/daje pożądany wynik w ramce macierzy:

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

Aby usunąć wartości bez obramowania, ustawiamy je na 0(interpretowane jako char jest wyświetlane jako spacja):

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

Skomentowany 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 bajtów

_{-1 dzięki Kevin Cruijssen}

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

Wypróbuj online!

Haskell , 90 88 87 82 bajtów

1 6 bajtów zapisanych dzięki Lynn

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

Wypróbuj online!

Nadal czuję się naprawdę długo, zobaczę, co mogę zrobić.

05AB1E , 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Tworzy to tylko lewy górny róg, szerokość x znaków i wysokość y znaków. Następnie odzwierciedla to w obu osiach:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 bajtów

Pobiera dane wejściowe w składni curry (w)(h).

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

Próbny

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 bajtów

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

Pełny zestaw testów.

Niestety wersja zamknięcia jest nieco dłuższa (175 bajtów):

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

Zestaw testowy z wersją zamknięcia.

Retina , 77 73 bajtów

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

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

Wypróbuj online! Link zawiera przypadki testowe. Pobiera dane wejściowe w formacie <height> <width>. Wyjaśnienie:

\d+
$*

Konwertuj wejścia na unary.

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

Pomnóż dane wejściowe, ale dodaj nowy wiersz, aby wynik był prostokątem.

1
/\

Stwórz kolczasty top.

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

Duplikuj każdy kolczasty rząd, ale z przesunięciem kolców w drugim rzędzie.

¶$

Usuń końcowe znaki nowej linii.

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

Usuń wnętrze pudełka. (Uwaga spacja w ostatnim wierszu.)

Excel, 95 bajtów

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

APL (Dyalog) , 41 39 bajtów

Monity o listę [H,W]

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

Wypróbuj online!

⎕-1 monit o wprowadzenie (mnemonic: stylizowana konsola) i odjęcie 1

2× pomnóż przez dwa

''⍴⍨ użyj tego, aby przekształcić pusty ciąg (pola ze spacjami)

⊢ wydajność, która (służy do jej oddzielenia 4)

{… }⍣4 Zastosuj następującą funkcję cztery razy:

 ≢⍵ Tally (długość) argumentu

 '/\'⍴⍨ cyklicznie r eshape "/\"tej długości

 ⍵, dołącz to po prawej stronie argumentu

 ⌽⍉ transpozycja i odbicie lustrzane (tj. obrót o 90 °)

¯1⌽1 cyklicznie obracaj ^pierwszy rząd o jeden krok w prawo

⊢ wydajność, która (służy do jej oddzielenia 1)

'\'@2@1 wprowadzić odwrotny ukośnik na 2 ^nd pozycji 1 ^st głównego elementu.

C (gcc) ,170 166 158 155 108 105

-3 bajty dzięki 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);}

Wypróbuj online!

Myślę, że można to pograć w golfa przy mniej prostym podejściu. Zobaczę, co da się zrobić, kiedy znajdę czas.

Ok nie mogę znaleźć innego sposobu na zmniejszenie liczby bajtów dla tego kodu.

Objaśnienie: prosta podwójna pętla drukująca pole char po char.

Podczas drukowania ramki: jeśli współrzędne xiy są parzyste lub nieparzyste, wyświetla a /, w przeciwnym razie a\ wyświetla się a

Jeśli nie jest obramowaniem, zamiast niego wyświetlany jest znak spacji

/// , 172 117 bajtów

Ponieważ dane wyjściowe składają się z ///s i whitespaces, należy przesyłać dane w tych 2 językach.

Umieść dane wejściowe za kodem W,Hjako liczbę jednoznaczną (unary dla /// jest dozwolone , dzięki Challenger5 dla sugestii) (użyj *do przedstawienia cyfry, oddziel od ,).

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

Wypróbuj online! (z wejściem W=4, H=3)

Python 3 , 87 82 bajtów

Edycja: Zapisano 5 bajtów dzięki @officialaimm , @ Mr.Xcoder i @tsh

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

Wypróbuj online!

J, 48 bajtów

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

bez golfa

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

wyjaśnienie

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

Wypróbuj online!

05AB1E , 19 bajtów

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

Wypróbuj online!

Odwraca argumenty.

Haskell , 84 79 bajtów

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

Wypróbuj online! Przykładowe użycie: 3%6daje listę linii. Służy mapM putStrLn $ 3%6do ładnego wydrukowania pudełka.

Java 8, 141 bajtów

Curled lambda od szerokości do wysokości do wyjścia.

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

Wypróbuj online (nie,return t+i+o; nie było zamierzone)

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

To rozwiązanie jest nietypowo wybredne pod względem wielkości wejściowej, ponieważ a charsłuży do zliczania do szerokości wejściowej. Na szczęście algorytm jest na tyle zły, że przy tych rozmiarach ukończenie programu prawdopodobnie już stanowi problem. Zdecydowałem się użyć charindeksu pętli, aby móc go później użyć jako taniego aliasu '\n'.

SOGL V0.12 , 22 21 13 bajtów

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

Wypróbuj tutaj! (oczekuje obu danych wejściowych na stosie, więc ..(i" ponieważ ciąg nie został jawnie uruchomiony) - weź dwa razy dane wejściowe, aby ułatwić obsługę)

Wyjaśnienie:

/\”            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 bajtów

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

Wypróbuj w Mathics (z jakiegoś powodu drukuje dodatkowe spacje na początku większości linii) lub w piaskownicy Wolfram ! Pobiera na wejściu dwie liczby całkowite.

To dość naiwne rozwiązanie, ale wszystkie sprytne rzeczy, których próbowałem, miały więcej bajtów. Coś, co prawie działa

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

z wyjątkiem tego, że nie powiedzie się, jeśli jeden z wymiarów ma wartość 1 (wejście to lista zawierająca wymiary).

Pyth , 40 39 38 bajtów

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

To bierze dwie liczby całkowite oddzielone znakiem nowej linii.

Pełny zestaw testów.

Rubin , 62 61 60 bajtów

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

-1 bajt dzięki Arnauldowi

Wypróbuj online!

Właściwie 38 bajtów

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

Wypróbuj online!

J , 39 bajtów

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

Wypróbuj online!

Przyjmuje dwa argumenty, jak heightw przypadku LHS i widthRHS.

VBA (Excel), 161 bajtów

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 bajtów 152 bajty

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

Wypróbuj online!

Dzięki BLT za golenie 8 bajtów.

dc , 123 bajty

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

Jest daleki od najkrótszego, ale jeśli weźmie się dwie ostatnie linie i obróci je pi/2radianami zgodnie z ruchem wskazówek zegara do pozycji „pionowej”, to wygląda to jak słup totemu .

Pobiera dane wejściowe jako dwie liczby całkowite oddzielone spacjami.

Wypróbuj online!

Mathematica, 116 bajtów

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

V , 18 bajtów

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

Odpowiedź nie wymagałaby lltylko <M-h>ollowpozostawienia 2 kolumn char :(

Wypróbuj online!

C # (.NET Core) , 188 bajtów

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

Liczba bajtów obejmuje również:

using System.Linq;

Wypróbuj online!

Zacząłem wyjaśniać polecenie po poleceniu, ale przestało to mieć sens w połowie ... Podstawową zasadą jest zrobienie pełnego kolczastego pudełka, a następnie wydrążenie środka. Użyłem Linq ze względu na użycie Linq, prawdopodobnie może być krótszy przy użyciu standardowych iteracji.

Oto wyjaśnienie idące na środek (najpierw wewnętrzna komenda):
Najpierw utwórz wiersze dla pełnego pola i połącz w pojedynczy ciąg

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

Następnie weź każdy znak z rzędu, a jeśli nie jest to obrys ramki, zastąp spacją, połącz je z powrotem w jeden ciąg dla każdego rzędu

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

Na koniec pobierz każdy wiersz i połącz je razem z nowymi wierszami (obejmuje również generowanie kolekcji dla wierszy)

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!