Bei zwei positiven Ganzzahlen, W und H, wird ein ASCII-Kunstfeld ausgegeben, dessen Rand aus Schrägstrichen ( /und \) mit W "Spitzen" am oberen und unteren Rand und H "Spitzen" am linken und rechten Rand besteht. Das Innere der Box ist mit Leerzeichen gefüllt.

Ein "Stachel" besteht einfach aus zwei Schrägstrichen, die eine Pfeilform bilden:

/\    \/

/      \
\      /

So ist der Ausgang für W = 4, H = 3wäre

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

da oben 4 Stacheln nach oben, unten 4 nach unten, links 3 nach links und rechts 3 nach rechts zeigen.

Hier sind einige andere Eingabe / Ausgabe-Paare:

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

In der Ausgabe dürfen keine Zeilen führende oder nachfolgende Leerzeichen enthalten. Es kann optional eine nachgestellte Newline geben.

Der kürzeste Code in Bytes gewinnt.

Kohle , 9 Bytes

ＢײＮײＮ/\

Probieren Sie es online!

Erläuterung

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

MATL , 18 Bytes

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

Probieren Sie es bei MATL Online!

Erläuterung

Betrachten Sie Eingänge W = 4, H = 3. Der Code erstellt die Zeilenvektoren [1 2 3 4 5 6 7 8](Bereich von 1bis 2*W) und [1 2 3 4 5 6](Bereich von 1bis 2*H). Das Transponieren des letzteren und das Hinzufügen des ersteren mit Broadcast ergibt die 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

Die modulare Indizierung in den String \/erzeugt das gewünschte Ergebnis in der Matrixgrenze:

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

Um die nicht umrandeten Werte zu entfernen, setzen wir sie auf 0(wenn sie als Zeichen interpretiert werden, werden sie als Leerzeichen angezeigt):

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

Kommentierter 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

Python 2 , 69 68 Bytes

_{-1 dank Kevin Cruijssen}

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

Probieren Sie es online!

Haskell , 90 88 87 82 Bytes

1 6 Bytes gespart dank Lynn

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

Probieren Sie es online!

Fühlt sich immer noch sehr lang an, ich werde sehen, was ich tun kann.

05AB1E , 14 Bytes

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

Probieren Sie es online!

Erläuterung

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

Dies erzeugt nur die linke obere Ecke, x Zeichen breit und y Zeichen hoch. Es spiegelt dies dann auf beiden Achsen wider:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 Byte

Übernimmt Eingaben in der 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>

Schnelle 3 , 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))}

Vollständige Testsuite.

Die Closure-Version ist leider etwas länger (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)}

Testsuite mit der Closure-Version.

Retina , 77 73 Bytes

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

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

Probieren Sie es online! Link enthält Testfälle. Übernimmt Eingaben im Format <height> <width>. Erläuterung:

\d+
$*

Konvertieren Sie die Eingaben in unary.

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

Multiplizieren Sie die Eingaben, fügen Sie jedoch eine neue Zeile hinzu, sodass das Ergebnis ein Rechteck ist.

1
/\

Kreieren Sie das stachelige Oberteil.

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

Duplizieren Sie jede stachelige Reihe, wobei die Stacheln in der zweiten Reihe versetzt sind.

¶$

Löschen Sie nachfolgende Zeilenumbrüche.

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

Löschen Sie das Innere der Box. (Beachten Sie das Leerzeichen in der letzten Zeile.)

Excel, 95 Bytes

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

APL (Dyalog) , 41 bis 39 Bytes

Fordert zur Eingabe einer Liste von auf [H,W]

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

Probieren Sie es online!

⎕-1 Eingabeaufforderung (Mnemonik: stilisierte Konsole) und subtrahieren 1

2× multiplizieren mit zwei

''⍴⍨ benutze das, um eine leere Zeichenkette umzuformen (Pads mit Leerzeichen)

⊢ ergeben, dass (dient zur Trennung von 4)

{… }⍣4 Wenden Sie die folgende Funktion viermal an:

 ≢⍵ Bestimmen Sie die Länge des Arguments

 '/\'⍴⍨ zyklisch r eshape "/\"auf diese Länge

 ⍵, Hänge das an die rechte Seite des Arguments an

 ⌽⍉ transponieren und spiegeln (dh um 90 ° drehen)

¯1⌽1 drehen , um die zyklisch 1 ^st Reihe einen Schritt nach rechts ,

⊢ ergeben, dass (dient zur Trennung von 1)

'\'@2@1 legt einen umgekehrten Schrägstrich in der 2 ^nd Position des 1 ^st Hauptpunktes.

C (gcc) ,170 166 158 155 108 105

-3 Bytes dank 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);}

Probieren Sie es online!

Ich denke, dies kann mit einer weniger einfachen Herangehensweise weiter golfen werden. Ich werde sehen, was ich tun kann, wenn ich die Zeit finde.

Ok, ich kann keinen anderen Weg finden, um die Anzahl der Bytes für diesen Code zu reduzieren.

Erklärung: Eine einfache Doppelschleife, die die Box char für char druckt.

