Relacionado , pero muy diferente.

En los siguientes ejemplos, Ay Bserán matrices de 2 por 2, y las matrices están indexadas en uno.

Un producto Kronecker tiene las siguientes propiedades:

A⊗B =  A(1,1)*B   A(1,2)*B
        A(2,1)*B   A(2,2)*B

     =  A(1,1)*B(1,1)   A(1,1)*B(1,2)   A(1,2)*B(1,1)   A(1,2)*B(1,2)
        A(1,1)*B(2,1)   A(1,1)*B(2,2)   A(1,2)*B(2,1)   A(1,2)*B(2,2)
        A(2,1)*B(1,1)   A(2,1)*B(1,2)   A(2,2)*B(1,1)   A(2,2)*B(1,2)
        A(2,2)*B(2,1)   A(2,2)*B(1,2)   A(2,2)*B(2,1)   A(2,2)*B(2,2)

Reto: Dadas dos matrices, Ay B, regreso A⊗B.

• El tamaño de las matrices será al menos 1-by-1. El tamaño máximo será lo que su computadora / idioma pueda manejar por defecto, pero la 5-by-5entrada mínima .
• Todos los valores de entrada serán enteros no negativos
• Las funciones integradas que calculan productos Kronecker o productos Tensor / Externo no están permitidas
• En general: Reglas estándar sobre formato de E / S, programa y funciones, lagunas, etc.

Casos de prueba:

A =   
     1     2
     3     4    
B =    
     5     6
     7     8    
A⊗B =    
     5     6    10    12
     7     8    14    16
    15    18    20    24
    21    24    28    32

B⊗A =    
     5    10     6    12
    15    20    18    24
     7    14     8    16
    21    28    24    32
------------------------
A =    
     1
     2
B =    
     1     2

A⊗B =    
     1     2
     2     4
------------------------
A =    
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

B =    
     1     1
     0     1

A⊗B  =    
    16    16     2     2     3     3    13    13
     0    16     0     2     0     3     0    13
     5     5    11    11    10    10     8     8
     0     5     0    11     0    10     0     8
     9     9     7     7     6     6    12    12
     0     9     0     7     0     6     0    12
     4     4    14    14    15    15     1     1
     0     4     0    14     0    15     0     1

B⊗A =    
    16     2     3    13    16     2     3    13
     5    11    10     8     5    11    10     8
     9     7     6    12     9     7     6    12
     4    14    15     1     4    14    15     1
     0     0     0     0    16     2     3    13
     0     0     0     0     5    11    10     8
     0     0     0     0     9     7     6    12
     0     0     0     0     4    14    15     1
------------------------

A = 2
B = 5
A⊗B = 10

Jalea, 10 9 bytes

×€€;"/€;/

Utiliza el Algoritmo de Büttner ( üpronunciado cuando se intenta hacer un eesonido [como en el encuentro] en la forma de la boca de un oosonido [como en el arranque]).

El ;"/€;/está inspirado en Dennis Mitchell . Originalmente Z€F€€;/(que cuesta un byte más).

• Caso de prueba 1
• Caso de prueba 2
• Caso de prueba 3
• Caso de prueba 4

CJam, 13 bytes

{ffff*::.+:~}

Este es un bloque sin nombre que espera dos matrices en la parte superior de la pila y deja su producto Kronecker en su lugar.

Banco de pruebas.

Explicación

Esta es solo la parte del producto Kronecker de la respuesta anterior , por lo tanto, estoy aquí reproduciendo las partes relevantes de la explicación anterior:

Aquí hay una descripción general rápida de los operadores infijos de CJam para la manipulación de listas:

• fespera una lista y algo más en la pila y asigna el siguiente operador binario sobre la lista, pasando el otro elemento como segundo argumento. Por ejemplo, [1 2 3] 2 f*y 2 [1 2 3] f*ambos dan [2 4 6]. Si ambos elementos son listas, el primero se asigna y el segundo se usa para cursar el operador binario.
• :tiene dos usos: si el operador que lo sigue es unario, este es un mapa simple. Por ejemplo, [1 0 -1 4 -3] :zes [1 0 1 4 3], donde zobtiene el módulo de un número. Si el operador que lo sigue es binario, esto doblará al operador en su lugar. Por ejemplo, [1 2 3 4] :+es 10.
• .vectoriza un operador binario. Espera dos listas como argumentos y aplica el operador a los pares correspondientes. Por ejemplo, [1 2 3] [5 7 11] .*da [5 14 33].

