Dados dos enteros positivos, W y H, generan un cuadro de arte ASCII cuyo borde está hecho de barras ( /y \) con "puntas" W en los bordes superior e inferior, y "puntas" H en los bordes izquierdo y derecho. El interior de la caja está lleno de espacios.

Una "espiga" son simplemente dos barras que se unen para formar una flecha:

/\    \/

/      \
\      /

Entonces la salida para W = 4, H = 3sería

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

como hay 4 picos en la parte superior apuntando hacia arriba, 4 en la parte inferior apuntando hacia abajo, 3 en la izquierda apuntando hacia la izquierda y 3 en la derecha apuntando hacia la derecha.

Aquí hay algunos otros pares de entrada / salida:

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

Ninguna línea en la salida debe tener espacios iniciales o finales. Opcionalmente, puede haber una nueva línea final.

El código más corto en bytes gana.

Carbón de leña , 9 bytes

ＢײＮײＮ/\

Pruébalo en línea!

Explicación

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

MATL , 18 bytes

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

¡Pruébalo en MATL Online!

Explicación

Considere insumos W = 4, H = 3. El código construye los vectores de fila [1 2 3 4 5 6 7 8](rango de 1a 2*W) y [1 2 3 4 5 6](rango de 1a 2*H). La transposición de la última y la adición a la primera con la emisión da la matriz

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

La indexación modular en la cadena \/produce el resultado deseado en el borde de la matriz:

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

Para eliminar los valores que no son de borde, los configuramos en 0(cuando se interpreta como char, se muestra como espacio):

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

Código comentado:

'\/'    % 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 gracias a Kevin Cruijssen}

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

Pruébalo en línea!

Haskell , 90 88 87 82 bytes

1 6 bytes guardados gracias a Lynn

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

Pruébalo en línea!

Todavía se siente muy largo, veré qué puedo hacer.

05AB1E , 14 bytes

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

Pruébalo en línea!

Explicación

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

Esto solo crea la esquina superior izquierda, x caracteres de ancho e y caracteres de alto. Luego refleja esto en ambos ejes:

x=3, y=2

/\/|
\  |
---+

JavaScript (ES6), 84 bytes

Toma entrada en la sintaxis de curry (w)(h).

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

Manifestación

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

Conjunto completo de pruebas.

La versión de cierre es un poco más larga, desafortunadamente (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)}

Conjunto de pruebas con la versión de cierre.

Retina , 77 73 bytes

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

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

Pruébalo en línea! El enlace incluye casos de prueba. Toma entrada en el formato <height> <width>. Explicación:

\d+
$*

Convierta las entradas a unario.

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

Multiplique las entradas, pero agregue una nueva línea para que el resultado sea un rectángulo.

1
/\

Crea la parte superior puntiaguda.

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

Duplique cada fila puntiaguda, pero con las puntas compensadas en la segunda fila.

¶$

Eliminar nuevas líneas finales.

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

Eliminar el interior de la caja. (Observe el espacio en la última línea).

Excel, 95 bytes

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

APL (Dyalog) , 41 39 bytes

Solicita una lista de [H,W]

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

Pruébalo en línea!

⎕-1 solicitud de entrada (mnemónica: consola estilizada) y resta 1

2× multiplicar por dos

''⍴⍨ use eso para remodelar una cadena vacía (almohadillas con espacios)

⊢ rendimiento que (sirve para separarlo de 4)

{… }⍣4 Aplica la siguiente función cuatro veces:

 ≢⍵ cuenta (longitud de) el argumento

 '/\'⍴⍨ cíclicamente r eshape "/\"a que la longitud

 ⍵, agregue eso al lado derecho del argumento

 ⌽⍉ transposición y espejo (es decir, girar 90 °)

¯1⌽1 rotar cíclicamente el 1 ^er fila un paso hacia la derecha

⊢ rendimiento que (sirve para separarlo de 1)

'\'@2@1 coloque una barra diagonal inversa en la ^2ª posición del ^1er elemento principal.

C (gcc) ,170 166 158 155 108 105

-3 bytes gracias a 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);}

Pruébalo en línea!

Creo que esto se puede jugar aún más con un enfoque menos directo, veré qué puedo hacer cuando encuentre el momento.

