İlgili , ama çok farklı.

Aşağıdaki örneklerde Ave B2'ye 2 matris olacak ve matrisler bir indekslenmiştir.

Bir Kronecker ürünü aşağıdaki özelliklere sahiptir:

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)

Zorluk: İki matris verilir Ave Bgeri döner A⊗B.

• Matrislerin boyutu en azından olacaktır 1-by-1. Maksimum boyut, bilgisayarınızın / dilinizin varsayılan olarak üstesinden gelebileceği her şey olacaktır, ancak minimum 5-by-5giriş olacaktır.
• Tüm giriş değerleri negatif olmayan tamsayılar olacaktır
• Kronecker ürünlerini veya Tensör / Dış ürünleri hesaplayan yerleşik işlevlere izin verilmez
• Genel olarak: I / O formatı, program ve fonksiyonlar, boşluklar vb. İle ilgili standart kurallar

Test senaryoları:

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

Jöle, 10 9 bayt

×€€;"/€;/

Büttner Algoritmasını kullanır ( übir eesesin ağız biçiminde oo[önyüklemede olduğu gibi ] bir ses çıkarmaya çalışırken telaffuz edilir ).

;"/€;/Esinlenmiştir Dennis Mitchell . Başlangıçta Z€F€€;/(bir bayt daha maliyeti).

• Test durumu 1
• Test durumu 2
• Test durumu 3
• Test durumu 4

CJam, 13 bayt

{ffff*::.+:~}

Bu, yığının üstünde iki matris bekleyen ve Kronecker ürünlerini yerinde bırakan isimsiz bir bloktur.

Test odası.

açıklama

Bu sadece önceki cevabın Kronecker ürün kısmı , bu yüzden burada sadece önceki açıklamanın ilgili kısımlarını yeniden üretiyorum:

İşte liste manipülasyonu için CJam'in infix operatörlerine hızlı bir genel bakış:

• fyığında bir liste ve başka bir şey bekler ve diğer ikili öğeyi ikinci bağımsız değişken olarak ileterek , aşağıdaki ikili işleci liste üzerinde eşler . Örneğin [1 2 3] 2 f*ve 2 [1 2 3] f*her ikisi de verir [2 4 6]. Her iki öğe de listeyse, birincisi eşlenir ve ikincisi ikili işleci köri yapmak için kullanılır.
• :iki kullanımı vardır: onu izleyen operatör tekli ise, bu basit bir harita. Örneğin [1 0 -1 4 -3] :zolan [1 0 1 4 3]yerlerde, zbir dizi modülünü alır. Bunu izleyen operatör ikili ise, bu olacaktır kat yerine operatörü. Ör [1 2 3 4] :+olduğunu 10.
• .ikili bir işleci vectorize eder. İki listeyi bağımsız değişken olarak bekler ve operatörü karşılık gelen çiftlere uygular. Örneğin [1 2 3] [5 7 11] .*verir [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 / Oktav, 83 42 Bayt

Kaydedilen 41 byte, FryAmTheEggman sayesinde!

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

Burada test edin!

Yıkmak

arrayfun, ikinci argüman tarafından tanımlanan n*Bbir değişken için çarpılan gizlenmiş bir döngüdür n. Bu, bir 2D matrisin içinden döngü yapmak bir vektörden döngü ile aynı olduğu için çalışır. Yani for x = Aile aynı for x = A(:).

'un',0, daha ayrıntılı olana eşdeğerdir 'UniformOutput', Falseve çıktının skaler yerine hücre içerdiğini belirtir.

cell2mat hücreleri daha sonra çıktısı alınacak olan sayısal bir matrise dönüştürmek için kullanılır.

Pyth, 14 12 11 bayt

JEsMs*RRRRJ

Çevrilmesi Jelly cevap dayanmaktadır Büttner takımından Algoritma ( übir yapmaya çalışırken telaffuz eebir ağız-şeklinde [buluştuğu olduğu gibi] sesi oo[çizme gibi] sesin).

Çevrimiçi deneyin (test örneği 1)!

Bonus: B⊗Aaynı sayıda bayt cinsinden hesaplayın

JEsMs*LRLRJ

Çevrimiçi deneyin (test örneği 1)!

Julia, 40 39 37 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

• Matrisler için A ve B , map(a->a*B,A')Kronecker ürün hesaplar A⊗B .

  Sonuç, B boyutlarına sahip bir matris blokları vektörüdür .

  Matrisleri kolon-ana düzeninde depolandığından A (ile ') devralmak zorundayız .

• sum(A^0)A'nın boyutlarının kimlik matrisinin tüm girdilerinin toplamını hesaplar . Bir n × n matrisi A için bu, n verir .

• İlk bağımsız değişken ile , n , hvcatbitiştirir n yatay matris blokları ve dikey olarak elde edilen (daha büyük) blok.

J, 10 bayt

Bu olası bir uygulamadır.

[:,./^:2*/

J, 13 bayt

Bu benzer bir uygulamadır, ancak bunun yerine J'nin sıralama tanımlama yeteneğini kullanır. Bu uygular *tüm RHS ile lhs her bir öğe arasındaki.

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

kullanım

   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

İç içe döngü ile kolay uygulama

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

Ölçek

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>