# Program to multiply two matrices

Given two matrices, the task is to multiply them. Matrices can either be square or rectangular:

Examples:

(Square Matrix Multiplication)

Input: mat1[m][n] = { {1, 1}, {2, 2} }
mat2[n][p] = { {1, 1}, {2, 2} }
Output: result[m][p] = { {3, 3}, {6, 6} }

(Rectangular Matrix Multiplication)

Input: mat1[3][2] = { {1, 1}, {2, 2}, {3, 3} }
mat2[2][3] = { {1, 1, 1}, {2, 2, 2} }
Output: result[3][3] = { {3, 3, 3}, {6, 6, 6}, {9, 9, 9} }

Recommended Practice

## Multiplication of two Square or Rectangular Matrices:

• The number of columns in Matrix-1 must be equal to the number of rows in Matrix-2.
• Output of multiplication of Matrix-1 and Matrix-2, results with equal to the number of rows of Matrix-1 and  the number of columns of Matrix-2 i.e. rslt[R1][C2]

Below is the implementation of the multiplication of two matrices:

## C

 `// C program to multiply two matrices ` ` `  `#include ` `#include ` ` `  `// Edit MACROs here, according to your Matrix Dimensions for ` `// mat1[R1][C1] and mat2[R2][C2] ` `#define R1 2 // number of rows in Matrix-1 ` `#define C1 2 // number of columns in Matrix-1 ` `#define R2 2 // number of rows in Matrix-2 ` `#define C2 2 // number of columns in Matrix-2 ` ` `  `void` `mulMat(``int` `mat1[][C1], ``int` `mat2[][C2]) ` `{ ` `    ``int` `rslt[R1][C2]; ` ` `  `    ``printf``(``"Multiplication of given two matrices is:\n"``); ` ` `  `    ``for` `(``int` `i = 0; i < R1; i++) { ` `        ``for` `(``int` `j = 0; j < C2; j++) { ` `            ``rslt[i][j] = 0; ` ` `  `            ``for` `(``int` `k = 0; k < R2; k++) { ` `                ``rslt[i][j] += mat1[i][k] * mat2[k][j]; ` `            ``} ` ` `  `            ``printf``(``"%d\t"``, rslt[i][j]); ` `        ``} ` ` `  `        ``printf``(``"\n"``); ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// R1 = 4, C1 = 4 and R2 = 4, C2 = 4 (Update these ` `    ``// values in MACROs) ` `    ``int` `mat1[R1][C1] = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  `    ``int` `mat2[R2][C2] = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  ` `  `    ``if` `(C1 != R2) { ` `        ``printf``(``"The number of columns in Matrix-1  must be "` `               ``"equal to the number of rows in "` `               ``"Matrix-2\n"``); ` `        ``printf``(``"Please update MACROs value according to "` `               ``"your array dimension in "` `               ``"#define section\n"``); ` ` `  `        ``exit``(EXIT_FAILURE); ` `    ``} ` ` `  `      ``// Function call ` `    ``mulMat(mat1, mat2); ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by Manish Kumar (mkumar2789)`

## C++

 `// C++ program to multiply two matrices ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Edit MACROs here, according to your Matrix Dimensions for ` `// mat1[R1][C1] and mat2[R2][C2] ` `#define R1 2 // number of rows in Matrix-1 ` `#define C1 2 // number of columns in Matrix-1 ` `#define R2 2 // number of rows in Matrix-2 ` `#define C2 2 // number of columns in Matrix-2 ` ` `  `void` `mulMat(``int` `mat1[][C1], ``int` `mat2[][C2]) ` `{ ` `    ``int` `rslt[R1][C2]; ` ` `  `    ``cout << ``"Multiplication of given two matrices is:\n"``; ` ` `  `    ``for` `(``int` `i = 0; i < R1; i++) { ` `        ``for` `(``int` `j = 0; j < C2; j++) { ` `            ``rslt[i][j] = 0; ` ` `  `            ``for` `(``int` `k = 0; k < R2; k++) { ` `                ``rslt[i][j] += mat1[i][k] * mat2[k][j]; ` `            ``} ` ` `  `            ``cout << rslt[i][j] << ``"\t"``; ` `        ``} ` ` `  `        ``cout << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// R1 = 4, C1 = 4 and R2 = 4, C2 = 4 (Update these ` `    ``// values in MACROs) ` `    ``int` `mat1[R1][C1] = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  `    ``int` `mat2[R2][C2] = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  `    ``if` `(C1 != R2) { ` `        ``cout << ``"The number of columns in Matrix-1  must "` `                ``"be equal to the number of rows in "` `                ``"Matrix-2"` `             ``<< endl; ` `        ``cout << ``"Please update MACROs according to your "` `                ``"array dimension in #define section"` `             ``<< endl; ` ` `  `        ``exit``(EXIT_FAILURE); ` `    ``} ` ` `  `      ``// Function call ` `    ``mulMat(mat1, mat2); ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by Manish Kumar (mkumar2789)`

