相关，但有很大的不同。

在下面的例子中，A和B将是2×2矩阵，和矩阵是一个索引。

一个克罗内克产品具有以下特性：

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)

挑战：给定两个矩阵，A并且B，return A⊗B。

• 矩阵的大小至少为1-by-1。默认情况下，最大大小将是您的计算机/语言可以处理的大小，但最小5-by-5输入。
• 所有输入值均为非负整数
• 不允许使用用于计算Kronecker产品或Tensor / Outer产品的内置函数
• 一般而言：有关I / O格式，程序和功能，漏洞等的标准规则。

测试用例：

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

果冻，10 9个字节

×€€;"/€;/

使用布特纳算法（ü当试图以ee声音的嘴形oo[如靴子] 发出声音[如遇见] 时发音）。

该;"/€;/被激发丹尼斯·米切尔。它最初是Z€F€€;/（花费一个字节）。

• 测试用例1
• 测试用例2
• 测试用例3
• 测试案例4

CJam，13个字节

{ffff*::.+:~}

这是一个未命名的块，期望在堆栈顶部放置两个矩阵，并将其Kronecker产品留在原处。

测试套件。

说明

这只是先前答案中的Kronecker产品部分，因此，我在这里仅重现先前解释的相关部分：

这是CJam的用于列表操作的中缀运算符的快速概述：

• f需要一个列表以及堆栈上的其他内容，然后将以下二进制运算符映射到该列表上，并传入另一个元素作为第二个参数。例如[1 2 3] 2 f*，2 [1 2 3] f*都给[2 4 6]。如果两个元素都是列表，则第一个元素将被映射，第二个元素将用于处理二进制运算符。
• :有两个用途：如果跟随它的运算符是一元的，则这是一个简单的映射。例如，[1 0 -1 4 -3] :z是[1 0 1 4 3]，其中z获得数字的模数。如果跟在它后面的运算符是二进制的，则它将折叠运算符。例如[1 2 3 4] :+是10。
• .向量化二进制运算符。它期望两个列表作为参数，并将运算符应用于相应的对。例如[1 2 3] [5 7 11] .*给[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 /八度，83 42字节

由于FryAmTheEggman，节省了41个字节！

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

在这里测试！

分解

arrayfun是对第二个参数定义n*B的变量乘以的伪装的for循环n。之所以可行，是因为循环通过2D矩阵与循环通过向量相同。即for x = A与相同for x = A(:)。

'un',0等价于更加冗长'UniformOutput', False，并指定输出包含单元格而不是标量。

cell2mat 用于将单元格转换回数字矩阵，然后将其输出。

Pyth，14 12 11字节

JEsMs*RRRRJ

Jelly Answer的翻译，它基于Büttner算法（ü尝试以ee声音的嘴形oo（如靴子）发声时发音）。

在线尝试（测试案例1）！

奖励：B⊗A以相同的字节数计算

JEsMs*LRLRJ

在线尝试（测试案例1）！

朱莉娅40 39 37字节

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

在线尝试！

这个怎么运作

• 对于矩阵A和B，map(a->a*B,A')计算Kronecker积A⊗B。

  结果是尺寸为B的矩阵块的向量。

  由于矩阵以列优先顺序存储，因此我们必须转置A（带有'）。

• sum(A^0)计算A维度的单位矩阵的所有条目的总和。对于n×n的矩阵A，得出n。

• 使用第一个参数n，水平地hvcat连接n个矩阵块，而垂直地连接结果（较大）的块。

J，10个字节

这是一种可能的实现。

[:,./^:2*/

J，13个字节

这是一个类似的实现，但是使用J的能力来定义等级。它适用*于LHS上的每个元素与整个RHS。

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

用法

   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

嵌套循环的简单实现

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

测试

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>