Su tarea es generar cuadros usando cualquier carácter ASCII con respecto a las entradas dadas.

Casos de prueba

1 1   --> =====
          =   =
          =====

1 2   --> =========
          =   =   =
          =========

2 1   --> =====
          =   =
          =====
          =   =
          =====

2 2   --> =========
          =   =   =
          =========
          =   =   =
          =========

2 5   --> =====================
          =   =   =   =   =   =
          =====================
          =   =   =   =   =   =
          =====================

Entrada

• La entrada puede tomarse de uno de los siguientes

  • stdin
  • Argumentos de línea de comando
  • Argumentos de función (2 argumentos, uno para cada número)

• La entrada, si se toma de los stdinargumentos de la línea de comandos, contendrá dos enteros positivos, separados por un espacio.

• Los dos números denotan el número de cuadros en cada columna y fila.

Salida

• Las cajas deben enviarse stdout(o el equivalente más cercano)
• Cada caja debe tener tres espacios horizontales.

Reglas

• Ambos números serán mayores que 0, pero no irán más allá de 1000
• Cualquier carácter visible se puede utilizar para generar los cuadros. (¡siempre y cuando no sean demasiado duros para la vista!)
• Se le permite escribir un programa completo o una función.
• No debe haber caracteres innecesarios, excepto un carácter opcional de línea nueva.

Puntuación

Este es el código de golf , por lo que gana el envío más corto (en bytes).

Pyth, 23 bytes

Mjbmsm@"= "&%k4dh*4HhyG

Define la función gque funciona según lo deseado.

Demostración.

Retina , 57 bytes

1(?=.* (1*))
$1#$1#


