Ce défi est lié à certaines des fonctionnalités du langage MATL, dans le cadre de l' événement Langue du mois de mai 2018 .

introduction

Dans MATL, de nombreuses fonctions à deux entrées fonctionnent par éléments avec la diffusion . Cela signifie ce qui suit:

• Par élément (ou vectorisé ): la fonction prend en entrée deux tableaux de tailles correspondantes. L'opération définie par la fonction est appliquée à chaque paire d'entrées correspondantes. Par exemple, en utilisant la notation post-fix:

  [2 4 6] [10 20 30] +
  

  donne la sortie

  [12 24 36]
  

  Cela fonctionne également avec les tableaux multidimensionnels. La notation [1 2 3; 4 5 6]représente le tableau 2× 3(matrice)

  1 2 3
  4 5 6
  

  qui a une taille le 2long de la première dimension (verticale) et le 3long de la seconde (horizontale). Donc par exemple

  [2 4 6; 3 5 7] [10 20 30; 40 60 80] *
  

  donne

  [20 80 180; 120 300 560]
  

• Diffusion ou ( expansion singleton ): les deux tableaux d'entrée n'ont pas de tailles correspondantes, mais dans chaque dimension non correspondante, l'un des tableaux a une taille 1. Ce tableau est implicitement répliqué le long des autres dimensions pour faire correspondre les tailles; puis l'opération est appliquée élément par élément comme ci-dessus. Par exemple, considérons deux tableaux d'entrée de tailles 1× 2et 3× 1:

  [10 20] [1; 2; 5] /
  

  Grâce à la diffusion, cela équivaut à

  [10 20; 10 20; 10 20] [1 1; 2 2; 5 5] /
  

  et donc ça donne

  [10 20; 5 10; 2 4]
  

  De même, avec les tailles 3× 2et 3× 1(la diffusion n'agit désormais que sur la deuxième dimension),

  [9 8; 7 6; 5 4] [10; 20; 30] +
  

  donne

  [19 18; 27 26; 35 34]
  

  Le nombre de dimensions peut même être différent. Par exemple, les entrées de tailles 3 × 2 et 3 × 1 × 5 sont compatibles et donnent un résultat 3 × 2 × 5. En fait, la taille 3 × 2 est identique à 3 × 2 × 1 (il existe arbitrairement de nombreuses dimensions singleton de fin implicites).

  D'un autre côté, une paire de tableaux 2× 2et 3× 1donnerait une erreur, car les tailles le long de la première dimension sont 2et 3: elles ne sont pas égales et aucune ne l'est 1.

Définition de la radiodiffusion modulaire

La diffusion modulaire est une généralisation de la diffusion qui fonctionne même si aucune des tailles qui ne correspondent pas 1. Considérez par exemple les tableaux 2× 2et 3× suivants 1comme entrées de la fonction +:

[2 4; 6 8] [10; 20; 30] +

La règle est la suivante: pour chaque dimension, le tableau qui est plus petit le long de cette dimension est répliqué de façon modulaire (cyclique) pour correspondre à la taille de l'autre tableau. Cela rendrait l'équivalent ci-dessus

[2 4; 6 8; 2 4] [10 10; 20 20; 30 30] +

Avec le résultat

[12 14; 26 28; 32 34]

Comme deuxième exemple,

[5 10; 15 20] [0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0] +

produirait

[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

En général, les entrées de tailles a× bet c× ddonnent un résultat de taille max(a,b)× max(c,d).

Le défi

Implémenter un ajout pour les tableaux bidimensionnels avec diffusion modulaire comme défini ci-dessus.

Les tableaux seront rectangulaires (non irréguliers), ne contiendront que des entiers non négatifs et auront une taille au moins1 dans chaque dimension.

Règles supplémentaires:

• L'entrée et la sortie peuvent être prises par tout moyen raisonnable . Leur format est flexible comme d'habitude.

• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites .

• Le code le plus court en octets gagne.

Cas de test

Les utilisations suivantes ;comme séparateur de lignes (comme dans les exemples ci-dessus). Chaque scénario de test montre les deux entrées puis la sortie.

[2 4; 6 8]
[10; 20; 30]
[12 14; 26 28; 32 34]

[5 10; 15 20]
[0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0]
[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

[1]
[2]
[3]

[1; 2]
[10]
[11; 12]

[1 2 3 4 5]
[10 20 30]
[11 22 33 14 25]

[9 12 5; 5 4 2]
[4 2; 7 3; 15 6; 4 0; 3 3]
[13 14 9;12 7 9;24 18 20;9 4 6;12 15 8]

[9 12 5; 5 4 2]
[4 2 6 7; 7 3 7 3; 15 6 0 1; 4 0 1 16; 3 3 3 8]
[13 14 11 16; 12 7 9 8; 24 18 5 10; 9 4 3 21; 12 15 8 17]

[6 7 9]
[4 2 5]
[10 9 14]

Gelée , 10 octets

ṁ€ZL$Z€Ɗ⁺S

Prend une paire de matrices (deux tableaux de lignes) en entrée et renvoie une matrice.

Essayez-le en ligne!

Comment ça marche

ṁ€ZL$Z€Ɗ⁺S  Main link. Argument: [M, N] (matrix pair)

  Z $       Zip M with N (i.e., transpose the matrix of arrays [M, N], ...
   L            then take the length (number of rows) of the result.
ṁ€          Mold M and N like the indices, cyclically repeating their rows as many
            times as needed to reach the length to the right.
     Z€     Zip each; transpose both M and N.
       Ɗ⁺   Combine the three links to the left into a chain and duplicate it.
            The first run enlarges the columns, the second run the rows.
         S  Take the sum of the modified matrices.

Fusain , 25 23 octets

ＡθＩＥ⌈ＥθＬιＥ⌈ＥθＬ§λ⁰ΣＥ觧νιλ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée comme un tableau à trois dimensions. Explication:

Ａθ

Saisissez tout.

    θ                   Input
   Ｅ                    Map over arrays
      ι                 Current array
     Ｌ                  Length
  ⌈                     Maximum
 Ｅ                      Map over implicit range
          θ             Input
         Ｅ              Map over arrays
             λ          Current array
            § ⁰         First element
           Ｌ            Length
        ⌈               Maximum
       Ｅ                Map over implicit range
                 θ      Input
                Ｅ       Map over arrays
                    ν   Current array
                   § ι  Cyclically index using outer loop index
                  §   λ Cyclically index using inner loop index
               Σ        Sum
Ｉ                       Cast to string
                        Implicitly print on separate lines and paragraphs

MATL , 25 24 octets

,iZy]vX>XKx,@GK:KP:3$)]+

Essayez-le en ligne!

Finalement! Il n'a fallu qu'une semaine pour que le défi inspiré de la langue du mois soit relevé par la langue du mois!

Je suppose que ce n'est pas aussi court que possible, mais je suis assez content car ma version initiale était supérieure à 40 octets. edit: j'avais raison, Luis a trouvé un autre octet à extraire!

,iZy]	# do twice: read input and find the size of each dimension
vX>	# find the maximum along each dimension
XKx	# save this into clipboard K and delete from stack. Stack is now empty.
,	# do twice:
 @G	# push the input at index i where i=0,1.
	# MATL indexes modularly, so 0 corresponds to the second input
 K:	# push the range 1...K[1]
 KP:	# push the range 1...K[2]
 3$)	# use 3-input ) function, which uses modular indexing
	# to expand the rows and columns to the appropriate broadcasted size
]	# end of loop
+	# sum the now appropriately-sized matrices and implicitly display