## Java

 `// C++ program to multiply two matrices ` ` `  `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `R1 = ``2``; ``// number of rows in Matrix-1 ` `    ``static` `int` `C1 = ``2``; ``// number of columns in Matrix-1 ` `    ``static` `int` `R2 = ``2``; ``// number of rows in Matrix-2 ` `    ``static` `int` `C2 = ``2``; ``// number of columns in Matrix-2 ` ` `  `    ``// This function multiplies mat1[][] ` `    ``// and mat2[][], and stores the result ` `    ``// in res[][] ` `    ``static` `void` `mulMat(``int``[][] mat1, ``int``[][] mat2) ` `    ``{ ` `        ``// To store result ` `        ``int``[][] rslt = ``new` `int``[R1][C2]; ` `        ``System.out.println( ` `            ``"Multiplication of given two matrices is:"``); ` `        ``int` `i, j, k; ` `        ``for` `(i = ``0``; i < R1; i++) { ` `            ``for` `(j = ``0``; j < C2; j++) { ` `                ``rslt[i][j] = ``0``; ` `                ``for` `(k = ``0``; k < R2; k++) ` `                    ``rslt[i][j] += mat1[i][k] * mat2[k][j]; ` `                ``System.out.print(rslt[i][j] + ``" "``); ` `            ``} ` `            ``System.out.println(``""``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] mat1 = { { ``1``, ``1` `}, ` `                         ``{ ``2``, ``2` `} }; ` ` `  `        ``int``[][] mat2 = { { ``1``, ``1` `}, ` `                         ``{ ``2``, ``2` `} }; ` ` `  ` `  `        ``if` `(C1 != R2) { ` `            ``System.out.println( ` `                ``"The number of columns in Matrix-1  must be equal to the number of rows in Matrix-2"``); ` `            ``System.out.println( ` `                ``"Please update the global variables according to your array dimension"``); ` `        ``} ` `        ``else` `{ ` `           `  `              ``// Function call ` `            ``mulMat(mat1, mat2); ` `        ``} ` `    ``} ` `} ` `// This code is contributed by shruti456rawal`

## Python3

 `# Python3 program to multiply two matrices ` ` `  ` `  `def` `mulMat(mat1, mat2, R1, R2, C1, C2): ` `    ``# List to store matrix multiplication result ` `    ``rslt ``=` `[[``0``, ``0``, ``0``, ``0``], ` `            ``[``0``, ``0``, ``0``, ``0``], ` `            ``[``0``, ``0``, ``0``, ``0``], ` `            ``[``0``, ``0``, ``0``, ``0``]] ` ` `  `    ``for` `i ``in` `range``(``0``, R1): ` `        ``for` `j ``in` `range``(``0``, C2): ` `            ``for` `k ``in` `range``(``0``, R2): ` `                ``rslt[i][j] ``+``=` `mat1[i][k] ``*` `mat2[k][j] ` ` `  `    ``print``(``"Multiplication of given two matrices is:"``) ` `    ``for` `i ``in` `range``(``0``, R1): ` `        ``for` `j ``in` `range``(``0``, C2): ` `            ``print``(rslt[i][j], end``=``" "``) ` `        ``print``(``"\n"``, end``=``"") ` ` `  ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``R1 ``=` `2` `    ``R2 ``=` `2` `    ``C1 ``=` `2` `    ``C2 ``=` `2` `     `  `    ``# First matrix. M is a list ` `    ``mat1 ``=` `[[``1``, ``1``], ` `           ``[``2``, ``2``]] ` `     `  `   `  `    ``# Second matrix. N is a list ` `    ``mat2 ``=` `[[``1``, ``1``], ` `           ``[``2``, ``2``]] ` ` `  `    ``if` `C1 !``=` `R2: ` `        ``print``(``"The number of columns in Matrix-1  must be equal to the number of rows in "` `+` `"Matrix-2"``, end``=``'') ` `        ``print``(``"\n"``, end``=``'') ` `        ``print``(``"Please update MACROs according to your array dimension in #define section"``, end``=``'') ` `        ``print``(``"\n"``, end``=``'') ` `    ``else``: ` `        ``# Call matrix_multiplication function ` `        ``mulMat(mat1, mat2, R1, R2, C1, C2) ` ` `  `# This code is contributed by Aarti_Rathi `

