31

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.

— Calvins Hobbys
quelle

Kann jemand, der Javascripts verwendet , einen Stack-Snippet dafür erstellen?

— FantaC

15

Kohle , 9 Bytes

Ｂ×²Ｎ×²Ｎ/\

Probieren Sie es online!

Erläuterung

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

— Nur ASCII
quelle

3

Natürlich hat Charcoal eine eingebaute "Ziehbox"

— Benzol

1

@benzene Es war ein bisschen glücklich, dass er kürzlich die Möglichkeit hinzugefügt hat, eine beliebige Zeichenfolge um die Box zu ziehen, aber schon vorher gab es Antworten wie codegolf.stackexchange.com/a/120065

— Neil

1

@Neil vor kurzem warten? Wann? (Kenne ich Charcoal weniger gut, danke? Haha)

— Nur ASCII

@ Nur ASCII Mein schlechtes! Ich war verwirrt wegen der Änderung, die die Cursorpositionierung zurückführte. (Die Änderung, die die willkürliche Grenzzeichenfolge einführte, war ca904b0, was fast ein Jahr her ist.)

— Neil

@benzene Ohne die eingebaute Box sind es immer noch nur 13 Bytes: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(Eingabe in der Reihenfolge Höhe, Breite).

— Neil

11

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

— Luis Mendo
quelle

8

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!

— Sisyphus
quelle

\\%skann werden \%sund \\/kann werden \/.

— Jonathan Frech

7

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.

— Weizen-Assistent
quelle

Das Definieren a#b=[a..b]und Ersetzen aller Vorkommen spart ein Byte:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]

— Lynn

Oh, a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]tatsächlich spart 6 ~

— Lynn

@Lynn Danke! Du hast mich in letzter Zeit wirklich erwischt.

— Weizen-Zauberer

@Lynn Ich habe es zum Laufen gebracht, aber auf Kosten eines anderen Bytes.

— Weizen-Zauberer

5

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

/\/|
\  |
---+

— kalsowerus
quelle

4

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

Code-Snippet anzeigen

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>

Erweitern Sie das Snippet

— Arnauld
quelle

3

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.

— Mr. Xcoder
quelle

3

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

— Neil
quelle

3

Excel, 95 Bytes

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

— Wernisch
quelle

3

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.

— Adam
quelle

3

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

— scottinet
quelle

1

Sie können weitere 3 Bytes abschneiden, indem Sie die puts("")in die erste for-Schleife wie diese verschiebenx,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);}

— cleblanc

@cleblanc Danke!

— Scottinet

3

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

— user202729
quelle

Sie können das Parsen überspringen, indem Sie Eingaben in Unary vornehmen .

— Esolanging Fruit

Ich sollte auch erwähnen, dass dies sehr beeindruckend ist! Gut gemacht!

— Esolanging Fruit

2

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!

— Halvard Hummel
quelle

81 Bytes in Python 2 nach einigen Verbesserungen

— offiziell

Wenn Sie es in Python 3 behalten möchten, *(b-1)kann es *~-bfür -2 Bytes sein.

— Mr. Xcoder

2

@officialaimm Warum " "*2*~-a? Nur "__"*~-a.

— TSH

@tsh Ja, Sie haben Recht ... Haha wusste nicht, dass ...

— officialaimm

@officialaimm wird es behalten Python 3, hat jedoch einige Bytes wegen Ihnen, Mr.Xcoder und TSH

— Halvard Hummel

2

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!

— Jona
quelle

1

33 Bytes ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Amend ist großartig hier.

— Meilen

ooooh, sehr schöne Verbesserung

— Jonah

1

30 Bytes '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:mit einigem Refactoring

— Meilen

2

05AB1E , 19 Bytes

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

Probieren Sie es online!

Argumente werden umgekehrt.

— Erik der Outgolfer
quelle

Hmm, ich rieche ... Canvas-Modus ?

— Mr. Xcoder

2

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.

— Laikoni
quelle

Ich habe meine Antwort mit Hilfe von Lynn unter Ihrer erhalten , aber ich würde gerne sehen, wie Sie sie erneut schlagen.

— Weizen-Zauberer

1

@ WheatWizard Los geht's;)

— Laikoni