Python 3 , 127 126 125 octets

joué un octet en changeant sum(m)enm+n

Un octet de plus grâce à @Jonathan Frech

lambda y:[[m+n for n,m,j in Z(l)]for*l,i in Z(y)]
from itertools import*
Z=lambda y:zip(*map(cycle,y),range(max(map(len,y))))

Prend l'entrée comme une liste de deux tableaux bidimensionnels.

• Le Zlambda prend deux tableaux en entrée et renvoie un itérateur produisant un index et des valeurs fusionnées à partir des deux tableaux, jusqu'à ce que l'index atteigne la plus grande longueur du tableau. La variable d'index ne m'est pas utile et me coûte des octets, mais je ne sais pas comment m'en passer ... ( lié )
• Le lambda principal prend simplement les tableaux d'entrée et appelle Zles tableaux externes et internes. Les valeurs les plus intérieures sont additionnées.

Essayez-le en ligne!

L'utilisation itertools.cycleressemble un peu à de la triche, mais je pense que j'ai été suffisamment puni par la longueur de la déclaration d'importation :)

Je suis sûr que cela pourrait être joué un peu plus, en particulier la méthode d'itération qui laisse ces variables inutiles iet j. Je serais reconnaissant de tous les conseils sur la façon de jouer au golf, je manque probablement quelque chose d'évident.

JavaScript (ES6), 131 octets

Pas le bon outil pour le travail, et probablement pas la bonne approche non plus. Eh bien ... ¯ \ _ (ツ) _ / ¯

