## Related Articles

• Write an Interview Experience
• Matrix Data Structure

# Kronecker Product of two matrices

• Difficulty Level : Easy
• Last Updated : 02 Dec, 2022

Given an m*n matrix A and a p*q matrix B, their Kronecker product C = A tensor B, also called their matrix direct product, is a (m*p) * (n*q) matrix.

```A tensor B =  |a11B   a12B|
|a21B   a22B|

= |a11b11   a11b12   a12b11  a12b12|
|a11b21   a11b22   a12b21  a12b22|
|a11b31   a11b32   a12b31  a12b32|
|a21b11   a21b12   a22b11  a22b12|
|a21b21   a21b22   a22b21  a22b22|
|a21b31   a21b32   a22b31  a22b32|```

Examples:

```1. The matrix direct(kronecker) product of the 2Ã—2 matrix A
and the 2Ã—2 matrix B is given by the 4Ã—4 matrix :

Input : A = 1 2    B = 0 5
3 4        6 7

Output : C = 0  5  0  10
6  7  12 14
0  15 0  20
18 21 24 28

2. The matrix direct(kronecker) product of the 2Ã—3 matrix A
and the 3Ã—2 matrix B is given by the 6Ã—6 matrix :

Input : A = 1 2    B = 0 5 2
3 4        6 7 3
1 0

Output : C = 0      5    2    0     10    4
6      7    3   12     14    6
0     15    6    0     20    8
18     21    9   24     28   12
0      5    2    0      0    0
6      7    3    0      0    0    ```
Recommended Practice

Below is the code to find the Kronecker Product of two matrices and stores it as matrix C :

## C++

 `// C++ code to find the Kronecker Product of two``// matrices and stores it as matrix C``#include ``using` `namespace` `std;` `// rowa and cola are no of rows and columns``// of matrix A``// rowb and colb are no of rows and columns``// of matrix B``const` `int` `cola = 2, rowa = 3, colb = 3, rowb = 2;` `// Function to computes the Kronecker Product``// of two matrices``void` `Kroneckerproduct(``int` `A[][cola], ``int` `B[][colb])``{` `    ``int` `C[rowa * rowb][cola * colb];` `    ``// i loops till rowa``    ``for` `(``int` `i = 0; i < rowa; i++) {` `        ``// k loops till rowb``        ``for` `(``int` `k = 0; k < cola; k++) {` `            ``// j loops till cola``            ``for` `(``int` `j = 0; j < rowb; j++) {` `                ``// l loops till colb``                ``for` `(``int` `l = 0; l < colb; l++) {` `                    ``// Each element of matrix A is``                    ``// multiplied by whole Matrix B``                    ``// resp and stored as Matrix C``                    ``C[i * rowb + k][j * colb + l]``                        ``= A[i][j] * B[k][l];``                ``}``            ``}``        ``}``    ``}` `    ``for` `(``int` `i = 0; i < rowa * rowb; i++) {``        ``for` `(``int` `j = 0; j < cola * colb; j++) {``            ``cout << C[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A[3][2] = { { 1, 2 }, { 3, 4 }, { 1, 0 } },``        ``B[2][3] = { { 0, 5, 2 }, { 6, 7, 3 } };` `    ``Kroneckerproduct(A, B);``    ``return` `0;``}` `// This code is contributed by shubhamsingh10`

## C

 `// C code to find the Kronecker Product of two``// matrices and stores it as matrix C``#include ` `// rowa and cola are no of rows and columns``// of matrix A``// rowb and colb are no of rows and columns``// of matrix B``const` `int` `cola = 2, rowa = 3, colb = 3, rowb = 2;` `// Function to computes the Kronecker Product``// of two matrices``void` `Kroneckerproduct(``int` `A[][cola], ``int` `B[][colb])``{` `    ``int` `C[rowa * rowb][cola * colb];` `    ``// i loops till rowa``    ``for` `(``int` `i = 0; i < rowa; i++) {` `        ``// k loops till rowb``        ``for` `(``int` `k = 0; k < cola; k++) {` `            ``// j loops till cola``            ``for` `(``int` `j = 0; j < rowb; j++) {` `                ``// l loops till colb``                ``for` `(``int` `l = 0; l < colb; l++) {` `                    ``// Each element of matrix A is``                    ``// multiplied by whole Matrix B``                    ``// resp and stored as Matrix C``                    ``C[i * rowb + k][j * colb + l]``                        ``= A[i][j] * B[k][l];``                ``}``            ``}``        ``}``    ``}``    ``for` `(``int` `i = 0; i < rowa * rowb; i++) {``        ``for` `(``int` `j = 0; j < cola * colb; j++) {``            ``printf``(``"%d "``, C[i][j]);``        ``}``        ``printf``(``"\n"``);``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A[3][2] = { { 1, 2 }, { 3, 4 }, { 1, 0 } },``        ``B[2][3] = { { 0, 5, 2 }, { 6, 7, 3 } };` `    ``Kroneckerproduct(A, B);``    ``return` `0;``}`