2

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'.

— Jakob
quelle

2

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

— dzaima
quelle

>: D hier schlägt es nicht gegen Charcoal

— ASCII

@ ASCII-only, weil Holzkohle eine eingebaute dafür hat: p (und SOGLs wirklich für komplizierte und lange Herausforderungen sowieso gemacht)

— Dzaima

1

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

— Kein Baum
quelle

1

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.

— Mr. Xcoder
quelle

1

Ruby , 62 61 60 Bytes

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

-1 Byte danke an Arnauld

Probieren Sie es online!

— GB
quelle

1

Eigentlich 38 Bytes

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

Probieren Sie es online!

— Erik der Outgolfer
quelle

1

J , 39 Bytes

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

Probieren Sie es online!

Nimmt zwei Argumente wie heightauf der LHS und widthauf der RHS.

— Meilen
quelle

Gute Arbeit, wie immer. Interessanter Ansatz auch.

— Jonah

@Jonah Nein, deine Idee ist mit amend viel besser. Wenn mit der Hälfte von mir kombiniert ...

— Meilen

1

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

— remoel
quelle

Golfed Sub (139 Bytes):Sub b c=[2*A1] r=[2*B1] For i=1To r For j=1To c Debug.?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," "); Next Debug.? Next End Sub

— Taylor Scott

Unmittelbare anonyme Fensterfunktionsversion von oben (113 Bytes):c=[2*A1]:r=[2*B1]:For i=1To r:For j=1To c:?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," ");:Next:?:Next

— Taylor Scott

1

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.

— Kennzeichen
quelle

Nutzen Sie die sFunktion jemals ?

— BLT

Die s-Funktion ist, was Sie aufrufen, um die Spikey-Box zu machen

— Mark

1

Ich habs. Sie können bis zu 152 Bytes erreichen, wenn Sie Leerzeichen und das s=Bit entfernen . Anonyme Funktionen sind erlaubt.

— BLT

Gut zu wissen, anon Funktionen sind erlaubt

— Mark

0

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!

— R. Kap
quelle

1

Derzeit ist die längste Antwort hier. Ich dachte, das wäre Javas Job ...

— R. Kap

Keine Sorge, es gibt jetzt eine Java-Lösung , und es ist länger.

— Jakob

0

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

— J42161217
quelle

Rotate[w,Pi]entspricht , w~Rotate~Piwie ist o["/\\",#]zu"/\\"~o~#

— Jonathan Frech

Ich kenne die Infix-Notation und benutze sie immer, wenn ich wirklich 1 Byte brauche. In diesem Fall lasse ich sie einfach los ... ;-)

— J42161217

2

Ich habe nicht an Ihrer Kenntnis der Infixnotation gezweifelt. Ich wollte nur die Byteanzahl reduzieren. Sie wissen, im Geiste des Golfspiels und so.

— Jonathan Frech

0

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!

— nmjcman101
quelle

0

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

— Grzegorz Puławski
quelle

0

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!

— Xcali
quelle

Mache eine Spiky Box

Kohle , 9 Bytes

Erläuterung

MATL , 18 Bytes

Erläuterung

Python 2 , 69 68 Bytes

Haskell , 90 88 87 82 Bytes

05AB1E , 14 Bytes

Erläuterung

JavaScript (ES6), 84 Byte

Demo

Schnelle 3 , 166 Bytes

Retina , 77 73 Bytes

Excel, 95 Bytes

APL (Dyalog) , 41 bis 39 Bytes

C (gcc) ,170 166 158 155 108 105

/// , 172 117 Bytes

Python 3 , 87 82 Bytes

J, 48 Bytes

ungolfed

Erläuterung

05AB1E , 19 Bytes

Haskell , 84 79 Bytes

Java 8, 141 Bytes

Ungolfed Lambda

SOGL V0.12 , 22 21 13 Bytes

Mathematica, 87 Bytes

Pyth , 40 39 38 Bytes

Ruby , 62 61 60 Bytes

Eigentlich 38 Bytes

J , 39 Bytes

R, 160 Bytes 152 Bytes

Gleichstrom , 123 Bytes

Mathematica, 116 Bytes

V , 18 Bytes

C # (.NET Core) , 188 Byte

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