Illustrer le carré d'un binôme

28

É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
code-golf  math  arithmetic  array-manipulation  grid 
— Adam
source
quelle est la valeur maximale des nombres saisis? Merci.
— don bright
1
@donbright Aucune limite artificielle. La seule limite est ce que votre ordinateur et votre langage peuvent gérer en termes de représentation, de calcul (avec l'algorithme choisi) et de résultat. Potentiellement, un ordinateur moderne équipé d'une imprimante qui accepte les données ligne par ligne, n'aurait presque aucune limite ... :-)
— Adam
L'orientation du carré est-elle donnée ou pouvons-nous la faire pivoter de 90 degrés?
— John Dvorak
1
Pourquoi le bonus pour 0 valeur cependant? Quelle serait la sortie attendue si ce n'était pas juste un carré?
— Mars Ho
@MarchHo C'est pourquoi le bonus est si petit. Néanmoins, certaines langues peuvent ne pas être en mesure de gérer des tableaux vides.
— 2015

Réponses:

14

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
— Zgarb
source
Cela me fait me sentir comme chez moi.
— 2015
3
Cette solution ressemble à une variation obscure de l' table flipperémoticône ASCII (╯ ° □ °） ╯︵ ┻━┻
— Pete TNT
10

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

— gobelet
source
Vous pouvez supprimer le fichier s=. Nous avons la convention selon laquelle les fonctions / lambdas anonymes ne doivent pas être stockées dans une variable.
— flawr
6
@flawr mais la réponse ne serait pas 42 ...
— bécher
OK.
— Adám
9

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.

— Adam
source
1
Agréable! Même idée en J avec un score égal:(|.*/])@#~
— Zgarb
@Zgarb Mettez à jour votre réponse et mettez une note comme la mienne. J le mérite!
— 2015
7

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
— freekvd
source
Vous aurez probablement besoin de l'envelopper dans catou writepour que ce soit une réponse valide.
— David Arenburg
@DavidArenburg Je ne vois pas pourquoi? Il dit "Sortie (par tous les moyens)". Il ne m'a fallu qu'un seul moyen pour produire ce qui me met dans les exigences.
— freekvd
Ouais, tu as peut-être raison. Je ne sais pas ce qu'ils veulent dire par là.
— David Arenburg
@DavidArenburg Ouais, ça va. C'est un défi de données / texte, pas un défi d'entrée / sortie.
— 2015
5

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.

— nimi
source
4

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}

ex1

Exemple 2

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

ex2

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]
— DavidC
source
1
C'est ingénieux. Avec cette méthode, je peux réduire ma propre solution de 4 caractères.
— 2015
Merci. Je viens de réaliser que la même approche fonctionne avec une fonction nommée. Voir la méthode 2 ci-dessus.
— DavidC
4

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
— alephalpha
source
Wow, je n'avais aucune idée de l' repelemsexistence. Impressionnant!
— bécher
4

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.
— Martin Ender
source
Bien, mais qu'est-ce qui cause autant d'espace blanc et que faudrait-il pour le réduire?
— 2015
1
@NBZ Le moyen le plus court que j'ai trouvé jusqu'à présent pour calculer une limite supérieure fiable sur la largeur de la cellule est d'utiliser deux fois la longueur de la chaîne d'entrée (car le plus grand nombre au carré n'aura pas plus de deux fois plus de chiffres que le nombre lui-même). Bien sûr, je pourrais calculer le montant réel nécessaire en fonction des chiffres obtenus, mais ce serait un peu plus long.
— Martin Ender
4

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
$
— Traumatisme numérique
source
D'après mon expérience, la valeur de retour de puts()dépend de la machine. C'est 10 sur le mien par exemple. En outre, voici une astuce: vous pouvez généralement compresser deux boucles en une seule si vous incrémentez conditionnellement le compteur dans la boucle externe. Ma solution montre comment cela peut être fait.
— xsot
@xsot Oui, le puts()code retour n'est garanti que pour être positif . Cependant, mes tests avec la glibc semblent montrer que la valeur de retour est le nombre d'octets écrits. En ce qui concerne la consolidation de boucle - oui, je connais cette technique et je l'ai essayée ici, jusqu'à présent sans raccourcir dans ce cas.
— Digital Trauma
2

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
— Golgappa
source
2
Bienvenue chez PPCG! Je ne pense pas que votre rembourrage soit suffisant pour les grands nombres. Pensez à en avoir un 1et un grand nombre comme 9999. Cela sapparaîtra alors 4, vous remplissez donc à une largeur de s+3 = 7mais avez 9999^2besoin de 8 chiffres. Vous voudrez peut-être utiliser à la 2*splace.
— Martin Ender
2
Quoi qu'il en soit, voici quelques conseils sur le golf: je ne vois pas pourquoi vous en avez besoin rjustavant de faire ljust. Vous pouvez réduire printà $><<(et de se débarrasser de l'espace après). ARGVa un alias $*. Vous pouvez peut-être éviter cela flattenen créant votre tableau avec quelque chose comme ceci: codegolf.stackexchange.com/a/19493/8478 . De plus, les réponses uniquement fonctionnelles sont définitivement autorisées ici (même les fonctions sans nom), de sorte que cette fonction puisse prendre les entiers comme entrées, et vous n'auriez pas à en faire .to_i.
— Martin Ender
@ MartinBüttner, merci pour les conseils.
— Harsh Gupta
2

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.

— Don Bright
source
Méthode intéressante.
— 2015
1

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)]
— Luis Mendo
source
1

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.

— xsot
source
j'ai du mal à obtenir cela pour compiler avec gcc (4.8.4) ...
— don bright
1
J'ai testé cela sur golf.shinh.org/check.rb qui utilise le paquet debian gcc-4.6.1-2. Quelles erreurs de compilation obtenez-vous?
— xsot
désolé, j'ai réessayé comme une seule ligne et cela a fonctionné, ... mais quand je cours, je reçois un défaut de segmentation. j'ai entré la chaîne 2 3 et appuyez sur retour et il indique la faute de segmentation (core dumped)
— don bright
Désolé mais je ne sais pas pourquoi cela ne fonctionnera pas pour vous. Au moins, vous pouvez toujours essayer le code sur le site que j'ai lié plus tôt :)
— xsot
1

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.

— PurkkaKoodari
source
1

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

— Downgoat
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.