## C#

 `// C# program to multiply two matrices ` ` `  `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `R1 = 2; ``// number of rows in Matrix-1 ` `    ``static` `int` `C1 = 2; ``// number of columns in Matrix-1 ` `    ``static` `int` `R2 = 2; ``// number of rows in Matrix-2 ` `    ``static` `int` `C2 = 2; ``// number of columns in Matrix-2 ` ` `  `    ``// This function multiplies mat1[][] ` `    ``// and mat2[][], and stores the result ` `    ``// in res[][] ` `    ``static` `void` `mulMat(``int``[, ] mat1, ``int``[, ] mat2) ` `    ``{ ` `        ``// To store result ` `        ``int``[, ] rslt = ``new` `int``[R1, C2]; ` `        ``Console.WriteLine( ` `            ``"Multiplication of given two matrices is:"``); ` `        ``int` `i, j, k; ` `        ``for` `(i = 0; i < R1; i++) { ` `            ``for` `(j = 0; j < C2; j++) { ` `                ``rslt[i, j] = 0; ` `                ``for` `(k = 0; k < R2; k++) ` `                    ``rslt[i, j] += mat1[i, k] * mat2[k, j]; ` `                ``Console.Write(rslt[i, j] + ``"\t"``); ` `            ``} ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[, ] mat1 = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  `        ``int``[, ] mat2 = { { 1, 1 }, ` `                         ``{ 2, 2 } }; ` ` `  `        ``if` `(C1 != R2) { ` `            ``Console.WriteLine( ` `                ``"The number of columns in Matrix-1  must be equal to the number of rows in Matrix-2"``); ` `            ``Console.WriteLine( ` `                ``"Please update MACROs according to your array dimension in #define section"``); ` `        ``} ` `        ``else` `{ ` `            ``mulMat(mat1, mat2); ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Aarti_Rathi`

## Javascript

 `var` `R1 = 2; ` `// number of rows in Matrix-1 ` `var` `C1 = 2; ` `// number of columns in Matrix-1 ` `var` `R2 = 2; ` `// number of rows in Matrix-2 ` `var` `C2 = 2; ` `// number of columns in Matrix-2 ` `// This function multiplies mat1[][] ` `// and mat2[][], and stores the result ` `// in res[][] ` `function` `mulMat(mat1, mat2) ` `{ ` `    ``// To store result ` `    ``var` `rslt = Array(R1).fill(0).map(()=>``new` `Array(C2).fill(0)); ` `    ``console.log(``"Multiplication of given two matrices is:"``); ` `    ``var` `i = 0; ` `    ``var` `j = 0; ` `    ``var` `k = 0; ` `    ``for` `(i = 0; i < R1; i++) ` `    ``{ ` `        ``for` `(j = 0; j < C2; j++) ` `        ``{ ` `            ``rslt[i][j] = 0; ` `            ``for` `(k = 0; k < R2; k++) ` `            ``{ ` `                ``rslt[i][j] += mat1[i][k] * mat2[k][j]; ` `            ``} ` `            ``console.log(rslt[i][j] + ``" "``); ` `        ``} ` `        ``console.log(``""``); ` `    ``} ` `} ` `// Driver program ` ` `  `var` `mat1 = [[1, 1], [2, 2]]; ` `var` `mat2 = [[1, 1], [2, 2]]; ` ` `  `if` `(C1 != R2) ` `{ ` `    ``console.log(``"The number of columns in Matrix-1 must be equal to the number of rows in Matrix-2"``); ` `    ``console.log(``"Please update the global variables according to your array dimension"``); ` `} ` `else`  `{ ` `    ``mulMat(mat1, mat2); ` `} ` ` `  `// This code is contributed by Aarti_Rathi`

Output

```Multiplication of given two matrices is:
3    3
6    6    ```

Time complexity: O(R1 * C2 * R2) for given matrices mat1[R1][C1] and mat2[R2][C2]
Auxiliary space: O(R1 * C2)

## Multiplication of Rectangular Matrices using Pointers in C/C++:

To solve the problem follow the below idea:

We use pointers in C/C++ to multiply matrices

Prerequisite:  How to pass a 2D array as a parameter in C?

Below is the implementation of the above approach:

