Este desafío está relacionado con algunas de las características del lenguaje MATL, como parte del evento Idioma del mes de mayo de 2018 .

Introducción

En MATL, muchas funciones de dos entradas funcionan por elementos con broadcast . Esto significa lo siguiente:

• En cuanto al elemento (o vectorizado ): la función toma como entradas dos matrices con tamaños coincidentes. La operación definida por la función se aplica a cada par de entradas correspondientes. Por ejemplo, usando la notación posterior a la corrección:

  [2 4 6] [10 20 30] +
  

  da la salida

  [12 24 36]
  

  Esto también funciona con matrices multidimensionales. La notación [1 2 3; 4 5 6]representa la matriz 2× 3(matriz)

  1 2 3
  4 5 6
  

  que tiene tamaño a lo 2largo de la primera dimensión (vertical) y a lo 3largo de la segunda (horizontal). Así por ejemplo

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

  da

  [20 80 180; 120 300 560]
  

• Difusión o ( expansión singleton ): las dos matrices de entrada no tienen tamaños coincidentes, pero en cada dimensión no coincidente, una de las matrices tiene tamaño 1. Esta matriz se replica implícitamente a lo largo de las otras dimensiones para hacer coincidir los tamaños; y luego la operación se aplica por elementos como se indicó anteriormente. Por ejemplo, considere dos matrices de entrada con tamaños 1× 2y 3× 1:

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

  Gracias a la transmisión, esto es equivalente a

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

  y entonces da

  [10 20; 5 10; 2 4]
  

  Del mismo modo, con los tamaños 3× 2y 3× 1(la transmisión ahora actúa solo a lo largo de la segunda dimensión),

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

  da

  [19 18; 27 26; 35 34]
  

  El número de dimensiones puede incluso ser diferente. Por ejemplo, las entradas con tamaños 3 × 2 y 3 × 1 × 5 son compatibles y dan un resultado de 3 × 2 × 5. De hecho, el tamaño 3 × 2 es el mismo que 3 × 2 × 1 (hay arbitrariamente muchas dimensiones singleton finales implícitas).

  Por otro lado, un par de matrices 2× 2y 3× 1darían un error, porque los tamaños a lo largo de la primera dimensión son 2y 3: no son iguales y ninguno lo es 1.

Definición de radiodifusión modular

La transmisión modular es una generalización de la transmisión que funciona incluso si ninguno de los tamaños no coincidentes es 1. Considere, por ejemplo, las siguientes matrices 2× 2y 3× 1como entradas de la función +:

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

La regla es la siguiente: para cada dimensión, la matriz que es más pequeña a lo largo de esa dimensión se replica modularmente (cíclicamente) para que coincida con el tamaño de la otra matriz. Esto haría que lo anterior sea equivalente a

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

con el resultado

[12 14; 26 28; 32 34]

Como segundo ejemplo,

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

produciría

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

En general, las entradas con tamaños a× by c× ddan un resultado de tamaño max(a,b)× max(c,d).

El reto

Implemente la adición para matrices bidimensionales con transmisión modular como se definió anteriormente.

Las matrices serán rectangulares (no irregulares), solo contendrán enteros no negativos y tendrán un tamaño de al menos1 en cada dimensión.

Reglas adicionales:

• La entrada y la salida se pueden tomar por cualquier medio razonable . Su formato es flexible como siempre.

• Se permiten programas o funciones, en cualquier lenguaje de programación . Las lagunas estándar están prohibidas .

• El código más corto en bytes gana.

Casos de prueba

Los siguientes usos ;como separador de filas (como en los ejemplos anteriores). Cada caso de prueba muestra las dos entradas y luego la salida.

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

Jalea , 10 bytes

ṁ€ZL$Z€Ɗ⁺S

Toma un par de matrices (dos matrices de filas) como entrada y devuelve una matriz.

Pruébalo en línea!

Cómo funciona

ṁ€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.

Carbón , 25 23 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como una matriz tridimensional. Explicación:

Ａθ

Ingrese todo.

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

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

Pruébalo en línea!

¡Finalmente! ¡Solo tomó una semana para que el desafío inspirado en el Idioma del mes fuera respondido por el Idioma del mes!

Supongo que no es lo más corto posible, pero estoy bastante feliz porque mi versión inicial tenía más de 40 bytes. editar: ¡Tenía razón, Luis encontró otro byte para exprimir!

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

golfó un byte cambiando sum(m)am+n

Un byte más gracias a @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))))

Toma datos como una lista de dos matrices bidimensionales.

• La Zlambda toma dos matrices como entrada y devuelve un iterador que produce un índice y valores fusionados de ambas matrices, hasta que el índice alcanza la longitud de la matriz más grande. La variable de índice no es útil para mí y me cuesta bytes, pero no sé cómo hacerlo sin ella ... ( relacionado )
• La lambda principal solo toma las matrices de entrada y llama Za las matrices externas e internas. Los valores más internos se suman.

