Radiodiffusion modulaire


24

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:

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]

"Implémenter l'addition pour les tableaux bidimensionnels" - il existe des cas de test unidimensionnels.
Jonathan Allan

Pouvons-nous supposer que nous n'obtenons aucune entrée de tableaux irréguliers? (ça y ressemble)
Jonathan Allan

1
@JonathanAllan Désolé de ne pas avoir été clair. Oui, vous ne pouvez supposer aucun tableau en lambeaux. Ce seront des tableaux rectangulaires. Ceux "unidimensionnels" doivent être considérés comme bidimensionnels avec une taille 1× n(comme [1 2 3]) ou n× 1(comme [1; 2; 3])
Luis Mendo

La diffusion que vous décrivez semble plus limitée que la diffusion MATLAB ou NumPy; dans votre description, les entrées doivent avoir le même nombre de dimensions, une restriction non présente dans MATLAB ou NumPy. S'agit-il d'une restriction MATL ou d'une simplification aux fins du défi (puisque le défi est limité à la saisie 2D)?
user2357112 prend en charge Monica

@ user2357112 Oui, c'était une simplification dans la description. La diffusion de MATL est la même que dans MATLAB: vous pouvez avoir des entrées 3 × 2 et 3 × 1 × 5 et obtenir un résultat 3 × 2 × 5. En fait, 3 × 2 équivaut à 3 × 2 × 1 (dimensions de fin implicites). Je pense qu'il est similaire dans Numpy (mais avec des dimensions principales). Je l'ai précisé dans l'introduction
Luis Mendo

Réponses:


4

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.

1
Bien sûr ... Je vois tous ces langages de golf comme quelque peu compatibles en termes d'octets nécessaires pour un défi (Jelly, 05AB1E, Pyth, APL, etc.) La plupart des réponses actuelles sont d'environ 20 octets, et voici Wizard Dennis avec une réponse divisée par deux ..;) Assez drôle quand mèmes et vérité sont une seule et même chose: " Personne ne surpasse Dennis! .. "
Kevin Cruijssen

1
@KevinCruijssen APL n'est pas une langue de golf.
Adám

1
@ Adám je sais, je sais. Mais il est encore très court (bien qu'il ait été développé pour la première fois dans les années 1960). J'aurais peut-être dû dire des langues courtes plutôt que des langues de golf. Ah bien ..
Kevin Cruijssen

5

Fusain , 25 23 octets

AθIE⌈EθLιE⌈EθL§λ⁰ΣE觧νιλ

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:

Aθ

Saisissez tout.

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

: P (c'est plus long que> _>)
ASCII uniquement

5

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

attend que Luis Mendo joue au golf de 5 octets de plus ;-)
Giuseppe

:-D Mon programme pour les cas de test avait 26 octets, bravo! Belle utilisation de l' :entrée vectorielle
Luis Mendo

4

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.


Pourriez-vous échanger vos ziparguments, inverser fle devoir de compréhension et ainsi supprimer un espace ( for i,*l-> for*l,i)? ( 125 octets )?
Jonathan Frech

Encore un octet, merci! Je mettrai à jour mon message.
etene

3

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!


3

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.

3

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!


Agréable! J'ai joué au golf à 104 octets, mais en utilisant applyet rep.lenc'est ce que j'avais envisagé, même si je n'avais pas réussi à le coder moi-même.
Giuseppe

@Giuseppe Merci! La version 104 ne donne cependant pas la sortie attendue.
JayCe

1
Ugh, je continue de vous induire en erreur! celui-ci devrait fonctionner
Giuseppe

1
@Giuseppe Love l'utilisation de dim, beaucoup plus propre et ouvre la porte à une généralisation multidimensionnelle avec des appels récursifs àr
JayCe

J'ai essayé d'utiliser outer(x,y,"+")ce qui contient toutes les bonnes sommes et de façon claire. Je ne sais pas comment les extraire efficacement.
ngm


2

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

2

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.

2

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


2

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

J'ai pris des idées de nos deux solutions et je suis descendu à 105 octets . J'ai dû utiliser Python 2 cependant, et j'ai eu l'astuce de multiplication de votre code, donc il ne me
semble

1
@etene Vous devriez le poster, c'est une bonne solution!
Dead Possum

Merde, des erreurs assez stupides de ma part, merci (encore)!
etene

1
@etene Je viens de remarquer que cette solution avait des problèmes avec 2 et 6 cas de test. Besoin de supprimer les références copiées
Dead Possum

1
@etene Retour à 105 octets : C
Dead Possum

2

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

1

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. ")

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.