Beim Drucken eines Rahmens: Wenn sowohl die x- als auch die y-Koordinate gerade oder ungerade sind, wird a angezeigt /, andernfalls wird a \angezeigt

Wenn kein Rand vorhanden ist, wird stattdessen ein Leerzeichen angezeigt

/// , 172 117 Bytes

Da die Ausgabe also aus ///s und whitespaces besteht, sollte es Übermittlungen in diesen beiden Sprachen geben.

Geben Sie den Code nach der Eingabe W,Hals unäre Zahl ein (unär für /// ist zulässig , dank Challenger5 für Vorschläge) ( *zur Darstellung von Ziffern, getrennt durch ,).

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

Probieren Sie es online! (mit Eingabe W=4, H=3)

Python 3 , 87 82 Bytes

Bearbeiten: 5 Bytes dank @officialaimm , @ Mr.Xcoder und @tsh gespeichert

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

Probieren Sie es online!

J, 48 Bytes

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

ungolfed

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

Erläuterung

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

Probieren Sie es online!

05AB1E , 19 Bytes

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

Probieren Sie es online!

Argumente werden umgekehrt.

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

Probieren Sie es online! Anwendungsbeispiel: 3%6Gibt eine Liste von Zeilen aus. Verwenden Sie mapM putStrLn $ 3%6diese Option, um die Schachtel hübsch zu drucken.

Java 8, 141 Bytes

Ein Curry-Lambda von der Breite zur Höhe bis zur Ausgabe.

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

Online testen (nein, return t+i+o;war nicht beabsichtigt)

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

Diese Lösung ist in Bezug charauf die Eingabegröße untypisch wählerisch, da mit a bis zur Eingabe der Breite gezählt wird. Glücklicherweise ist der Algorithmus so schlecht, dass bei diesen Größen der Abschluss des Programms wahrscheinlich bereits ein Problem darstellt. Ich habe mich charfür den Schleifenindex entschieden, damit ich ihn später als billigen Alias ​​für wiederverwenden kann '\n'.

SOGL V0.12 , 22 21 13 Bytes

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

Probieren Sie es hier aus!(Erwartet beide Eingaben auf dem Stack, ..und "da eine Zeichenfolge nicht explizit gestartet wurde) - Zweimalige Eingabe der Zahl wird zur Vereinfachung hinzugefügt.)

Erläuterung:

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

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

Probieren Sie es in Mathematik (es druckt aus irgendeinem Grund zusätzliche Leerzeichen am Anfang der meisten Zeilen) oder in der Wolfram-Sandbox aus ! Nimmt zwei Ganzzahlen als Eingabe.

Es ist eine ziemlich naive Lösung, aber all die cleveren Dinge, die ich ausprobiert habe, hatten mehr Bytes. Etwas, das fast funktioniert, ist

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

außer es schlägt fehl, wenn eine der Dimensionen 1 ist (Eingabe ist eine Liste mit den Dimensionen).

Pyth , 40 39 38 Bytes

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

Dies nimmt die zwei durch eine neue Zeile getrennten Ganzzahlen.

Vollständige Testsuite.

Ruby , 62 61 60 Bytes

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

-1 Byte danke an Arnauld

Probieren Sie es online!

Eigentlich 38 Bytes

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

Probieren Sie es online!

J , 39 Bytes

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

Probieren Sie es online!

Nimmt zwei Argumente wie heightauf der LHS und widthauf der 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)))}

Probieren Sie es online!

Danke, BLT, dass du 8 Bytes gespart hast.

Gleichstrom , 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

Es ist bei weitem nicht das kürzeste, aber wenn man die letzten beiden Zeilen nimmt und sie dreht pi/2 im Uhrzeigersinn in eine "aufrechte" Position , sieht es wie ein Totempfahl aus .

Nimmt die Eingabe als zwei durch Leerzeichen getrennte Ganzzahlen.

Probieren Sie es 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è

Für die Beantwortung wäre das llif nicht erforderlich<M-h>ollow nur 2 Zeichenspalten übrig :(

Probieren Sie es online!

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

Die Byteanzahl umfasst auch:

using System.Linq;

Probieren Sie es online!

Ich habe angefangen, Erklärungen von Kommando zu Kommando zu machen, aber es ergab auf halbem Weg keinen Sinn mehr. Ich habe Linq aus Gründen der Verwendung von Linq verwendet, wahrscheinlich kann es mit nur Standarditerationen kürzer sein.

Hier ist eine Erklärung, die mit der Mitte nach außen geht (der innerste Befehl zuerst):
Erstellen Sie zuerst Zeilen für die gesamte Box und verketten Sie sie zu einer einzelnen Zeichenfolge

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

Holen Sie sich dann jedes Zeichen in einer Reihe, und wenn es nicht der Umriss des Kästchens ist, ersetzen Sie es durch ein Leerzeichen, und verknüpfen Sie sie für jede Reihe wieder zu einer Zeichenfolge

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

Holen Sie sich schließlich jede Zeile und verknüpfen Sie sie mit Zeilenumbrüchen (einschließlich der Erstellung einer Auflistung für Zeilen).

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

Probieren Sie es online!