관련 되어 있지만 매우 다릅니다.

아래의 예에서, A그리고 B2 바이 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반환 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 바이트

×€€;"/€;/

Büttner의 알고리즘을 사용합니다 ( 부팅에서와 같이 소리 의 입 모양에서 [만남에 따라] 소리 ü를 만들려고 할 때 발음됩니다 ).eeoo

는 ;"/€;/영감 데니스 미첼 . 원래 Z€F€€;/(1 바이트 더 필요).

• 테스트 사례 1
• 테스트 사례 2
• 테스트 사례 3
• 테스트 사례 4

CJam, 13 바이트

{ffff*::.+:~}

이것은 스택 위에 두 개의 매트릭스를 기대하고 크로네 커 제품을 그 자리에 남겨 두는 명명되지 않은 블록입니다.

테스트 스위트.

설명

이것은 이전 답변 의 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 바이트

저장된 41 바이트, FryAmTheEggman에 감사합니다!

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

여기에서 테스트하십시오!

고장

arrayfun는 두 번째 인수로 정의 된 n*B변수에 대해 곱하는 위장 된 for-loop입니다 n. 이것은 2D 행렬을 통한 반복이 벡터를 통한 반복과 동일하기 때문에 작동합니다. 즉와 for x = A같습니다 for x = A(:).

'un',0은 verbose와 동일 'UniformOutput', False하며 출력에 스칼라 대신 셀이 포함되도록 지정합니다.

cell2mat 셀을 다시 숫자 매트릭스로 변환하는 데 사용되며 출력됩니다.

Pyth, 14 12 11 바이트

JEsMs*RRRRJ

젤리의 번역은 Büttner의 알고리즘을 기반으로합니다 ( 부팅에서와 같이 소리 의 입 모양에서 소리 ü를 만들려고 할 때 발음 됨 ).eeoo

온라인으로 사용해보십시오 (테스트 사례 1)!

보너스 : B⊗A같은 바이트 수로 계산

JEsMs*LRLRJ

온라인으로 사용해보십시오 (테스트 사례 1)!

줄리아, 40 39 37 바이트

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

온라인으로 사용해보십시오!

작동 원리

• 행렬 들어 및 B , 크로네 커 제품 계산 A⊗B를 .map(a->a*B,A')

  결과는 B 차원의 행렬 블록으로 구성된 벡터입니다 .

  행렬은 열 주요 순서로 저장되므로 A (with ') 를 바꿉니다 .

• sum(A^0)A 의 항등식 행렬의 모든 항목의 합을 계산 합니다. 들면 N × 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

자바 스크립트 (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>