## Java

 `// Java code to find the Kronecker Product of``// two matrices and stores it as matrix C``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// rowa and cola are no of rows and columns``    ``// of matrix A``    ``// rowb and colb are no of rows and columns``    ``// of matrix B``    ``static` `int` `cola = ``2``, rowa = ``3``, colb = ``3``, rowb = ``2``;` `    ``// Function to computes the Kronecker Product``    ``// of two matrices``    ``static` `void` `Kroneckerproduct(``int` `A[][], ``int` `B[][])``    ``{` `        ``int``[][] C = ``new` `int``[rowa * rowb][cola * colb];` `        ``// i loops till rowa``        ``for` `(``int` `i = ``0``; i < rowa; i++) {` `            ``// k loops till rowb``            ``for` `(``int` `k = ``0``; k < cola; k++) {` `                ``// j loops till cola``                ``for` `(``int` `j = ``0``; j < rowb; j++) {` `                    ``// l loops till colb``                    ``for` `(``int` `l = ``0``; l < colb; l++) {` `                        ``// Each element of matrix A is``                        ``// multiplied by whole Matrix B``                        ``// resp and stored as Matrix C``                        ``C[i * rowb + k][j * colb + l]``                            ``= A[i][j] * B[k][l];``                    ``}``                ``}``            ``}``        ``}``        ``for` `(``int` `i = ``0``; i < rowa * rowb; i++) {``            ``for` `(``int` `j = ``0``; j < cola * colb; j++) {``                ``System.out.print(C[i][j] + ``" "``);``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[][] = { { ``1``, ``2` `}, { ``3``, ``4` `}, { ``1``, ``0` `} };` `        ``int` `B[][] = { { ``0``, ``5``, ``2` `}, { ``6``, ``7``, ``3` `} };` `        ``Kroneckerproduct(A, B);``    ``}``}` `// This code is contributed by Gitanjali.`

## Python3

 `# Python code to find the Kronecker Product of two``# matrices and stores it as matrix C` `# rowa and cola are no of rows and columns``# of matrix A``# rowb and colb are no of rows and columns``# of matrix B``cola ``=` `2``rowa ``=` `3``colb ``=` `3``rowb ``=` `2``;` `# Function to computes the Kronecker Product``# of two matrices``def` `Kroneckerproduct(A, B):` `    ``C ``=` `[[``0``] ``*` `(cola ``*` `colb)  ``for` `_ ``in` `range``(rowa ``*` `rowb) ]``    ` `    ``# i loops till rowa``    ``for` `i ``in` `range``(rowa):` `        ``# k loops till rowb``        ``for` `k ``in` `range``(cola):` `            ``# j loops till cola``            ``for` `j ``in` `range``(rowb):` `                ``# l loops till colb``                ``for` `l ``in` `range``(colb):` `                    ``# Each element of matrix A is``                    ``# multiplied by whole Matrix B``                    ``# resp and stored as Matrix C``                    ``C[i ``*` `rowb ``+` `k][j ``*` `colb ``+` `l]  ``=` `A[i][j] ``*` `B[k][l];``                ` `    ``for` `i ``in` `range``(rowa ``*` `rowb):``        ``print``(``*``C[i])``    ` `# Driver Code``A ``=` `[[ ``1``, ``2` `], [ ``3``, ``4` `], [ ``1``, ``0` `]];``B ``=` `[[ ``0``, ``5``, ``2` `], [ ``6``, ``7``, ``3` `]];` `Kroneckerproduct(A, B);` `# This code is contributed by phasing17`