1(?=(1*#1*#)*$)
=   
1
====
#
=#

Toma entrada en unario con una nueva línea final.

Cada línea debe ir a su propio archivo y #debe cambiarse a nueva línea en los archivos. Esto no es práctico, pero puede ejecutar el código tal como está en un archivo con la -sbandera, manteniendo los #marcadores (y cambiando la nueva línea final #en la entrada también). Puede #volver a cambiar las líneas nuevas en la salida para facilitar la lectura si lo desea. P.ej:

> echo -n 11 111#|retina -s boxes|tr # '\n'
=============
=   =   =   =
=============
=   =   =   =
=============

Método: 5 pasos de sustitución simple. Los primeros dos (primeras 4 líneas) Crea una 2*N+1por Mrejilla de unos y los próximos 3 pasos (6 líneas) Formato en la salida deseada.

Las cadenas intermedias (delimitadas por -'s):

11 111
------------------
111
111
111
111
 111
------------------
111
111
111
111
111
------------------
111
=   =   =   
111
=   =   =   
111
------------------
============
=   =   =   
============
=   =   =   
============
------------------
=============
=   =   =   =
=============
=   =   =   =
=============

JavaScript ( ES6 ), 83

Una función con parámetros de filas y columnas. Usando cadenas de plantilla, hay 2 nuevas líneas incrustadas que son significativas y contadas.

Salida a través de alert(ventana emergente). Al alertusar una fuente proporcional, obtenemos un mejor resultado usando una letra con un ancho similar al espacio en lugar de =.

Pruebe en Firefox usando la consola para obtener la alertsalida real , o ejecute el fragmento a continuación.

f=(r,c)=>{for(x=y="|";c--;)x+="||||",y+="   |";for(o=x;r--;)o+=`
${y}
`+x;alert(o)}

// TEST

// redefine alert to avoid that annoying popup during test
alert=x=>O.innerHTML=x

test=_=>([a,b]=I.value.match(/\d+/g),f(a,b))

test()

<input id=I value='2 3'><button onclick="test()">-></button>
<pre id=O></pre>

JavaScript (ES6), 75 73

Usando repeatllamadas copiosas , repetimos |, luego repetimos |con espacios finales, y repetimos ambas repeticiones para hacer filas:

f=(y,x)=>alert(((s="|"[r="repeat"](x*4)+`|
`)+"|   "[r](x)+`|
`)[r](y)+s)

(Las nuevas líneas son significativas, según la sugerencia de edc65 de usar cadenas de plantillas).

Retazo:

<input id="x" type="range" max="10" min="1" step="1" value="3"><input id="y" type="range" max="10" min="1" step="1" value="2"><pre id="o"></pre><script>function f(y,x){return ((s="|"[r="repeat"](x*4)+"|\n")+"|   "[r](x)+"|\n")[r](y)+s};function redraw(){document.getElementById("o").innerHTML=f(document.getElementById("y").value,document.getElementById("x").value)};document.getElementById("x").onchange=redraw;document.getElementById("y").onchange=redraw;document.getElementById("x").oninput=redraw;document.getElementById("y").oninput=redraw;redraw();</script>

Sin cadenas de plantilla, sin reutilización del nombre del método y con espacios en blanco agregados:

f=(y,x)=>alert(
    (
      (s="|".repeat(x*4)+"|\n") + 
      "|   ".repeat(x)+"|\n"
    ).repeat(y)+s
)

(Usando la recomendación de edc65 para usar |para un mejor espaciado visual).

Pip, 29 24 = 23 + 1 bytes

Requiere la -nbandera. Toma la altura y el ancho como argumentos de línea de comandos y construye cajas de 1s.

([1X4m]XbRLa+1)@<v.1R0s

Explicación:

                         a,b are cmdline args; m is 1000; v is -1; s is " " (implicit)
 [1X4m]                  List containing 1111 and 1000
       Xb                String repetition of each element b times
         RLa+1           Repeat the list a+1 times
(             )@<v       Now we have one row too many at the end, so take everything
                         but the last item (equiv to Python x[:-1])
                  .1     Concatenate a 1 to the end of each row
                    R0s  Replace 0 with space
                         Print, joining list on newlines (implicit, -n flag)

Este programa aprovecha mucho el hecho de que las cadenas son números y los números son cadenas en Pip. (¡Y los tres espacios en esos cuadros resultaron ser perfectos para aprovechar la mvariable incorporada !)

Así es como la lista se construye con la entrada 2 3:

[1111;1000]
[111111111111;100010001000]
[111111111111;100010001000;111111111111;100010001000;111111111111;100010001000]
[111111111111;100010001000;111111111111;100010001000;111111111111]
[1111111111111;1000100010001;1111111111111;1000100010001;1111111111111]
[1111111111111;"1   1   1   1";1111111111111;"1   1   1   1";1111111111111]

Y el resultado final:

C:\> pip.py 2 3 -ne "([1X4m]XbRLa+1)@<v.1R0s"
1111111111111
1   1   1   1
1111111111111
1   1   1   1
1111111111111

Más sobre Pip

Perl, 72 63 52 50 bytes

Mi versión más corta todavía se usa $/para obtener un carácter de nueva línea de forma más compacta:

$ perl -e 'print((($,="="."   ="x pop.$/)=~s/./=/gr)x(1+pop))' 2 5
=====================
=   =   =   =   =   =
=====================
=   =   =   =   =   =
=====================

La actualización anterior coloca las líneas en su mayoría vacías en el separador de registros de salida $,e imprime una lista de líneas continuas.

$ perl -e 'print((($,="="."   ="x pop."\n")=~s/./=/gr)x(1+pop))' 2 5

La versión anterior podría ser un poco más clara para el lector casual:

$ perl -E 'say($y=($x="="."   ="x pop)=~s/./=/gr);for(1..pop){say$x;say$y}' 2 5

La primera versión utilizada en @ARGVlugar de pop:

$ perl -E 'say($y=($x="="."   ="x$ARGV[1])=~s/./=/gr);for(1..$ARGV[0]){say$x;say$y}' 2 5

Python 2, 58 57 Bytes

Implementación bastante sencilla.

def f(x,y):a="="*(4*y+1);print(a+"\n="+"   ="*y+"\n")*x+a

Compruébalo aquí.

Gracias a Sp3000 por guardar un byte.

GNU sed -r, 160

Suspiro, pensé que esto sería más pequeño, pero aquí está de todos modos. Desafortunadamente, las expresiones regulares sed no tienen ninguna capacidad de búsqueda.

:
s/(.*)1$/   =\1/;t
s/([= ]+)/\1\n\1/
:b
s/   (.*\n)/===\1/;tb
s/(1*)1 $/\n\1/
:c
s/([^\n]*\n[^\n]*\n)(1*)1$/\1\1\2/;tc
s/(=+)(.*)/\1\2\1/
s/(^|\n)(.)/\1=\2/g

Tomando entrada como unario de STDIN:

$ sed -rf boxes.sed <<< "11 111"
=============
=   =   =   =
=============
=   =   =   =
=============
$

CJam, 25 bytes

q~)S3*'=5*+4/f*3f>\)*1>N*

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

q~                        e# Read H and W from STDIN.
   S3*'=5*+               e# Push "   =====".
           4/             e# Chop into ["   =" "===="].
  )          f*           e# Repeat each string W+1 times.
               3f>        e# Cut off the first three characters.
                  \)*     e# Repeat the resulting array H+1 times.
                     1>   e# Remove the first string.
                       N* e# Join the lines.