## C++

 `// C++ program to multiply two ` `// rectangular matrices ` `#include ` `using` `namespace` `std; ` ` `  `// Multiplies two matrices mat1[][] ` `// and mat2[][] and prints result. ` `// (m1) x (m2) and (n1) x (n2) are ` `// dimensions of given matrices. ` `void` `multiply(``int` `m1, ``int` `m2, ``int` `mat1[][2], ``int` `n1, ``int` `n2, ` `              ``int` `mat2[][2]) ` `{ ` `    ``int` `x, i, j; ` `    ``int` `res[m1][n2]; ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``res[i][j] = 0; ` `            ``for` `(x = 0; x < m2; x++) { ` `                ``*(*(res + i) + j) += *(*(mat1 + i) + x) ` `                                     ``* *(*(mat2 + x) + j); ` `            ``} ` `        ``} ` `    ``} ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``cout << *(*(res + i) + j) << ``" "``; ` `        ``} ` `        ``cout << ``"\n"``; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `mat1[][2] = { { 1, 1 }, { 2, 2 } }; ` `    ``int` `mat2[][2] = { { 1, 1 }, { 2, 2 } }; ` `    ``int` `m1 = 2, m2 = 2, n1 = 2, n2 = 2; ` ` `  `    ``// Function call ` `    ``multiply(m1, m2, mat1, n1, n2, mat2); ` `    ``return` `0; ` `} ` ` `  `// This code is contributed ` `// by Akanksha Rai(Abby_akku)`

## C

 `// C program to multiply two rectangular matrices ` `#include ` ` `  `// Multiplies two matrices mat1[][] and mat2[][] ` `// and prints result. ` `// (m1) x (m2) and (n1) x (n2) are dimensions ` `// of given matrices. ` `void` `multiply(``int` `m1, ``int` `m2, ``int` `mat1[][m2], ``int` `n1, ` `              ``int` `n2, ``int` `mat2[][n2]) ` `{ ` `    ``int` `x, i, j; ` `    ``int` `res[m1][n2]; ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``res[i][j] = 0; ` `            ``for` `(x = 0; x < m2; x++) { ` `                ``*(*(res + i) + j) += *(*(mat1 + i) + x) ` `                                     ``* *(*(mat2 + x) + j); ` `            ``} ` `        ``} ` `    ``} ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``printf``(``"%d "``, *(*(res + i) + j)); ` `        ``} ` `        ``printf``(``"\n"``); ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `mat1[][2] = { { 1, 1 }, { 2, 2 } }; ` `    ``int` `mat2[][2] = { { 1, 1 }, { 2, 2 } }; ` `    ``int` `m1 = 2, m2 = 2, n1 = 2, n2 = 2; ` ` `  `    ``// Function call ` `    ``multiply(m1, m2, mat1, n1, n2, mat2); ` `    ``return` `0; ` `}`

## Java

 `// JAVA program to multiply two ` `// rectangular matrices ` `import` `java.io.*; ` `import` `java.lang.*; ` `import` `java.util.*; ` ` `  `// Multiplies two matrices mat1[][] ` `// and mat2[][] and prints result. ` `// (m1) x (m2) and (n1) x (n2) are ` `// dimensions of given matrices. ` `public` `class` `GFG { ` `  ``public` `static` `void` `multiply(``int` `m1, ``int` `m2, ` `                              ``int` `mat1[][], ``int` `n1, ` `                              ``int` `n2, ``int` `mat2[][]) ` `  ``{ ` `    ``int` `x, i, j; ` `    ``int` `res[][] = ``new` `int``[m1][n2]; ` `    ``for` `(i = ``0``; i < m1; i++) { ` `      ``for` `(j = ``0``; j < n2; j++) { ` `        ``res[i][j] = ``0``; ` `        ``for` `(x = ``0``; x < m2; x++) { ` `          ``res[i][j] += mat1[i][x] * mat2[x][j]; ` `        ``} ` `      ``} ` `    ``} ` `    ``for` `(i = ``0``; i < m1; i++) { ` `      ``for` `(j = ``0``; j < n2; j++) { ` `        ``System.out.print(res[i][j] + ``" "``); ` `      ``} ` `      ``System.out.println(); ` `    ``} ` `  ``} ` ` `  `  ``// Driver code ` `  ``public` `static` `void` `main(String[] args) ` `  ``{ ` `    ``int` `m1 = ``2``, m2 = ``2``, n1 = ``2``, n2 = ``2``; ` `    ``int` `mat1[][] = ``new` `int``[][] { { ``1``, ``1` `}, { ``2``, ``2` `} }; ` `    ``int` `mat2[][] = ``new` `int``[][] { { ``1``, ``1` `}, { ``2``, ``2` `} }; ` ` `  `    ``// Function call ` `    ``multiply(m1, m2, mat1, n1, n2, mat2); ` `  ``} ` `} ` ` `  `// This code is contributed by ishankhandelwals.`

