Dado (por qualquer meio) dois números naturais diferentes (de qualquer tamanho razoável), produza (por qualquer meio) o quadrado de sua soma, como nos exemplos abaixo:

Dados 4 e 3, saída:

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

Dados 1 e 3, saída:

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

O espaço em branco pode variar de acordo com o motivo, mas as colunas devem estar alinhadas à esquerda, alinhadas à direita ou (pseudo-) centralizadas.

Uma nova linha à direita é boa, mas as brechas padrão não são.

Isso é código-golfe, portanto inclua um cabeçalho como # LanguageName, 123na sua resposta, onde o número é chars (bytes para idiomas que não são baseados em texto). O código de embalagem para caracteres Unicode grandes não é permitido.

Bônus: -3 se seu código gerar apenas um quadrado quando um dos números for 0; por exemplo, dado 0 e 3, saída:

9 9 9
9 9 9
9 9 9

J, 9 bytes - 3 = 6

#~@|.*/#~

Inspirado pela resposta do @ NBZ no APL , inspirado no @randomra. Isso define um verbo que recebe uma matriz de números. É usado da seguinte maneira:

   (#~@|.*/#~) 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

Eu também reivindico o bônus de 3 bytes, uma vez que uma entrada 0 produz sub-matrizes de tamanho zero:

   (#~@|.*/#~) 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

Explicação

J tem uma vantagem definitiva nesse desafio. Além de comer problemas de manipulação de matriz no café da manhã, imprime matrizes 2D no formato correto por padrão.

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

Oitava, 45 bytes - 3 = 42

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

Explicação

Isso constrói dois vetores (vamos assumir m = 4e n = 3):

ones(n, 1)constrói uma matriz de tamanho n x 1, multiplicando os valores 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

Em seguida, os vetores são multiplicados de maneira elemento a elemento, com expansão de transmissão automática para que os vetores de 7 elementos produzam uma matriz de 7x7 elementos:

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

Por exemplo, a multiplicação da primeira linha de apor bfornece:

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

E da mesma forma para as linhas restantes de a.

Saída:

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

Você pode tentar aqui no ideone

Dyalog APL , 10-3 = 7

Inspirado * por esta resposta em que os argumentos são replicados e usados ​​em uma tabela de multiplicação:

⊖∘.×⍨(/⍨⎕)

⎕Emite um prompt ( ⎕:) e avalia qualquer expressão inserida então. (Por motivos de segurança, isso não funciona no TryAPL, mas no NGN / APL .)
/⍨Replica o próprio argumento vezes ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Cria uma tabela de multiplicação.
⊖Vira de cabeça para baixo.

Isso funciona em qualquer entrada de comprimento (a entrada é recuada 6 espaços, a saída está na margem esquerda):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ 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, eu tinha uma solução diferente em mente: cada retângulo é criado separadamente, criando uma tabela de multiplicação para cada combinação dos dois argumentos. Em seguida, os quatro quadrados são reparados juntos vertical e horizontalmente. Se parece com isso:

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

⎕Prompt, como acima.
,⍴×<Combine ( ,) os argumentos e use-os para modelar ( ⍴) um retângulo preenchido com seu produto ( ×).
∘.(… )⍨Crie uma tabela em que cada célula seja o que for especificado em (… )
⊖Vire verticalmente.
⍪⌿Combine células verticalmente.
,/Combine células horizontalmente.

R, 31-3 = 28

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

Explicação:

           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

Isso também funciona para mais de dois números. Por exemplo, a saída para (5,3,2) fica assim:

      [,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, 153 125 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))

Metade do código é para formatação de saída. Funciona para números inteiros grandes arbitrários. Exemplo de saída:

> 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

Às vezes, há um espaço em branco adicional entre os números, porque estou calculando o espaço necessário com base em x*x+y*yvez de max (x*x) (y*y), por exemplo

> 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

Mas é no máximo um espaço em branco.

Mathematica 56-3 = 53

Atualização : eu adicionei um segundo método, exatamente do mesmo tamanho de código, que usa uma função nomeada. Emprega um Arraye não um Tablemas segue a mesma lógica. (Ver abaixo.)

Método 1

Isso cria uma tabela de produtos, cujos fatores dependem da linha, valores da coluna. O par de números é inserido como uma lista de números inteiros. Funções anônimas, como as seguintes, são mais úteis se forem usadas apenas uma vez em um programa. Caso contrário, faz mais sentido usar uma função nomeada.

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

Cada fator é uma instrução If-then:

• If[r>#2,#,#2] significa "Se o número da linha for maior que a segunda entrada, use a primeira entrada como fator, caso contrário, use a segunda entrada.
• If[c>#,#2,#] significa "Se o número da coluna for maior que a primeira entrada, use a segunda entrada como fator, caso contrário, use a primeira entrada.

Exemplo 1

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

Exemplo 2

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

Método 2 (também 56-3 = 53)

Isso funciona de maneira semelhante ao método 1. Mas requer menos código quando chamado. E as células são endereçáveis, ao contrário das células de uma tabela. Este método é melhor usar se a função for usada mais de uma vez.

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

Os exemplos acima são produzidos pelo seguinte:

Ex 1:

f[4,3]

Ex 2:

f[0,3]

Oitava, 34 - 3 = 31

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

Exemplos:

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*

Recebe entrada como uma matriz de estilo CJam. Ele usa um pouco mais de espaçamento do que o necessário, mas acho que está "dentro da razão" e sempre está alinhado corretamente.

Teste aqui.

Explicação

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.

Função C (usando glibc), 122 bytes - 3 = 119

Implementação principalmente direta com 2 loops. Espero que haja algumas oportunidades de golfe que perdi aqui:

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

As entradas são passadas nos dois primeiros parâmetros da função, os outros dois são manequins. As colunas estão alinhadas à direita.

Observe que o glibc puts()sempre parece retornar o número de bytes escritos, incluindo a nova linha implícita à direita, que é o que precisamos aqui. Não há garantias de que isso funcione com qualquer outra libc.

Em um 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]));
    }
}

Compile como gcc sqrbin.c -o sqrbin(ou make sqrbin). Os avisos podem ser ignorados com segurança.

Exemplo de saída:

$ ./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
$ 

Ruby, (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

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

Isso usa funções de string do Python para criar uma grade de caracteres, substitui os caracteres por números inteiros e imprime a saída formatada.

Matlab, 58 - 3 = 55

Usando uma função anônima:

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

Exemplo:

>> @(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

(Solução antiga) 59 - 3 = 56

Usando uma função 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));}

A entrada é tomada como dois números inteiros separados por espaço na mesma linha. Cada célula é preenchida com espaços para o dobro do comprimento da sequência de entrada.

Pitão, 39-3 = 36

Pyth não possui formatação matricial incorporada, o que aumenta muito o tamanho, pois é necessário preencher manualmente os números de saída. Aqui está o que eu criei.

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

Experimente online.

Blocos , 51 bytes 52 62 82 87 (não concorrente)

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

Ungolfed:

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

Tente