Ok, no puedo encontrar otra forma de reducir el número de bytes para ese código.

Explicación: una simple impresión de doble bucle de la caja char por char.

Al imprimir un borde: si las coordenadas xey son pares o impares, muestra un /, de lo contrario, \se muestra un

Si no es un borde, se muestra un carácter de espacio

/// , 172117 bytes

Por lo tanto, debido a que la salida consiste en ///s y whitespaces, no debe haber presentaciones en los 2 idiomas.

Ponga la entrada después del código W,Hcomo número unario (se permite unario para /// , gracias a Challenger5 para sugerencia) (use *para representar dígitos, separe con ,) formato.

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

Pruébalo en línea! (con entrada W=4, H=3)

Python 3 , 87 82 bytes

Editar: Guardado 5 bytes gracias a @officialaimm , @ Mr.Xcoder y @tsh

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

Pruébalo en línea!

J, 48 bytes

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

sin golf

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

explicación

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

Pruébalo en línea!

05AB1E , 19 bytes

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

Pruébalo en línea!

Toma argumentos invertidos.

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

Pruébalo en línea! Ejemplo de uso: 3%6produce una lista de líneas. Úselo mapM putStrLn $ 3%6para hacer una bonita impresión de la caja.

Java 8, 141 bytes

Una lambda al curry de ancho a alto a la salida.

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

Pruébelo en línea (no, return t+i+o;no fue intencional)

Lambda sin golf

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

Esta solución es atípicamente exigente con el tamaño de entrada ya que charse usa para contar hasta la entrada de ancho. Afortunadamente, el algoritmo es lo suficientemente malo como para que en esos tamaños la finalización del programa probablemente ya sea un problema. Elegí usar charpara el índice de bucle para poder reutilizarlo más tarde como un alias barato para '\n'.

SOGL V0.12 , 22 21 13 bytes

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

Pruébalo aquí! (espera que ambas entradas en la pila así ..(y "debido a que una cadena no se ha iniciado explícitamente) - se agrega la entrada de número dos veces para facilitar su uso)

Explicación:

/\”            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~"
"<>""&

Pruébelo en matemáticas (imprime espacios adicionales al comienzo de la mayoría de las líneas por algún motivo) o en el sandbox de Wolfram ! Toma dos enteros como entrada.

Es una solución bastante ingenua, pero todas las cosas inteligentes que probé tenían más bytes. Algo que casi funciona es

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

excepto que falla si cualquiera de las dimensiones es 1 (la entrada es una lista que contiene las dimensiones).

Pyth , 40 39 38 bytes

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

Esto toma los dos enteros separados por una nueva línea.

Conjunto completo de pruebas.

Ruby , 62 61 60 bytes

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

-1 byte gracias a Arnauld

Pruébalo en línea!

En realidad , 38 bytes

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

Pruébalo en línea!

J , 39 bytes

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

Pruébalo en línea!

Toma dos argumentos como heighten el LHS y widthen el 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)))}

Pruébalo en línea!

Gracias BLT por reducir 8 bytes.

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

Está lejos de ser el más corto, pero si uno toma las dos últimas líneas y las gira en pi/2radianes en el sentido de las agujas del reloj hasta una posición "vertical", se parece a un tótem .

Toma la entrada como dos enteros separados por espacios.

Pruébalo en línea!

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è

La respuesta no requeriría el ll if<M-h>ollow dejaran solo 2 columnas de caracteres :(

Pruébalo en línea!

C # (.NET Core) , 188 bytes

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

El recuento de bytes también incluye:

using System.Linq;

Pruébalo en línea!

Comencé a dar explicaciones comando por comando, pero dejó de tener sentido a mitad de camino ... Lo esencial es hacer un cuadro lleno de púas, y luego ahuecar en el medio. Usé Linq por usar Linq, probablemente puede ser más corto usando solo iteraciones estándar.

Aquí está la explicación en el medio (primero el comando más interno):
Primero, cree filas para el cuadro completo y concatene en una sola cadena

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

Luego, obtenga cada carácter en una fila, y si no es el contorno del cuadro, reemplácelo con espacio, concatene nuevamente en una cadena para cada fila

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

Finalmente, obtenga cada fila y concatenelas junto con nuevas líneas (también incluye la generación de una colección para filas)

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

Pruébalo en línea!