Hacer una caja puntiaguda

31

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.

code-golf  string  ascii-art  integer 
— Pasatiempos de Calvin
fuente
¿Alguien que javascripts puede hacer un fragmento de pila para esto?
— FantaC

Respuestas:

15

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 "/\"
— Solo ASCII
fuente
3
Por supuesto, el carbón tiene incorporado un 'cuadro de extracción'
— benceno el
1
@benceno Fue algo afortunado que recientemente agregó la capacidad de dibujar una cadena arbitraria alrededor de la caja, pero incluso antes de eso había respuestas como codegolf.stackexchange.com/a/120065
— Neil
1
@Neil espera recientemente? ¿Cuando? (¿Conozco el carbón menos bien, gracias? Jaja)
— Solo ASCII
@ ASCII-only My bad! Me confundí por el cambio que hizo retroceder la posición del cursor. (El cambio que introdujo la cadena de borde arbitraria fue ca904b0 que fue hace casi un año).
— Neil
@benceno Sin la caja incorporada, sigue siendo solo 13 bytes: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(toma la entrada en orden de altura, ancho).
— Neil
11

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
— Luis Mendo
fuente
7

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.

— Asistente de trigo
fuente
Definir a#b=[a..b]y reemplazar todas las ocurrencias ahorra un byte:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]
— Lynn
Oh, en a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]realidad ahorra 6 ~
— Lynn
@ Lynn ¡Gracias! Realmente has estado atrapando mi holgura últimamente.
— Wheat Wizard
@ Lynn Lo puse a trabajar pero a costa de otro byte.
— Wheat Wizard
5

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

/\/|
\  |
---+
— kalsowerus
fuente
4

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

Mostrar fragmento de código

— Arnauld
fuente
3

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.

— Sr. Xcoder
fuente
3

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

— Neil
fuente
3

Excel, 95 bytes

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)
— Wernisch
fuente
3

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.

— Adán
fuente
3

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

— scottinet
fuente
1
Puede recortar otros 3 bytes moviendo el puts("")primer bucle for de esta manerax,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 Gracias!
— scottinet
3

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

— usuario202729
fuente
Puede omitir el análisis tomando la entrada en Unary .
— Esolanging Fruit
Además, debo mencionar que esto es muy impresionante. ¡Buen trabajo!
— Esolanging Fruit
2

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!

— Halvard Hummel
fuente
— officialaimm
Si desea mantenerlo en Python 3, *(b-1)puede ser *~-b, por -2 bytes.
— Sr. Xcoder
2
@officialaimm ¿Por qué " "*2*~-a? Justo "__"*~-a.
— tsh
@tsh Sí, tienes razón ... Jaja no se dio cuenta de eso ...
— officialaimm
@officialaimm lo mantendrá Python 3, sin embargo, guardó algunos bytes debido a usted, Mr.Xcoder y tsh
— Halvard Hummel
2

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!

— Jonás
fuente
1
33 bytes ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:. Enmendar es genial aquí.
— millas
ooooh, muy buena mejora
— Jonás
1
30 bytes '/\ '{~2(<,~<<0 _1)}2|+/&i.&+:con algunas refactorizaciones
— millas
2

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

— Jakob
fuente
2

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
— dzaima
fuente
>: D no está ganando carbón aquí
— solo ASCII
@ ASCII-solo porque el carbón tiene una función incorporada para esto: p (y los SOGL realmente hicieron desafíos complicados y largos de todos modos)
— 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~"
"<>""&

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

— No un arbol
fuente
1

J , 39 bytes

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

Pruébalo en línea!

Toma dos argumentos como heighten el LHS y widthen el RHS.

— millas
fuente
Buen trabajo, como siempre. Enfoque interesante, también.
— Jonás
@ Jonás No, tu idea es mucho mejor usando enmendar. Si se combina con la mitad de la mía ...
— millas
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
— remodelar
fuente
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
Versión de función de ventana inmediata anónima de arriba (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)))}

Pruébalo en línea!

Gracias BLT por reducir 8 bytes.

— marca
fuente
¿Alguna vez usaste la sfunción?
— BLT
La función s es lo que se llama para hacer la caja con púas
— Mark
1
Lo tengo. Puede reducir a 152 bytes si elimina el espacio en blanco y el s=bit. Se permiten funciones anónimas.
— BLT
Es bueno saber que las funciones anon están permitidas
— Mark
0

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!

— R. Kap
fuente
1
Actualmente la respuesta más larga aquí. Pensé que ese era el trabajo de Java ...
— R. Kap
No se preocupe, ahora hay una solución Java y es más larga.
— 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
fuente
Rotate[w,Pi]es equivalente a w~Rotate~Pi, como es o["/\\",#]a"/\\"~o~#
— Jonathan Frech
Conozco la notación infija y siempre la uso cuando realmente necesito 1 byte. En este caso, simplemente lo dejé pasar ... ;-)
— J42161217
2
No dudé de tu conocimiento de la notación infija; Solo quería reducir el recuento de bytes. Ya sabes, en el espíritu del golf y tal.
— Jonathan Frech
0

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));
— Grzegorz Puławski
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.