Verwandte , aber sehr unterschiedlich.

In den nachfolgenden Beispielen sind, Aund Bwird 2-mal-2 - Matrix sein, und die Matrizen sind eint indexiert.

Ein Kronecker- Produkt hat folgende Eigenschaften:

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)

Herausforderung: Bei zwei Matrizen Aund Bzurück A⊗B.

• Die Größe der Matrizen wird mindestens sein 1-by-1. Die maximale Größe ist die Größe, die Ihr Computer / Ihre Sprache standardmäßig verarbeiten kann, jedoch die minimale 5-by-5Eingabe.
• Alle Eingabewerte sind nicht negative Ganzzahlen
• Eingebaute Funktionen zur Berechnung von Kronecker-Produkten oder Tensor / Outer- Produkten sind nicht zulässig
• Im Allgemeinen: Standardregeln für E / A-Format, Programm und Funktionen, Lücken usw.

Testfälle:

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

Gelee, 10 9 Bytes

×€€;"/€;/

Verwendet den Büttner-Algorithmus ( üausgesprochen, wenn versucht wird, einen eeSound [wie beim Treffen] in der Mundform eines ooSounds [wie beim Booten] zu erzeugen).

Das ;"/€;/ist inspiriert von Dennis Mitchell . Es war ursprünglich Z€F€€;/(was ein weiteres Byte kostet).

• Testfall 1
• Testfall 2
• Testfall 3
• Testfall 4

CJam, 13 Bytes

{ffff*::.+:~}

Dies ist ein unbenannter Block, der zwei Matrizen oben auf dem Stapel erwartet und das Kronecker-Produkt an seiner Stelle belässt.

Testsuite.

Erläuterung

Dies ist nur der Kronecker-Produktteil aus der vorherigen Antwort , daher reproduziere ich hier nur die relevanten Teile der vorherigen Erklärung:

Hier ist eine kurze Übersicht über die Infix-Operatoren von CJam für die Listenmanipulation:

• ferwartet eine Liste und etwas anderes auf dem Stapel und ordnet den folgenden binären Operator der Liste zu, wobei das andere Element als zweites Argument übergeben wird. ZB [1 2 3] 2 f*und 2 [1 2 3] f*beide geben [2 4 6]. Wenn beide Elemente Listen sind, wird das erste zugeordnet und das zweite zum Curryen des Binäroperators verwendet.
• :hat zwei Verwendungszwecke: Wenn der Operator, der ihm folgt, unär ist, ist dies eine einfache Karte. ZB [1 0 -1 4 -3] :zist [1 0 1 4 3], wo zbekommt der Modul einer Zahl. Wenn die Bediener es folgenden binär sind, wird dies klappt die Bediener statt. ZB [1 2 3 4] :+ist 10.
• .vektorisiert einen binären Operator. Es erwartet zwei Listen als Argumente und wendet den Operator auf entsprechende Paare an. ZB [1 2 3] [5 7 11] .*gibt [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 / Oktave, 83 42 Bytes

Gespeichert 41 Bytes, dank FryAmTheEggman!

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

Testen Sie es hier!

Nervenzusammenbruch

arrayfunist eine getarnte for-Schleife, die sich n*Bfür eine ndurch das zweite Argument definierte Variable multipliziert . Dies funktioniert, weil das Durchlaufen einer 2D-Matrix mit dem Durchlaufen eines Vektors identisch ist. Dh for x = Aist das gleiche wie for x = A(:).

'un',0entspricht dem ausführlicheren 'UniformOutput', Falseund gibt an, dass die Ausgabe Zellen anstelle von Skalaren enthält.

cell2mat wird verwendet, um die Zellen zurück in eine numerische Matrix zu konvertieren, die dann ausgegeben wird.

Pyth, 14 12 11 Bytes

JEsMs*RRRRJ

Übersetzung der Jelly-Antwort , die auf dem Büttner-Algorithmus basiert ( üausgesprochen, wenn versucht wird, einen eeTon [wie im Meet] in der Mundform eines ooSounds [wie im Boot] zu erzeugen).

Probieren Sie es online aus (Testfall 1)!

Bonus: Berechnen Sie B⊗Ain der gleichen Anzahl von Bytes

JEsMs*LRLRJ

Probieren Sie es online aus (Testfall 1)!

Julia, 40 39 37 Bytes

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

Probieren Sie es online aus!

Wie es funktioniert

• Für Matrizen A und B , map(a->a*B,A')berechnet das Kronecker - Produkt A⊗B .

  Das Ergebnis ist ein Vektor von Matrixblöcken mit den Abmessungen B .

  Wir müssen A (mit ') transponieren, da Matrizen in Spalten-Hauptreihenfolge gespeichert sind.

• sum(A^0)berechnet die Summe aller Einträge der Identitätsmatrix der Dimensionen von A. Für eine n × n- Matrix A ergibt dies n .

• Mit dem ersten Argument n werden n Matrixblöcke horizontal und die resultierenden (größeren) Blöcke vertikal hvcatverkettet .

J, 10 Bytes

Dies ist eine mögliche Implementierung.

[:,./^:2*/

J, 13 Bytes

Dies ist eine ähnliche Implementierung, verwendet jedoch die Fähigkeit von J, Ränge zu definieren. Es gilt *zwischen jedem Element auf der linken Seite mit der gesamten rechten Seite.

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

Verwendung

   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

Einfache Implementierung mit verschachtelter Schleife

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

Prüfung

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>