Dado (por cualquier medio) dos números naturales diferentes (de cualquier tamaño razonable), genera (por cualquier medio) el cuadrado de su suma como en los ejemplos a continuación:

Dado 4 y 3, salida:

12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Dado 1 y 3, salida:

3 9 9 9
3 9 9 9
3 9 9 9
1 3 3 3

El espacio en blanco puede variar dentro de lo razonable, pero las columnas deben estar alineadas a la izquierda, a la derecha o (pseudo-) centradas.

Una nueva línea final está bien, pero las lagunas estándar no lo están.

Este es el código de golf, por lo tanto, incluya un encabezado como # LanguageName, 123en su respuesta, donde el número son caracteres (bytes para idiomas que no están basados ​​en texto). El código de embalaje para caracteres Unicode grandes no está permitido.

Bonificación: -3 si su código genera solo un cuadrado cuando uno de los números es 0; Por ejemplo, dado 0 y 3, salida:

9 9 9
9 9 9
9 9 9

J, 9 bytes - 3 = 6

#~@|.*/#~

Inspirado por la respuesta APL de @ NBZ, jugado por @randomra. Esto define un verbo que toma una matriz de números. Se usa de la siguiente manera:

   (#~@|.*/#~) 4 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

También reclamo el bono de 3 bytes, ya que una entrada de 0 produce submatrices de tamaño cero:

   (#~@|.*/#~) 4 0
16 16 16 16
16 16 16 16
16 16 16 16
16 16 16 16
   (#~@|.*/#~) 0 3
9 9 9
9 9 9
9 9 9

Explicación

J tiene una ventaja definitiva en este desafío. Además de los problemas de manipulación de la matriz para el desayuno, imprime matrices 2D en el formato correcto de forma predeterminada.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table

Octava, 45 bytes - 3 = 42

s=@(m,n)[a=ones(n,1)*n;b=ones(m,1)*m].*[b;a]'

Explicación

Esto construye dos vectores (supongamos m = 4yn = 3 ):

ones(n, 1)construye una serie de unidades de tamaño n x 1, por lo que multiplicando las unidades por n:

ones(n, 1) * n => [3 3 3]' (where ' is transpose... n x 1 is a column vector)

a = [3 3 3  4 4 4 4]'   %// a is a column vector
b = [4 4 4 4  3 3 3]    %// b is a row vector

Luego, los vectores se multiplican en forma de elementos, con expansión de difusión automática para que los vectores de 7 elementos produzcan una matriz de 7x7 elementos:

    [3] .* [4 4 4 4 3 3 3]
    [3]
    [3]
    [4]
    [4]
    [4]
    [4]

Por ejemplo, la multiplicación de la primera fila de apor bda:

    [3] .* [4 4 4 4 3 3 3] = [12 12 12 12  9  9  9]

Y de manera similar para las filas restantes de a.

Salida:

>> s(4,3)
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

>> s(3,0)
ans =

   9   9   9
   9   9   9
   9   9   9

Puedes probarlo aquí en ideone

Dyalog APL , 10-3 = 7

Inspirado * por esta respuesta donde los argumentos se replican y luego se usan en una tabla de multiplicar:

⊖∘.×⍨(/⍨⎕)

⎕Emite un prompt ( ⎕:) y evalúa cualquier expresión ingresada en ese momento. (Por razones de seguridad, esto no funciona en TryAPL pero funciona en NGN / APL ).
/⍨Replica su argumento en sí veces ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Crea una tabla de multiplicación.
⊖Voltea boca abajo.

Esto sucede para trabajar en cualquier entrada de longitud (la entrada está sangrada 6 espacios, la salida está en el margen izquierdo):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ Empty list (the square of nothing)
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0      ⍝ 0​² = 0
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0 1      ⍝ (0+1)​² = 1²
1
      ⊖∘.×⍨(/⍨⎕)
⎕:
      2 3      ⍝ (2+3)​² = 2² + 3²
6 6 9 9 9
6 6 9 9 9
6 6 9 9 9
4 4 6 6 6
4 4 6 6 6
      ⊖∘.×⍨(/⍨⎕)
⎕:
      1 2 3      ⍝ (1+2+3)​² = 1² + 2(1×2) + 2(1×3) + 2² + 2(2×3) + 3²
3 6 6 9 9 9
3 6 6 9 9 9
3 6 6 9 9 9
2 4 4 6 6 6
2 4 4 6 6 6
1 2 2 3 3 3
      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍳4    ⍝ Integers 1 through 4
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
2 4 4  6  6  6  8  8  8  8
2 4 4  6  6  6  8  8  8  8
1 2 2  3  3  3  4  4  4  4

* Originalmente, tenía una solución diferente en mente: cada rectángulo se crea por separado creando una tabla de multiplicación para cada combinación de los dos argumentos. Luego, los cuatro cuadrados se reparan vertical y horizontalmente. Se parece a esto:

,/⍪⌿⊖∘.(,⍴×)⍨⎕

⎕Rápido, como arriba.
,⍴×<Combina ( ,) los args y úsalo para dar forma ( ⍴) a un rectángulo lleno de su producto ( ×).
∘.(... )⍨Cree una tabla donde cada celda sea lo que se especifica en (... )
⊖Voltee verticalmente.
⍪⌿Combina celdas verticalmente.
,/Combina las celdas horizontalmente.

R, 31-3 = 28

rev(b<-rep(a<-scan(),a))%*%t(b)

Explicación:

           a<-scan()            # take numeric input and store as vector a
    b<-rep(         ,a)         # repeat each numeric input by itself and store as vector b
rev(                   )        # the reverse of vector b
                        %*%     # matrix multiplication
                           t(b) # the transposed of vector b

Esto también funciona para más de dos números. Por ejemplo, la salida para (5,3,2) se ve así:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]   10   10   10   10   10    6    6    6    4     4
 [2,]   10   10   10   10   10    6    6    6    4     4
 [3,]   15   15   15   15   15    9    9    9    6     6
 [4,]   15   15   15   15   15    9    9    9    6     6
 [5,]   15   15   15   15   15    9    9    9    6     6
 [6,]   25   25   25   25   25   15   15   15   10    10
 [7,]   25   25   25   25   25   15   15   15   10    10
 [8,]   25   25   25   25   25   15   15   15   10    10
 [9,]   25   25   25   25   25   15   15   15   10    10
[10,]   25   25   25   25   25   15   15   15   10    10

Haskell, 153125 bytes - 3 = 122

(#)=replicate
d=length.show
y%x=unlines$(>>= \n->(1+d(x*x+y*y)-d n)#' '++show n)<$>x#(y#(x*y)++x#(x*x))++y#(y#(y*y)++x#(x*y))

La mitad del código es para formatear la salida. Funciona para enteros grandes arbitrarios. Salida de ejemplo:

> putStrLn $ 4 % 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

> putStrLn $ 6 % 0
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36

A veces hay un espacio en blanco adicional entre los números, porque estoy calculando el espacio necesario en x*x+y*ylugar de max (x*x) (y*y), por ejemplo

> putStrLn $ 2 % 3
  6  6  9  9  9
  6  6  9  9  9
  6  6  9  9  9
  4  4  6  6  6
  4  4  6  6  6

Pero es como máximo un espacio en blanco.

Mathematica 56-3 = 53

Actualización : agregué un segundo método, precisamente del mismo tamaño de código, que usa una función con nombre. Emplea un en Arraylugar de un Tablepero sigue la misma lógica. (Vea abajo.)

Método 1

Esto crea una tabla de productos, cuyos factores dependen de los valores de la fila y la columna. El par de números se ingresa como una lista de enteros. Las funciones anónimas como las siguientes son más útiles si se usan solo una vez en un programa. De lo contrario, tiene más sentido usar una función con nombre.

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&

Cada factor es una declaración If-then:

• If[r>#2,#,#2] significa, "Si el número de fila es mayor que la segunda entrada, use la primera entrada como factor, de lo contrario use la segunda entrada.
• If[c>#,#2,#] significa, "Si el número de columna es mayor que la primera entrada, use la segunda entrada como factor, de lo contrario use la primera entrada.

Ejemplo 1

 Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{5,3}

Ejemplo 2

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{0,3}

Método 2 (también 56-3 = 53)

Esto funciona de manera similar al Método 1. Pero requiere menos código cuando se llama. Y las celdas son direccionables, a diferencia de las celdas de una tabla. Este método es mejor si la función se usará más de una vez.

a_~f~b_:=Grid@Array[If[#>a,a,b]If[#2>a,b,a]&,{a+b,a+b}]

Los ejemplos de arriba son producidos por lo siguiente:

Ej 1:

f[4,3]

Ej 2:

f[0,3]

Octava, 34 - 3 = 31

@(a)rot90(b=repelems(a,[1,2;a]))*b

Ejemplos:

octave:1> f = @(a)rot90(b=repelems(a,[1,2;a]))*b;
octave:2> f([4,3])
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

octave:3> f([0,3])
ans =

   9   9   9
   9   9   9
   9   9   9

CJam, 27 bytes - 3 = 24

q:L~_]ze~_ff{*sL,2*Se[}W%N*

Toma datos como una matriz de estilo CJam. Utiliza un poco más de espacio del necesario, pero creo que está "dentro de lo razonable", y siempre está correctamente alineado.

Pruébalo aquí.

Explicación

q:L    e# Read the input and store it in L.
~_     e# Evaluate the input, pushing [A B] onto the stack and duplicate it.
]z     e# Wrap both in an array and transpose it to get [[A A] [B B]].
e~     e# Run-length decode, getting A copies of A and B copies of B.
_ff{   e# Double map over each pair of entries in this new array...
  *s   e#   Multiply the two values.
  L,2* e#   Push twice the length of the input string.
  Se[  e#   Pad the result to this width with spaces (from the left).
}
W%     e# Reverse the resulting matrix to get the correct orientation.
N*     e# Join the rows with linefeed characters.

Función C (usando glibc), 122 bytes - 3 = 119

Implementación principalmente directa con 2 bucles. Espero que haya algunas oportunidades de golf que he perdido aquí:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

Las entradas se pasan en los dos primeros parámetros de la función, los otros dos son dummies. Las columnas están alineadas a la derecha.

Tenga en cuenta que glibc puts()siempre parece devolver el número de bytes escritos, incluida la nueva línea final implícita, que es lo que necesitamos aquí. No hay garantías de que esto funcione con cualquier otra libc.

En un programa completo:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

int main (int argc, char **argv) {
    if (argc == 3) {
        f(atoi(argv[1]),atoi(argv[2]));
    }
}

Compilar como gcc sqrbin.c -o sqrbin(o make sqrbin). Las advertencias pueden ser ignoradas de manera segura.

Salida de ejemplo:

$ ./sqrbin 4 3
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
$ ./sqrbin 4 0
 16 16 16 16
 16 16 16 16
 16 16 16 16
 16 16 16 16
$ 

Rubí, (133 - 3) = 130 bytes

s=1
a=ARGV.map{|e|s*=(e=e.to_i);[e]*e}.flatten
s=s.to_s.size
a.reverse.each{|i|a.each{|j|print (i*j).to_s.rjust(s).ljust(s+3)};puts}

para 4,3

12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12

para 1,3

3   9   9   9   
3   9   9   9   
3   9   9   9   
1   3   3   3

por 0,3

9   9   9   
9   9   9   
9   9   9

Python 2, 176 bytes - 3 = 173

def g(m,n):
 y,x,z,l,f='y','x','z','l','%'+str(len(str(max(m*m,n*n))))+'s'
 d={y:m*n,x:n*n,z:m*m,l:'\n'}
 for i in map(lambda x:d[x],(y*m+x*n+l)*n+(z*m+y*n+l)*m): print f % i,

Esto utiliza funciones de cadena de Python para crear una cuadrícula de caracteres, luego reemplaza los caracteres con enteros e imprime la salida formateada.

Matlab, 58-3 = 55

Usando una función anónima:

@(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)

Ejemplo:

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(4,3)
ans =
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(0,3)
ans =
     9     9     9
     9     9     9
     9     9     9

(Solución anterior) 59-3 = 56

Usando una función anónima:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]

C, (125-3) bytes

i,j,a;main(b,s){for(sscanf(gets(s),"%d %d",&a,&b);j<a+b;)printf(++i>a+b?i=!++j,"\n":"%*d",strlen(s)*2,(i<a?a:b)*(j<b?b:a));}

La entrada se toma como dos enteros separados por espacios en la misma línea. Cada celda se rellena con espacios al doble de la longitud de la cadena de entrada.

Pyth, 39-3 = 36

Pyth no tiene un formato de matriz incorporado, lo que aumenta enormemente el tamaño, ya que uno tiene que rellenar manualmente los números de salida. Esto es lo que se me ocurrió.

JAQL*b]jdm.[`d\ l`eS^R2Jsm*d]*bdJj+yHyG

Pruébalo en línea.

Bloques , 51 bytes 52 62 82 87 (no competitivos)

::`+`1|U;{`*`1}|A;`+`1,0+`1={`1^2}|;0+`,`1+`={`^2}|

Sin golf:

::
  ` + `1                    | Expand;
  {` * `1}                  | SetAll;
  ` + `1, 0 + `1 = {`1 ^ 2} | Set;
  0 + `, `1 + `  = {` ^ 2}  | Set

Intentalo