Pruébalo en línea!

Usar se itertools.cyclesiente un poco como hacer trampa, pero creo que la longitud de la declaración de importación me ha castigado lo suficiente :)

Estoy seguro de que esto podría ser Jugamos al golf un poco más, especialmente el método de iteración que las hojas de estos inútiles iy jvariables. Le agradecería cualquier consejo sobre cómo jugar golf, probablemente me estoy perdiendo algo obvio.

JavaScript (ES6), 131 bytes

No es la herramienta adecuada para el trabajo, y probablemente tampoco sea el enfoque correcto. Oh bueno ... ¯ \ _ (ツ) _ / ¯

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

Pruébalo en línea!

¿Cómo?

La función auxiliar g () crea una matriz que es tan grande como la matriz de entrada más grande ( una o b ) e invoca la función de devolución de llamada c sobre ella:

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

La función auxiliar h () lee la matriz 2D a en (x, y) con transmisión modular:

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

El código principal ahora simplemente se lee como:

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

Versión recursiva, 134 bytes.

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)

Pruébalo en línea!

05AB1E , 15 bytes

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

Pruébalo en línea!

Versión anterior, 25 bytes

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

Pruébalo en línea!

Explicación

15 byter:

2FεIζg∍ø] øεø¨} O - Programa completo. Toma la entrada como una lista 3D [A, B] de STDIN.
2F - Aplicar dos veces:
  ε - Para cada uno en [A, B]:
   Iζ - Transponer la entrada (llenar espacios con espacios).
     g - Longitud (recupera el número de filas).
      ∍ - Extiende el elemento actual (A o B) a la longitud necesaria.
       ø - Transponer.
        ] - Cierra todos los bucles.
         ø - Transponer de nuevo.
          ε - Para cada fila en ^ (columna del resultado de los bucles):
           ø - Transponer la columna.
            ¨} - Elimina el último elemento y cierra el bucle del mapa.
              O - Suma.

25 byter:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Programa completo. Toma datos como una lista 3D de STDIN.
é: ordena la lista por longitud.
 `D - Volcar contenido por separado en la pila, duplicar los ToS.
   Š - Realiza un intercambio triple. a, b, c -> c, a, b.
    g - Obtenga la longitud de los ToS.
     ∍ - Extienda la lista más corta (en altura) en consecuencia.
      ) Σ} - Envuelva toda la pila en una lista y ordénela por:
        нg: la longitud de su primer elemento.
           `DŠ - Igual que el anterior.
              нg - La longitud del primer elemento.
                δ∍ € ˜ - Extiende la lista más corta (en ancho) en consecuencia. 
                    ) ø - Envuelva la pila en una lista y transponga (zip).
                      € ø - Luego comprime cada lista.
                        O: aplica la sumatoria vectorizada.

R , 136104103 95 95 bytes

Bajó la friolera de 33 35 bytes siguiendo el consejo de Giuseppe. Se las arregló para obtener menos de 100 bytes utilizando un operador como nombre de función. Consulte el historial para obtener un código más legible.

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)

Pruébalo en línea!

K (ngn / k) , 23 bytes

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

Pruébalo en línea!

05AB1E , 18 bytes

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

Pruébalo en línea!

Explicación

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

KeSmlhdQmm+Fm@@bdkQKeSlM

Pruébalo aquí

Explicación

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 bytes

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

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

esta podría ser la única vez que tengo la oportunidad de usar |[0]

Python 2 , 124 116 bytes

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

Pruébalo en línea!

Explicación:

Toma la lista de dos listas 2-d como entrada.

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 bytes

Editar: Gracias (¡otra vez!) A Dead Possum por guardar 4 bytes

Edición 2: perdió 8 bytes, algunos casos de prueba no pasaban

Una mezcla entre la solución anterior de Dead Possum (¡gracias a él!) Y mi propia solución 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)`)

Pruébalo en línea!

La misma entrada que mi solución Python 3 (un par de listas de 2 dimensiones).

Código comentado:

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

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

Pruébalo en línea!

(Reemplazar ⧻con \gracias a Jo King )

Funciona repitiendo cada matriz horizontal y verticalmente para que ambas tengan el mismo tamaño (producto de tamaños de fila x producto de tamaños de columna), sumando esas y extrayendo la región correcta de eso. (Las entradas de vector de fila o las entradas de vector de columna necesitan una reshapellamada para convertirse en matrices bidimensionales, lo que supongo que está bien, ya que la pregunta especifica "Implementar la adición para matrices bidimensionales" y "Cualquier entrada puede tomar la entrada y la salida medios razonables. Su formato es flexible como de costumbre ")