a=>b=>(g=(a,b,c)=>[...Array((a[b[L='length']]?a:b)[L])].map(c))(a,b,(_,y)=>g(a[0],b[0],(_,x)=>(h=a=>a[y%a[L]][x%a[0][L]])(a)+h(b)))

Essayez-le en ligne!

Comment?

La fonction d'assistance g () crée un tableau qui est aussi grand que le plus grand tableau d'entrée ( a ou b ) et appelle la fonction de rappel c par-dessus:

g = (a, b, c) =>
  [...Array(
    (a[b[L = 'length']] ? a : b)[L]
  )].map(c)

La fonction d'assistance h () lit le tableau 2D a en (x, y) avec une diffusion modulaire:

h = a => a[y % a[L]][x % a[0][L]]

Le code principal se lit maintenant simplement comme suit:

a => b =>
  g(a, b, (_, y) =>
    g(a[0], b[0], (_, x) =>
      h(a) + h(b)
    )
  )

Version récursive, 134 octets

a=>b=>(R=[],g=x=>a[y]||b[y]?a[0][x]+1|b[0][x]+1?g(x+1,(R[y]=R[y]||[])[x]=(h=a=>a[y%a.length][x%a[0].length])(a)+h(b)):g(+!++y):R)(y=0)

Essayez-le en ligne!

05AB1E , 15 octets

2FεIζg∍ø]øεø¨}O

Essayez-le en ligne!

Ancienne version, 25 octets

é`DŠg∍)Σнg}`DŠнgδ∍€˜)ø€øO

Essayez-le en ligne!

Explication

15 octets:

2FεIζg∍ø] øεø¨} O - Programme complet. Prend l'entrée en tant que liste 3D [A, B] de STDIN.
2F - Appliquer deux fois:
  ε - Pour chacun dans [A, B]:
   Iζ - Transposer l'entrée (combler les lacunes avec des espaces).
     g - Longueur (récupérer le nombre de lignes).
      ∍ - Prolongez l'élément actuel (A ou B) à la longueur nécessaire.
       ø - Transposer.
        ] - Ferme toutes les boucles.
         ø - Transposer à nouveau.
          ε - Pour chaque ligne de ^ (colonne du résultat des boucles):
           ø - Transposer la colonne.
            ¨} - Supprimez le dernier élément et fermez la boucle de carte.
              O - Somme.

25 octets:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Programme complet. Prend l'entrée sous forme de liste 3D de STDIN.
é - Trier la liste par longueur.
 `D - Vider le contenu séparément sur la pile, dupliquer le ToS.
   Š - Effectuez un triple échange. a, b, c -> c, a, b.
    g - Obtenez la longueur du ToS.
     ∍ - Étendez la liste plus courte (en hauteur) en conséquence.
      ) Σ} - Enveloppez la pile entière dans une liste et triez-la par:
        нg - La longueur de son premier élément.
           `DŠ - Comme ci-dessus.
              нg - La longueur du premier élément.
                δ∍ € ˜ - Étendez la liste plus courte (en largeur) en conséquence. 
                    ) ø - Envelopper la pile dans une liste et la transposer (zip).
                      € ø - Puis zippez chaque liste.
                        O - Appliquer la sommation vectorisée.

R , 136 104 103 103 95 93 octets

Golfé sur un énorme 33 35 octets suivant les conseils de Giuseppe. Géré pour obtenir moins de 100 octets en utilisant un opérateur comme nom de fonction. Voir l'historique pour un code plus lisible.

function(x,y,d=pmax(dim(x),dim(y)))y/d[2]/d[1]+x/d[2]/d[1]
"/"=function(x,j)apply(x,1,rep,,j)

Essayez-le en ligne!

K (ngn / k) , 23 octets

