Radiodifusión modular


24

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:

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]

"Implementar la adición para matrices bidimensionales": hay casos de prueba unidimensionales.
Jonathan Allan

¿Podemos suponer que no tenemos entradas de matrices desiguales? (parece)
Jonathan Allan

1
@JonathanAllan Lo siento por no ser claro. Sí, puede asumir que no hay matrices irregulares. Serán matrices rectangulares. Los "unidimensionales" deben considerarse bidimensionales con tamaño 1× n(como [1 2 3]) o n× 1(como [1; 2; 3])
Luis Mendo

La transmisión que describe parece más limitada que la transmisión de MATLAB o NumPy; en su descripción, las entradas deben tener el mismo número de dimensiones, una restricción que no está presente en MATLAB o NumPy. ¿Es esta una restricción MATL, o una simplificación para los propósitos del desafío (ya que el desafío está limitado a la entrada 2D)?
user2357112 es compatible con Monica

@ user2357112 Sí, fue una simplificación en la descripción. La transmisión de MATL es la misma que en MATLAB: puede tener entradas de 3 × 2 y 3 × 1 × 5 y obtener un resultado de 3 × 2 × 5. En realidad, 3 × 2 es equivalente a 3 × 2 × 1 (dimensiones finales implícitas). Creo que es similar en Numpy (pero con dimensiones principales). Lo he aclarado en la introducción
Luis Mendo

Respuestas:


4

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.

1
Por supuesto ... veo que todos estos idiomas de golf son algo compatibles en términos de bytes necesarios para un desafío (Jelly, 05AB1E, Pyth, APL, etc.) La mayoría de las respuestas actuales son de unos 20 bytes, y aquí viene el asistente Dennis. con una respuesta a la mitad de eso ...;) Bastante gracioso cuando los memes y la verdad son lo mismo: "¡ Nadie supera a Dennis! .. "
Kevin Cruijssen

1
@KevinCruijssen APL no es un lenguaje de golf.
Adám

1
@ Adám lo sé, lo sé. Pero aún es muy corto (a pesar de haberse desarrollado por primera vez en la década de 1960). Tal vez debería haber dicho idiomas cortos en lugar de idiomas de golf. Ah bueno ..
Kevin Cruijssen

5

Carbón , 25 23 bytes

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

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:

Aθ

Ingrese todo.

    θ                   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 (aunque es más largo> _>)
Solo ASCII

5

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

espera a que Luis Mendo juegue 5 bytes más ;-)
Giuseppe

:-D Mi programa para los casos de prueba tenía 26 bytes, ¡bien hecho! Buen uso de :con entrada vectorial
Luis Mendo

4

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.


¿Podrías intercambiar ziplos argumentos, invertir fla asignación de comprensión y así eliminar un espacio ( for i,*l-> for*l,i)? ( 125 bytes )?
Jonathan Frech

Un byte más, gracias! Actualizaré mi publicación.
Etene

3

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!


3

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.

3

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!


¡Agradable! He reducido esto a 104 bytes, pero lo he considerado applyy rep.lenes lo que había considerado, aunque no había podido codificarlo yo mismo.
Giuseppe

@Giuseppe Gracias! Sin embargo, la versión 104 no da el resultado esperado.
JayCe

1
¡Ugh, te sigo desviando! este debería funcionar
Giuseppe

1
@Giuseppe Me encanta el uso de dim, mucho más limpio y abre la puerta a una generalización multidimensional con llamadas recursivas ar
JayCe

He estado tratando de usar el outer(x,y,"+")que contiene todas las sumas correctas, y en un patrón claro. No puedo entender cómo extraerlos de manera eficiente.
ngm


2

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

2

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.

2

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


2

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

Tomé ideas de nuestras soluciones y bajé a 105 bytes . Sin embargo, tuve que usar Python 2, y obtuve el truco de multiplicación de su código, por lo que no sería correcto actualizar mi respuesta :)
etene

1
@etene Deberías publicarlo, ¡es una buena solución!
Dead Possum

Maldición, errores bastante estúpidos de mi parte, ¡gracias (de nuevo)!
etene

1
@etene Acabo de notar que esta solución tenía problemas con 2 y 6 casos de prueba. Necesidad de eliminar referencias copiadas
Dead Possum

1
@etene Volver a 105 bytes : C
Dead Possum

2

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

1

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.