関連するが、非常に異なる。

以下の例ではA、Bは2行2列の行列になり、行列は1インデックスになります。

クロネッカー積は、次のプロパティがあります。

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)

課題：与えられた2つの行列AとBを返しA⊗Bます。

• 行列のサイズは少なくとも1-by-1です。最大サイズは、お使いのコンピューター/言語がデフォルトで処理できるものですが、最小5-by-5入力です。
• すべての入力値は非負の整数になります
• クロネッカー積またはテンソル / 外積を計算する組み込み関数は許可されていません
• 一般的に：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バイト

×€€;"/€;/

Büttnerのアルゴリズムを使用します（[一致するように] 音を[ブート時のように] 口の形üにしようとするときに発音します）。eeoo

;"/€;/触発されデニス・ミッチェル。元々Z€F€€;/（もう1バイトかかります）。

• テストケース1
• テストケース2
• テストケース3
• テストケース4

CJam、13バイト

{ffff*::.+:~}

これは、スタックの最上部に2つの行列が必要な名前のないブロックで、Kronecker製品をそのまま残します。

テストスイート。

説明

これは前の回答からのクロネッカー製品の一部です。したがって、ここでは、前の説明の関連部分を再現します。

リスト操作のためのCJamの挿入演算子の簡単な概要を次に示します。

• fリストとスタック上の何かを期待し、次のバイナリ演算子をリストにマップし、他の要素を2番目の引数として渡します。例えば[1 2 3] 2 f*、2 [1 2 3] f*両方が与える[2 4 6]。両方の要素がリストの場合、最初の要素がマッピングされ、2番目の要素がバイナリ演算子をカリー化するために使用されます。
• :次の2つの用途があります。後続の演算子が単項の場合、これは単純なマップです。例えば、[1 0 -1 4 -3] :zは[1 0 1 4 3]、z数値のモジュラスを取得します。それに続く演算子がバイナリの場合、これは代わりに演算子を折りたたみます。例えば[1 2 3 4] :+です10。
• .二項演算子をベクトル化します。引数として2つのリストを想定し、対応するペアに演算子を適用します。例えば、[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バイト

保存された41バイト、FryAmTheEggmanに感謝！

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

ここでテストしてください！

壊す

arrayfunは、2番目の引数で定義されn*Bた変数に対して、乗算する偽装forループですn。これは、2Dマトリックスをループすることはベクトルをループすることと同じであるため機能します。すなわちfor x = A、と同じfor x = A(:)です。

'un',0はmore verboseと同等'UniformOutput', Falseであり、出力にスカラーではなくセルが含まれることを指定します。

cell2mat セルを数値マトリックスに変換し、出力します。

Pyth、14 12 11バイト

JEsMs*RRRRJ

Büttnerのアルゴリズムに基づくJelly answerの翻訳（[meet]のように[boot]のように口の形で音を出そüうとすると発音されます）。eeoo

オンラインで試してみてください（テストケース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')クロネッカー積の演算A⊗Bを。

  結果は、次元Bの行列ブロックのベクトルです。

  行列は列優先の順序で格納されるため、Aを（で'）転置する必要があります。

• sum(A^0)Aの次元の単位行列のすべてのエントリの合計を計算します。以下のためのN×N行列A、この収率は、N。

• 最初の引数nを使用すると、n個の行列ブロックを水平方向にhvcat連結し、結果の（より大きい）ブロックを垂直方向に連結します。

J、10バイト

これは可能な実装の1つです。

[:,./^: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>