Étant donné (par tout moyen) deux nombres naturels différents (de toute taille raisonnable), affichez (par tout moyen) le carré de leur somme comme dans les exemples ci-dessous:

Étant donné 4 et 3, sortie:

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

Étant donné 1 et 3, sortie:

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

Les espaces peuvent varier dans des limites raisonnables, mais les colonnes doivent être alignées à gauche, à droite ou (pseudo-) centrées.

Une nouvelle ligne de fin est très bien, mais les failles standard ne le sont pas.

Il s'agit de code-golf, donc incluez un en-tête comme # LanguageName, 123dans votre réponse, où le nombre est des caractères (octets pour les langues qui ne sont pas basées sur du texte). Il est interdit de compresser du code dans de grands caractères Unicode.

Bonus: -3 si votre code ne produit qu'un seul carré lorsque l'un des nombres est 0; par exemple donné 0 et 3, sortie:

9 9 9
9 9 9
9 9 9

J, 9 octets - 3 = 6

#~@|.*/#~

Inspiré par la réponse APL de @ NBZ , joué par @randomra. Cela définit un verbe qui prend un tableau de nombres. Il est utilisé comme suit:

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

Je réclame également le bonus de 3 octets, car une entrée de 0 produit des sous-matrices de taille zéro:

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

Explication

J a un avantage certain dans ce défi. En plus de manger des problèmes de manipulation de tableaux pour le petit déjeuner, il imprime les matrices 2D au format correct par défaut.

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

Octave, 45 octets - 3 = 42

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

Explication

Cela construit deux vecteurs (supposons m = 4et n = 3):

ones(n, 1)construit un tableau de ceux de taille n x 1, donc en multipliant ceux par nnous obtenons:

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

Ensuite, les vecteurs sont multipliés de manière élémentaire, avec une expansion de diffusion automatique de sorte que les vecteurs à 7 éléments produisent une matrice à 7x7 éléments:

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

Par exemple, la multiplication de la première ligne de apar bdonne:

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

Et de même pour les lignes restantes de a.

Sortie:

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

Vous pouvez l'essayer ici sur ideone

Dyalog APL , 10-3 = 7

Inspiré * par cette réponse où les arguments sont répliqués puis utilisés dans une table de multiplication:

⊖∘.×⍨(/⍨⎕)

⎕Emet une invite ( ⎕:) et évalue toute expression entrée ensuite. (Pour des raisons de sécurité, cela ne fonctionne pas sur TryAPL mais cela fonctionne sur NGN / APL .)
/⍨Réplique son argument lui-même fois ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Crée une table de multiplication.
⊖Se retourne à l'envers.

Cela arrive à travailler sur n'importe quelle entrée de longueur (l'entrée est en retrait de 6 espaces, la sortie est à gauche):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ 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

* À l'origine, j'avais une solution différente à l'esprit: chaque rectangle est créé séparément en créant une table de multiplication pour chaque combinaison des deux arguments. Ensuite, les quatre carrés sont raccommodés verticalement et horizontalement. Cela ressemble à ceci:

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

⎕Invite, comme ci-dessus.
,⍴×<Combinez ( ,) les arguments et utilisez-les pour former ( ⍴) un rectangle rempli de leur produit ( ×).
∘.(… )⍨Créez un tableau dans lequel chaque cellule correspond à ce qui est spécifié dans (… )
⊖Retourner verticalement.
⍪⌿Combinez les cellules verticalement.
,/Combinez les cellules horizontalement.

R, 31-3 = 28

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

Explication:

           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