ffff*  e# This is the important step for the Kronecker product (but
       e# not the whole story). It's an operator which takes two matrices
       e# and replaces each cell of the first matrix with the second matrix
       e# multiplied by that cell (so yeah, we'll end up with a 4D list of
       e# matrices nested inside a matrix).
       e# Now the ffff* is essentially a 4D version of the standard ff* idiom
       e# for outer products. For an explanation of ff*, see the answer to
       e# to the Kronecker sum challenge.
       e# The first ff maps over the cells of the first matrix, passing in the 
       e# second matrix as an additional argument. The second ff then maps over 
       e# the second matrix, passing in the cell from the outer map. We 
       e# multiply them with *.
       e# Just to recap, we've essentially got the Kronecker product on the
       e# stack now, but it's still a 4D list not a 2D list.
       e# The four dimensions are:
       e#   1. Columns of the outer matrix.
       e#   2. Rows of the outer matrix.
       e#   3. Columns of the submatrices.
       e#   4. Rows of the submatrices.
       e# We need to unravel that into a plain 2D matrix.
::.+   e# This joins the rows of submatrices across columns of the outer matrix.
       e# It might be easiest to read this from the right:
       e#   +    Takes two rows and concatenates them.
       e#   .+   Takes two matrices and concatenates corresponding rows.
       e#   :.+  Takes a list of matrices and folds .+ over them, thereby
       e#        concatenating the corresponding rows of all matrices.
       e#   ::.+ Maps this fold operation over the rows of the outer matrix.
       e# We're almost done now, we just need to flatten the outer-most level
       e# in order to get rid of the distinction of rows of the outer matrix.
:~     e# We do this by mapping ~ over those rows, which simply unwraps them.

MATLAB / Octave, 83 42 Bytes

Guardadas 41 bytes, gracias a FryAmTheEggman!

@(A,B)cell2mat(arrayfun(@(n)n*B,A,'un',0))

¡Pruébalo aquí!

Descompostura

arrayfunes un bucle for disfrazado que se multiplica n*B, para una variable ndefinida por el segundo argumento. Esto funciona porque recorrer una matriz 2D es lo mismo que recorrer un vector. Es decir, for x = Aes lo mismo que for x = A(:).

'un',0es equivalente al más detallado 'UniformOutput', Falsey especifica que la salida contiene celdas en lugar de escalares.

cell2mat se utiliza para convertir las celdas de nuevo en una matriz numérica, que luego se genera.

Pyth, 14 12 11 bytes

JEsMs*RRRRJ

Traducción de la respuesta Jelly , que se basa en el Algoritmo de Büttner ( üpronunciado cuando se intenta hacer un eesonido [como en el encuentro] en la forma de la boca de un oosonido [como en el arranque]).

¡Pruébelo en línea (caso de prueba 1)!

Bono: calcular B⊗Aen el mismo número de bytes

JEsMs*LRLRJ

¡Pruébelo en línea (caso de prueba 1)!

Julia, 40 39 37 bytes

A%B=hvcat(sum(A^0),map(a->a*B,A')...)

Pruébalo en línea!

Cómo funciona

• Para las matrices A y B , map(a->a*B,A')calcula el producto Kronecker A⊗B .

  El resultado es un vector de los bloques de la matriz con las dimensiones de B .

  Tenemos que transponer A (con ') ya que las matrices se almacenan en orden de columna mayor.

• sum(A^0)calcula la suma de todas las entradas de la matriz de identidad de las dimensiones de A. Para una matriz n × n A , esto produce n .

• Con el primer argumento n , hvcatconcatena n bloques de matriz horizontalmente y los bloques resultantes (más grandes) verticalmente.

J, 10 bytes

Esta es una posible implementación.

[:,./^:2*/

J, 13 bytes

Esta es una implementación similar, pero en su lugar utiliza la capacidad de J para definir rangos. Se aplica *entre cada elemento en el LHS con todo el RHS.

[:,./^:2*"0 _

Uso

   f =: <either definition>
    (2 2 $ 1 2 3 4) f (2 2 $ 5 6 7 8)
 5  6 10 12
 7  8 14 16
15 18 20 24
21 24 28 32
   (2 1 $ 1 2) f (1 2 $ 1 2)
1 2
2 4
   2 f 5
10

JavaScript (ES6), 79

Implementación sencilla con bucle anidado

(a,b)=>a.map(a=>b.map(b=>a.map(y=>b.map(x=>r.push(y*x)),t.push(r=[]))),t=[])&&t

Prueba

f=(a,b)=>a.map(a=>b.map(b=>a.map(y=>b.map(x=>r.push(y*x)),t.push(r=[]))),t=[])&&t

console.log=x=>O.textContent+=x+'\n'

function show(label, mat)
{
  console.log(label)
  console.log(mat.join`\n`)
}

;[ 
  {a:[[1,2],[3,4]],b:[[5,6],[7,8]] },
  {a:[[1],[2]],b:[[1,2]]},
  {a:[[16,2,3,13],[5,11,10,8],[9,7,6,12],[4,14,15,1]],b:[[1,1],[0,1]]},
  {a:[[2]],b:[[5]]}
].forEach(t=>{
  show('A',t.a)  
  show('B',t.b)
  show('A⊗B',f(t.a,t.b))
  show('B⊗A',f(t.b,t.a))  
  console.log('-----------------')
})

<pre id=O></pre>