Correlato , ma molto diverso.

Negli esempi che seguono, Ae Bsarà di 2-by-2 matrici e le matrici sono uno indicizzate.

Un prodotto Kronecker ha le seguenti proprietà:

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)

Sfida: date due matrici Ae Britorno A⊗B.

• La dimensione delle matrici sarà almeno 1-by-1. La dimensione massima sarà quella che il tuo computer / lingua può gestire per impostazione predefinita, ma 5-by-5input minimo .
• Tutti i valori di input saranno numeri interi non negativi
• Le funzioni incorporate che calcolano i prodotti Kronecker o i prodotti Tensore / Esterno non sono consentite
• In generale: regole standard relative a formato I / O, programma e funzioni, scappatoie ecc.

Casi test:

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

Gelatina, 10 9 byte

×€€;"/€;/

Utilizza l'algoritmo di Büttner ( üpronunciato quando si cerca di emettere un eesuono [come in un incontro] nella forma della bocca di un oosuono [come nello stivale]).

L' ;"/€;/ispirato a Dennis Mitchell . In origine era Z€F€€;/(che costa un altro byte).

• Caso di prova 1
• Caso di prova 2
• Caso di prova 3
• Caso di prova 4

CJam, 13 byte

{ffff*::.+:~}

Questo è un blocco senza nome che prevede due matrici in cima alla pila e lascia il loro prodotto Kronecker al loro posto.

Suite di test.

Spiegazione

Questa è solo la parte del prodotto Kronecker della risposta precedente , quindi sono qui solo per riprodurre le parti pertinenti della spiegazione precedente:

Ecco una rapida panoramica degli operatori infix di CJam per la manipolazione degli elenchi:

• fsi aspetta un elenco e qualcos'altro nello stack e mappa il seguente operatore binario sull'elenco, passando l'altro elemento come secondo argomento. Ad esempio [1 2 3] 2 f*ed 2 [1 2 3] f*entrambi danno [2 4 6]. Se entrambi gli elementi sono elenchi, il primo viene mappato e il secondo viene utilizzato per eseguire il curry dell'operatore binario.
• :ha due usi: se l'operatore che lo segue è unario, questa è una semplice mappa. Ad esempio [1 0 -1 4 -3] :zè [1 0 1 4 3], dove zottiene il modulo di un numero. Se l'operatore che lo segue è binario, questo piegherà invece l'operatore. Ad esempio, [1 2 3 4] :+è 10.
• .vettorializza un operatore binario. Si aspetta due liste come argomenti e applica l'operatore alle coppie corrispondenti. Ad esempio, [1 2 3] [5 7 11] .*dà [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 byte

Salvato 41 byte, grazie a FryAmTheEggman!

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

Provalo qui!

Abbattersi

arrayfunè un for-loop mascherato che si moltiplica n*B, per una variabile ndefinita dal secondo argomento. Questo funziona perché il looping attraverso una matrice 2D equivale al looping attraverso un vettore. Cioè for x = Aè lo stesso di for x = A(:).

'un',0è equivalente al più dettagliato 'UniformOutput', Falsee specifica che l'output contiene celle anziché scalari.

cell2mat viene utilizzato per riconvertire le celle in una matrice numerica, che viene quindi emessa.

Pyth, 14 12 11 byte

JEsMs*RRRRJ

Traduzione della risposta di Jelly , che si basa sull'algoritmo di Büttner ( üpronunciato quando si cerca di emettere un eesuono [come nell'incontro] nella forma della bocca di un oosuono [come nello stivale]).

Provalo online (test case 1)!

Bonus: calcola B⊗Anello stesso numero di byte

JEsMs*LRLRJ

Provalo online (test case 1)!

Julia, 40 39 37 byte

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

Provalo online!

Come funziona

• Per le matrici A e B , map(a->a*B,A')calcola il prodotto Kronecker A⊗B .

  Il risultato è un vettore di blocchi matrice con le dimensioni di B .

  Dobbiamo trasporre A (con ') poiché le matrici sono memorizzate nell'ordine della colonna maggiore.

• sum(A^0)calcola la somma di tutte le voci della matrice identità delle dimensioni di A. Per una matrice n × n A , questo produce n .

• Con il primo argomento n , hvcatconcatena n blocchi di matrice in orizzontale e i blocchi (più grandi) risultanti in verticale.

J, 10 byte

Questa è una possibile implementazione.

[:,./^:2*/

J, 13 byte

Questa è un'implementazione simile, ma utilizza invece la capacità di J di definire i ranghi. Si applica *tra ogni elemento sull'LHS con l'intero 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

Implementazione semplice con loop nidificato

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

Test

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>