Maravilloso, 168 bytes

Esta respuesta solo funciona hasta 255x255, no 1000x1000, debido a las limitaciones del lenguaje Marbelous. Estoy trabajando en una biblioteca de 32 bits, pero no estará lista pronto.

La entrada se proporciona como dos parámetros de línea de comando o parámetros de función a la placa principal.

@2@3}1@0
SLEL//>0\/
@3@1}0--
}1&0@0/\&0
@1/\@2}1\/
:SL
..}0@0
&0/\>0&0
EN..--\/
{0@0/\ES
:EL
..@0
..>0EN
}0--\/
@0/\EX
:EX
}0
\/3D3D3D3D
:ES
}0
\/3D202020
:EN
}0
{03D0A

Pseudocódigo:

MB(H,W):
    EL(W)
    for 1..H:
        SL(W)
        EL(W)
EL(W):
    for 1..W:
        EX()
    EN()
SL(W):
    for 1..W:
        ES()
    EN()
EX():
    print "===="
ES():
    print "=   "
EN():
    print "=\n"

CJam 52 51 46 41 bytes

l~:B;:A;'=:U{{U4*}B*N}:V~{U{SZ*U}B*NUV}A*

Gracias a Sp3000 por -5 caracteres

Gracias a Martin Büttner ♦ por otros 5 caracteres

Intentalo

función c, 81

x,y;f(h,w){for(;y<=h*2;y++)for(x=0;x<w*4+2;x++)putchar(x>w*4?10:x&3&&y&1?32:61);}

Programa de prueba:

x,y;f(h,w){for(;y<=h*2;y++)for(x=0;x<w*4+2;x++)putchar(x>w*4?10:x&3&&y&1?32:61);}

int main (int argc, char **argv)
{
  f(2, 3);
}

PHP4.1, 76 71 69 bytes

Esto es lo más golfizado que puedo conseguir.

$R=str_repeat;echo$R(($T=$R('-',4*$H+1))."
|{$R('   |',$H)}
",$V),$T;

Esto espera que la clave Htenga el número de líneas y Vel número de cuadros por línea.

Estoy usando -y |solo para que las cajas realmente parezcan cajas. Si es necesario, puedo cambiarlo a =. No importa el carácter que se use.
Salir -y |también ayuda a comprender el desorden que está sucediendo.

Método antiguo, 76 bytes:

for($R=str_repeat;$H--;)echo$T=$R('-',($V*4)+1),"
|{$R('   |',$V)}
";echo$T;

Ejemplo de salida:

http://localhost/file.php?H=2&V=3

-------------
|   |   |   |
-------------
|   |   |   |
-------------

Julia, 59 bytes

(n,m)->(l="="^(4m+1)*"\n";print(l*("="*"   ="^m*"\n"*l)^n))

Esto crea una función sin nombre que acepta dos enteros como entrada e imprime el resultado en STDOUT. Para llamarlo, dale un nombre, por ejemplo f=(n,m)->....

Ungolfed + explicación:

function f(n, m)
    # Store the solid row
    l = "="^(4m + 1) * "\n"

    # Print all rows by repeating a pattern n times
    print(l * ("=" * "   ="^m * "\n" * l)^n)
end

Ejemplos:

julia> f(2, 3)
=============
=   =   =   =
=============
=   =   =   =
=============

julia> f(1, 5)
=====================
=   =   =   =   =   =
=====================

Cualquier sugerencia es bienvenida.

bash + coreutils, 57

dc -e"2do$2 4*1+^1-pd8*F/1+$1si[fli1-dsi0<c]dscx"|tr 0 \ 

Esto se utiliza dcpara imprimir números binarios que tienen 1s para los bordes del cuadro ys 0para los espacios.

• el número X todos se calcula por 2 ^ (width * 4 + 1) - 1, luego se empuja e imprime
• el 10001...0001número se calcula por , luego se empujaX* 8 / 15 + 1
• la pila se descarga heightveces

El trconvierte los 0s de caracteres de espacio.

Salida

$ ./boxes.sh 2 4
11111111111111111
1   1   1   1   1
11111111111111111
1   1   1   1   1
11111111111111111
$ 

R, 83 81

Como una función sin nombre que toma h y w como parámetros. Construye la primera y segunda línea en un vector para cada fila y la replica hveces. Agrega un vector para la línea inferior y cats del vector usando fillpara restringir la longitud de las líneas. Ahora aprovecha la regla de cualquier personaje visible.

function(h,w)cat(rep(c(A<-rep(1,w*4+2),rep('   1',w)),h),A[-1],fill=w*4+1,sep='')

Prueba de funcionamiento

> f=function(h,w)cat(rep(c(A<-rep(1,w*4+2),rep('   1',w)),h),A[-1],fill=w*4+1,sep='')
> f(4,2)
111111111
1   1   1
111111111
1   1   1
111111111
1   1   1
111111111
1   1   1
111111111
> 

Python 3 2, 160 87 85 79 bytes

Sé que esto se puede jugar mucho más al golf, me gustaría algunas sugerencias ya que este es mi primer intento en el golf.

def d(x,y):
    for i in[1]*x:print'='*(4*y+1)+'\n'+'=   '*(y+1)
    print'='*(4*y+1)

Gracias a los consejos de @Cool Guy y @ Sp3000, reduje el tamaño a poco más de la mitad.

Por ejemplo: d (3,3)

=============
=   =   =   =   
=============
=   =   =   =   
=============
=   =   =   =   
=============

Pruébalo aquí .

Disculpe los espacios en blanco finales.

KDB (Q), 37 bytes

{(3+2*x-1)#(5+4*y-1)#'(4#"=";"=   ")}

Explicación

                      (4#"=";"=   ")     / box shape
           (5+4*y-1)#'                   / extend y axis
 (3+2*x-1)#                              / extend x axis
{                                   }    / lambda

Prueba

q){(3+2*x-1)#(5+4*y-1)#'(4#"=";"=   ")}[2;5]
"====================="
"=   =   =   =   =   ="
"====================="
"=   =   =   =   =   ="
"====================="

JavaScript, 92 85 bytes

Esperaba que esto fuera más corto que la otra respuesta de JS (buen trabajo como siempre, edc65), pero bueno. Tengo la sensación de que las matemáticas aquí se pueden jugar más.

f=(r,c)=>(x=>{for(i=s='';(y=i++/x)<r-~r;)s+=i%x?' *'[-~y%2|!(-~i%4)]:'\n'})(4*c+2)||s

Octava, 69 sesenta y cinco 64

y=ones([2,4].*input()+1);y(1:2:end,:)=y(:,1:4:end)=4;char(y+31)

Gracias a DLosc por señalar los problemas que llevaron a -1

Toma entrada como [1 1]y salidas:

#####
# #
#####

También puede ingresar '1' y obtener 1x1. Si la entrada realmente necesita ser1 1 , el tamaño sube a88 8584 :

y=ones([2,4].*eval(['[',input(0,'s'),']'])+1);y(1:2:end,:)=y(:,1:4:end)=4;char(y+31)

Nota: Matlab no permite el encadenamiento o la entrada de Octave (entero), pero aquí está la versión de Matlab ( 67 ):

y=ones([2,4].*input('')+1);y(1:2:end,:)=4;y(:,1:4:end)=4;char(y+31)

C, 76 bytes

w,n;f(r,c){for(w=c*4+2,n=w*r*2+w;n--;)putchar(n%w?n/w%2&&n%w%4-1?32:61:10);}

Se invoca como una función con número de filas y columnas como argumentos. Por ejemplo:

f(5, 2)

CJam, 30 29 bytes

Nueva versión con redundante +al final eliminado (gracias, Dennis):

l~_4*)'=*N+:F\'=S3*+*'=+N++*F

Sé que Dennis ya publicó una solución CJam que supera esto por millas. Pero este es mi primer intento en CJam, por lo que es un milagro que funcione. :)

Bastante fuerza bruta. Construye la primera línea a partir de 4 * H + 1 =signos, luego la segunda línea a partir de tiempos =repetidos H, con otra =agregada. Luego concatena las dos líneas, repite todo el Vtiempo y luego agrega otra copia de la primera línea.

Parece que tengo demasiadas manipulaciones de la pila, e incluso terminé almacenando la primera línea en una variable porque tenía que barajar las cosas en la pila aún más.

No es muy elegante en general, pero tienes que comenzar en alguna parte ... y quería probar un problema simple primero.

CJam, 23

q~[F8]f{2b*1+' f+N}*_0=

Pruébalo en línea

Explicación:

q~        read and evaluate the input (height width)
[F8]      make an array [15 8] - 1111 and 1000 in base 2
f{…}      for width and each of [15 8]
  2b      convert the number to base 2
  *       repeat the digits "width" times
  1+      append a 1 to the array of digits (right edge)
  ' f+    add the space character to each digit (0->' ', 1->'!')
  N       push a newline
*         repeat the resulting array "height" times
_0=       copy the first line (bottom edge)

Dart, 57

b(y,x,{z:'='}){z+=z*4*x;print('$z\n=${'   ='*x}\n'*y+z);}

Pruébelo en: https://dartpad.dartlang.org/36ed632613395303ef51

Java, 181

Espero que segun

Se le permite escribir un programa completo o una función.

cumple con las reglas para contar los bytes de la función , que es 181 en este caso

import static java.lang.System.*;
public class Boxes
{
    public static void main(String[] args)
    {
        Boxes b=new Boxes();
        System.out.println("1,1:");
        b.b(1,1);
        System.out.println("1,2:");
        b.b(1,2);
        System.out.println("2,1:");
        b.b(2,1);
        System.out.println("2,2:");
        b.b(2,2);
        System.out.println("2,5:");
        b.b(2,5);
    }

    void b(int R, int C){String s="",e=s,x,y,z=s,a="====",n="=\n";int r,c;for(r=R;r-->0;){x=y=e;for(c=C;c-->0;){x+=a;y+="=   ";}s+=x+n+y+n;}for(c=C;c-->0;){z+=a;}s+=z+n;out.println(s);}
}

C #, 153 151 150

Esto realmente no puede competir, pero aquí es solo por diversión:

(h,w)=>{string s="=",e="\n",a="====",b="   =",m=a,o;int i=0,j;for(;i++<=h*2;){o=s;for(j=0;j++<w+1;o=m)System.Console.Write(o);m=m==a?b:a;s=e+s;e="";}}

Como correr:

public class Program
{
    public static void Main()
    {
        new System.Action<int, int>((h,w)=>{string s="=",e="\n",a="====",b="   =",m=a,o;int i=0,j;for(;i++<=h*2;){o=s;for(j=0;j++<w+1;o=m)System.Console.Write(o);m=m==a?b:a;s=e+s;e="";}})(3, 4);
    }
}

Abierto a mejoras.

Python 2.7, 66 bytes.

Sé que ya hay mejores soluciones en Python, pero eso es lo mejor que se me ocurrió.

def f(x,y):a,b,c="="*4,"   =","\n=";print "="+a*y+(c+b*y+c+a*y)*x

Ejemplo:

f(3,4)

=================
=   =   =   =   =
=================
=   =   =   =   =
=================
=   =   =   =   =
=================

Rubí, 57 48 45

f=->h,w{l=?=*w*4+?=;(l+$/+'=   '*w+"=
")*h+l}

Uso:

print f[2,5]

Gracias a manatwork por guardar 3 bytes.

Java, 123 119 bytes

void p(int h,int w){String b="=",d="\n=";for(;w-->0;d+="   =")b+="====";for(d+="\n"+b;h-->0;b+=d);System.out.print(b);}

Abusar de los parámetros de entrada como contadores ayudó mucho a disminuir el tamaño del código.

Gracias a Cool Guy por sugerir el abuso de la sintaxis.

SAS, 117 119

macro a array a[0:1]$4('#   ' '####');do x=1 to 2+2*&x-1;t=repeat(a[mod(x,2)],&y-1);put t $char%%eval(&y*3). '#';end;%

Ejemplo:

%let x=4;
%let y=4;
data;a;run;

Resultado:

#############
#   #   #   #
#############
#   #   #   #
#############
#   #   #   #
#############
#   #   #   #
#############