## C#

 `// Include namespace system``using` `System;` `public` `class` `GFG``{``  ` `  ``// rowa and cola are no of rows and columns``  ``// of matrix A``  ``// rowb and colb are no of rows and columns``  ``// of matrix B``  ``public` `static` `int` `cola = 2;``  ``public` `static` `int` `rowa = 3;``  ``public` `static` `int` `colb = 3;``  ``public` `static` `int` `rowb = 2;``  ``// Function to computes the Kronecker Product``  ``// of two matrices``  ``public` `static` `void` `Kroneckerproduct(``int``[,] A, ``int``[,] B)``  ``{``    ``int``[,] C = ``new` `int``[GFG.rowa * GFG.rowb,GFG.cola * GFG.colb];``    ``// i loops till rowa``    ``for` `(``int` `i = 0; i < GFG.rowa; i++)``    ``{``      ``// k loops till rowb``      ``for` `(``int` `k = 0; k < GFG.cola; k++)``      ``{``        ``// j loops till cola``        ``for` `(``int` `j = 0; j < GFG.rowb; j++)``        ``{``          ``// l loops till colb``          ``for` `(``int` `l = 0; l < GFG.colb; l++)``          ``{``            ``// Each element of matrix A is``            ``// multiplied by whole Matrix B``            ``// resp and stored as Matrix C``            ``C[i * GFG.rowb + k,j * GFG.colb + l] = A[i,j] * B[k,l];``          ``}``        ``}``      ``}``    ``}``    ``for` `(``int` `i = 0; i < GFG.rowa * GFG.rowb; i++)``    ``{``      ``for` `(``int` `j = 0; j < GFG.cola * GFG.colb; j++)``      ``{``        ``Console.Write(C[i,j].ToString() + ``" "``);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``// Driver program``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[,] A = {{1, 2}, {3, 4}, {1, 0}};``    ``int``[,] B = {{0, 5, 2}, {6, 7, 3}};``    ``GFG.Kroneckerproduct(A, B);``  ``}``}` `// This code is contributed by aadityaburujwale.`

## Javascript

 `// JS code to find the Kronecker Product of two``// matrices and stores it as matrix C`  `// rowa and cola are no of rows and columns``// of matrix A``// rowb and colb are no of rows and columns``// of matrix B``let cola = 2, rowa = 3, colb = 3, rowb = 2;` `// Function to computes the Kronecker Product``// of two matrices``function` `Kroneckerproduct(A, B)``{` `    ``let C = ``new` `Array(rowa * rowb)``    ``for` `(``var` `i = 0; i < rowa * rowb; i++)``        ``C[i] = ``new` `Array(cola * colb)` `    ``// i loops till rowa``    ``for` `(let i = 0; i < rowa; i++) {` `        ``// k loops till rowb``        ``for` `(let k = 0; k < cola; k++) {` `            ``// j loops till cola``            ``for` `(let j = 0; j < rowb; j++) {` `                ``// l loops till colb``                ``for` `(let l = 0; l < colb; l++) {` `                    ``// Each element of matrix A is``                    ``// multiplied by whole Matrix B``                    ``// resp and stored as Matrix C``                    ``C[i * rowb + k][j * colb + l]``                        ``= A[i][j] * B[k][l];``                ``}``            ``}``        ``}``    ``}` `    ``for` `(let i = 0; i < rowa * rowb; i++) {``        ``for` `(let j = 0; j < cola * colb; j++) {``            ``process.stdout.write(C[i][j] + ``" "``);``        ``}``        ``console.log()``    ``}``}` `// Driver Code``let A = [[ 1, 2 ], [ 3, 4 ], [ 1, 0 ]];``let B = [[ 0, 5, 2 ], [ 6, 7, 3 ]];` `Kroneckerproduct(A, B);` `// This code is contributed by phasing17`

Output

```0 5 2 0 10 4
6 7 3 12 14 6
0 15 6 0 20 8
18 21 9 24 28 12
0 5 2 0 0 0
6 7 3 0 0 0 ```

Time Complexity: O(rowa * rowb * cola * colb)
Auxiliary Space: O((rowa * rowb) * (cola * colb))

My Personal Notes arrow_drop_up