Cela fonctionne également pour plus de deux numéros. Par exemple, la sortie pour (5,3,2) ressemble à ceci:

      [,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 octets - 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 moitié du code est pour le formatage de sortie. Cela fonctionne pour les grands nombres arbitraires. Exemple de sortie:

> 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

Parfois, il y a un espace supplémentaire entre les nombres, car je calcule l'espace nécessaire en fonction x*x+y*yde max (x*x) (y*y), par exemple

> 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

Mais c'est tout au plus un espace.

Mathematica 56-3 = 53

Mise à jour : j'ai ajouté une deuxième méthode, exactement de la même taille de code, qui utilise une fonction nommée. Il utilise un Arrayplutôt qu'un, Tablemais suit la même logique. (Voir ci-dessous.)

Méthode 1

Cela crée un tableau de produits, dont les facteurs dépendent des valeurs de ligne et de colonne. La paire de nombres est entrée sous la forme d'une liste d'entiers. Les fonctions anonymes telles que les suivantes sont plus utiles si elles ne sont utilisées qu'une seule fois dans un programme. Sinon, il est plus logique d'utiliser une fonction nommée.

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

Chaque facteur est une instruction If-then:

• If[r>#2,#,#2] signifie: "Si le numéro de ligne est supérieur à la deuxième entrée, utilisez la première entrée comme facteur, sinon utilisez la deuxième entrée.
• If[c>#,#2,#] signifie: "Si le numéro de colonne est supérieur à la première entrée, utilisez la deuxième entrée comme facteur, sinon utilisez la première entrée.

Exemple 1

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

Exemple 2

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

Méthode 2 (également 56-3 = 53)

Cela fonctionne de manière similaire à la méthode 1. Mais elle nécessite moins de code lorsqu'elle est appelée. Et les cellules sont adressables, contrairement aux cellules d'un tableau. Il est préférable d'utiliser cette méthode si la fonction sera utilisée plusieurs fois.

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

Les exemples ci-dessus sont produits par les éléments suivants:

Ex 1:

f[4,3]

Ex 2:

f[0,3]

Octave, 34-3 = 31

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

Exemples:

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 octets - 3 = 24

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

Prend l'entrée comme un tableau de style CJam. Il utilise un peu plus d'espacement que nécessaire, mais je pense que c'est "dans des limites raisonnables", et il est toujours correctement aligné à droite.

Testez-le ici.

Explication

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.

Fonction C (en utilisant la glibc), 122 octets - 3 = 119

Implémentation généralement simple avec 2 boucles. Je pense qu'il y a des opportunités de golf que j'ai manquées ici:

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

Les entrées sont passées dans les deux premiers paramètres de la fonction, les deux autres sont des variables muettes. Les colonnes sont alignées à droite.

Remarque glibc puts()semble toujours renvoyer le nombre d'octets écrits, y compris la nouvelle ligne implicite de fin, ce dont nous avons besoin ici. Aucune garantie que cela fonctionnera avec toute autre libc.

Dans un programme complet:

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

Compilez en tant que gcc sqrbin.c -o sqrbin(ou make sqrbin). Les avertissements peuvent être ignorés en toute sécurité.

Exemple de sortie:

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

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}

pour 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

pour 1,3

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

pour 0,3

9   9   9   
9   9   9   
9   9   9

Python 2, 176 octets - 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,

Cela utilise des fonctions de chaîne Python pour créer une grille de caractères, puis remplace les caractères par des nombres entiers et imprime la sortie formatée.

Matlab, 58-3 = 55

Utilisation d'une fonction anonyme:

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

Exemple:

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

(Ancienne solution) 59-3 = 56

Utilisation d'une fonction anonyme:

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

C, (125-3) octets

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

L'entrée est considérée comme deux entiers séparés par des espaces sur la même ligne. Chaque cellule est remplie d'espaces à deux fois la longueur de la chaîne d'entrée.

Pyth, 39-3 = 36

Pyth n'a pas de formatage matriciel intégré, ce qui augmente considérablement la taille, car il faut remplir manuellement les numéros de sortie. Voici ce que j'ai trouvé.

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

Essayez-le en ligne.

Blocs , 51 octets 52 62 82 87 (non concurrents)

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

Non golfé:

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

Essayez-le