## Python3

 `# Python program to multiply two ` `# rectangular matrices ` ` `  `# Multiplies two matrices mat1[][] ` `# and mat2[][] and prints result. ` `# (m1) x (m2) and (n1) x (n2) are ` `# dimensions of given matrices. ` `def` `multiply(m1, m2, mat1, n1, n2, mat2): ` `    ``res ``=` `[[``0` `for` `x ``in` `range``(n2)] ``for` `y ``in` `range``(m1)] ` `    ``for` `i ``in` `range``(m1): ` `        ``for` `j ``in` `range``(n2): ` `            ``res[i][j] ``=` `0` `            ``for` `x ``in` `range``(m2): ` `                ``res[i][j] ``+``=` `mat1[i][x] ``*` `mat2[x][j] ` `    ``for` `i ``in` `range``(m1): ` `        ``for` `j ``in` `range``(n2): ` `            ``print``(res[i][j], end``=``" "``) ` `        ``print``() ` ` `  `# Driver code ` `m1 ``=` `2` `m2 ``=` `2` `n1 ``=` `2` `n2 ``=` `2` `mat1 ``=` `[[``1``, ``1``], [``2``, ``2``]] ` `mat2 ``=` `[[``1``, ``1``], [``2``, ``2``]] ` ` `  `# Function call ` `multiply(m1, m2, mat1, n1, n2, mat2) ` ` `  `# This code is contributed by Tapesh(tapeshdua420) `

## C#

 `// C# program to multiply two ` `// rectangular matrices ` `using` `System; ` ` `  `class` `Program { ` `    ``// Driver code ` `    ``static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``int` `m1 = 2, m2 = 2, n1 = 2, n2 = 2; ` `        ``int``[, ] mat1 = ``new` `int``[, ] { { 1, 1 }, { 2, 2 } }; ` `        ``int``[, ] mat2 = ``new` `int``[, ] { { 1, 1 }, { 2, 2 } }; ` ` `  `        ``// Function call ` `        ``multiply(m1, m2, mat1, n1, n2, mat2); ` `    ``} ` ` `  `    ``// Multiplies two matrices mat1[][] ` `    ``// and mat2[][] and prints result. ` `    ``// (m1) x (m2) and (n1) x (n2) are ` `    ``// dimensions of given matrices. ` `    ``static` `void` `multiply(``int` `m1, ``int` `m2, ``int``[, ] mat1, ` `                         ``int` `n1, ``int` `n2, ``int``[, ] mat2) ` `    ``{ ` `        ``int` `x, i, j; ` `        ``int``[, ] res = ``new` `int``[m1, n2]; ` `        ``for` `(i = 0; i < m1; i++) { ` `            ``for` `(j = 0; j < n2; j++) { ` `                ``res[i, j] = 0; ` `                ``for` `(x = 0; x < m2; x++) { ` `                    ``res[i, j] += mat1[i, x] * mat2[x, j]; ` `                ``} ` `            ``} ` `        ``} ` `        ``for` `(i = 0; i < m1; i++) { ` `            ``for` `(j = 0; j < n2; j++) { ` `                ``Console.Write(res[i, j] + ``" "``); ` `            ``} ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Tapesh(tapeshdua420)`

## Javascript

 `// JS program to multiply two ` `// rectangular matrices ` `// Multiplies two matrices mat1[][] ` `// and mat2[][] and prints result. ` `// (m1) x (m2) and (n1) x (n2) are ` `// dimensions of given matrices. ` `function` `multiply(m1, m2, mat1, n1, n2, mat2) { ` `    ``let x, i, j; ` `    ``let res = [[0, 0], [0, 0]]; ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``// res[i][j] = 0; ` `            ``for` `(x = 0; x < m2; x++) { ` `                ``res[i][j] += (mat1[i][x] * mat2[x][j]) ` `            ``} ` `        ``} ` `    ``} ` `    ``for` `(i = 0; i < m1; i++) { ` `        ``for` `(j = 0; j < n2; j++) { ` `            ``console.log(res[i][j]); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `let mat1 = [[1, 1], [2, 2]]; ` `let mat2 = [[1, 1], [2, 2]]; ` `let m1 = 2, m2 = 2, n1 = 2, n2 = 2; ` ` `  `// Function call ` `multiply(m1, m2, mat1, n1, n2, mat2); ` ` `  `// This code is contributed by ishankhandelwals.`

Output

```3 3
6 6 ```

Time complexity: O(N3)
Auxiliary Space: O(M1 * N2)

Related Article: Strassenâ€™s Matrix Multiplication

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next