{+/2{+:'(|/#:'x)#'x}/x}

Essayez-le en ligne!

05AB1E , 18 octets

éR`UvXNèy‚é`©g∍®+ˆ

Essayez-le en ligne!

Explication

éR                  # sort by length, descending
  `U                # store the shorter list in X
    v               # for each list y, index N in the longer list
     XNè            # get the nth element of the shorter list
        y‚é         # pair with y and sort by length
           `©g∍     # repeat the shorter list to the same length as the longer
               ®+   # elementwise addition of the lists
                 ˆ  # add to global list
                    # implicitly print global list

Pyth, 24 octets

KeSmlhdQmm+Fm@@bdkQKeSlM

Essayez-le ici

Explication

KeSmlhdQmm+Fm@@bdkQKeSlM
                    eSlMQ  Get the maximum length of (implicit) input...
KeSmlhdQ           K       ... and the maximum row length.
        mm                 For each 2d index ...
          +Fm@@bdkQ        ... get the sum of the appropriate elements.

Java 8, 172 octets

A->B->{int m=A.length,o=A[0].length,d=B.length,u=B[0].length,l=m>d?m:d,a=o>u?o:u,r[][]=new int[l][a],$;for(;l-->0;)for($=a;$-->0;)r[l][$]=A[l%m][$%o]+B[l%d][$%u];return r;}

Essayez-le en ligne.

Explication:

A->B->{                   // Method with integer-matrix as both parameters and return-type
  int m=A.length,         //  Rows of `A`                        (we got an     M)
      o=A[0].length,      //  Columns of `A`                     (we got an     O)
      d=B.length,         //  Rows of `B`                        (we got a      D)
      u=B[0].length,      //  Columns of `B`                     (we got a      U)
      l=m>d?m:d,          //  Maximum of both rows               (we got an     L)
      a=o>u?o:u,          //  Maximum of both columns            (we got an     A)
      r[][]=new int[l][a],//  Result-matrix of size `l` by `a`   (and we got an R)
      $;                  //  Temp integer                       (which $pells? ;P)
  for(;l-->0;)            //  Loop over the rows
    for($=a;$-->0;)       //   Inner loop over the columns
      r[l][$]=            //    Set the current cell in the result-matrix to:
        A[l%m][$%o]       //     The value at {`l` modulo-`m`, `$` modulo-`o`} in `A`
        +B[l%d][$%u];     //     Plus the value at {`l` modulo-`d`, `$` modulo-`u`} in `B`
  return r;}              //  Return the result matrix

APL (Dyalog Classic) , 23 21 octets

↑{+⌿⍺[⍵|[0]⍳⍴⍺]}2,¨⍴¨

Essayez-le en ligne!

cela pourrait être la seule fois où j'aurais la chance d'utiliser |[0]

Python 2 , 124 116 octets

l=len
A,B=sorted(input(),key=l)
A*=l(B)
for i in eval(`zip(A,B)`):a,b=sorted(i,key=l);a*=l(b);print map(sum,zip(*i))

Essayez-le en ligne!

Explication:

Prend la liste de deux listes 2D comme entrée.

l=len
A,B=sorted(input(),key=l)         # Sort inputed lists by length
A*=l(B)                           # Extend shorter list
for i in eval(`zip(A,B)`):        # Zip and remove copied references
  a,b=sorted(i,key=l)             # Sort lists in each pair (keep references)
  a*=l(b)                         # Extend shorter list
  print map(sum,zip(*i))          # Zip and sum

Python 2 , 101 97 105 octets

Edit: Merci (encore!) À Dead Possum pour avoir sauvé 4 octets

Edit 2: perdu 8 octets, certains cas de test ne passaient pas

Un mélange entre la solution antérieure de Dead Possum (grâce à lui!), Et ma propre solution Python 3 .

lambda y:[map(sum,P(i))for i in P(y)]
def P(y):y=sorted(y,key=len);y[0]*=len(y[1]);return eval(`zip(*y)`)

Essayez-le en ligne!

Même entrée que ma solution Python 3 (une paire de listes bidimensionnelles).

Code commenté:

# Iterate over the nested lists, resized & joined by P(),
# and sum the inner joined items
lambda y:[map(sum,P(i))for i in P(y)]
def P(y):
 y=sorted(y,key=len)  # Sort the two input lists by length
 y[0]*=len(y[1])      # Multiply the smallest one by the biggest one's length
                      # (The smallest list is now the previously largest one)
 return eval(`zip(*y)`)  # Return paired list elements up to the smallest list's length

Julia 0,6 , 85 83 octets

M\N=(((r,c),(s,d))=size.((M,N));repmat(M,s,d)+repmat(N,r,c))[1:max(r,s),1:max(c,d)]

Essayez-le en ligne!

(Remplacez ⧻par \merci à Jo King )

Fonctionne en répétant chaque matrice horizontalement et verticalement afin qu'elles aient toutes les deux la même taille (produit des tailles de ligne x produit des tailles de colonne), en les additionnant et en extrayant la région correcte à partir de cela. (Les entrées de vecteur de ligne ou les entrées de vecteur de colonne ont besoin d'un reshapeappel pour être converties en tableaux bidimensionnels, ce qui, je suppose, est correct car la question spécifie «Implémenter l'ajout pour les tableaux bidimensionnels» et «L'entrée et la sortie peuvent être prises par n'importe quel moyens raisonnables. Leur format est flexible comme d'habitude. ")