Open In App

# Replace each Matrix element with its row product except that element

Given a 2D-array mat[][] of order M*N. The task is to replace every element of each row with the product of other elements of the same row.

Examples:

Input: mat[][] = {{3, 4, 1}, {6, 1, 7}, {2, 9, 8}}
Output:
4, 3, 12
7, 42, 6
72, 16, 18

Input: mat[][] = {{13, 4, 5}, {6, 11, 1}}
Output:
20, 65, 52
11, 6, 66

Approach: The idea is straightforward. Traverse the matrix row-wise and find the product of each row. In the second traversal find the replacement value for each cell of the row. Follow the steps below to solve the problem:

• Initialize the variables mul, i and j.
• Iterate over the range [0, M) using the variable i and perform the following tasks:
• Set the value of mul as 1.
• Iterate over the range [0, N) using the variable j and perform the following tasks:
• Set the value of mul as mul*mat[i][j].
• Iterate over the range [0, N) using the variable j and perform the following tasks:
• Set the value of mat[i][j] as mul/mat[i][j].
• After performing the above steps, print the values of mat[][] as the answer.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``const` `int` `M = 3, N = 3;` `// Show Matrix.``void` `showMatrix(vector >& mat)``{``    ``int` `i, j;``    ``for` `(i = 0; i < M; i++) {``        ``for` `(j = 0; j < N; j++) {``            ``cout << mat[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `// Utility Function``void` `ReplaceWithProduct(vector >& mat)``{``    ``int` `mul, i, j;``    ``for` `(i = 0; i < M; i++) {``        ``mul = 1;``        ``for` `(j = 0; j < N; j++)``            ``mul *= mat[i][j];``        ``for` `(j = 0; j < N; j++)``            ``mat[i][j] = mul / mat[i][j];``    ``}``    ``showMatrix(mat);``}` `// Utility Main function.``int` `main()``{``    ``vector > mat = { { 3, 6, 2 },``                                 ``{ 1, 4, 9 },``                                 ``{ 5, 3, 8 } };``    ``ReplaceWithProduct(mat);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `GFG``{``  ``static` `int` `M = ``3``, N = ``3``;` `  ``// Show Matrix.``  ``static` `void` `showMatrix(``int` `[][]mat)``  ``{``    ``int` `i, j;``    ``for` `(i = ``0``; i < M; i++) {``      ``for` `(j = ``0``; j < N; j++) {``        ``System.out.print(mat[i][j] + ``" "``);``      ``}``      ``System.out.println();``    ``}``  ``}` `  ``// Utility Function``  ``static` `void` `ReplaceWithProduct(``int` `[][]mat)``  ``{``    ``int` `mul, i, j;``    ``for` `(i = ``0``; i < M; i++) {``      ``mul = ``1``;``      ``for` `(j = ``0``; j < N; j++)``        ``mul *= mat[i][j];``      ``for` `(j = ``0``; j < N; j++)``        ``mat[i][j] = mul / mat[i][j];``    ``}``    ``showMatrix(mat);``  ``}` `  ``// Utility Main function.``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `[][]mat = { { ``3``, ``6``, ``2` `},``                   ``{ ``1``, ``4``, ``9` `},``                   ``{ ``5``, ``3``, ``8` `} };``    ``ReplaceWithProduct(mat);` `  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# python3 program for the above approach``M ``=` `3``N ``=` `3` `# Show Matrix.``def` `showMatrix(mat):` `    ``for` `i ``in` `range``(``0``, M):``        ``for` `j ``in` `range``(``0``, N):``            ``print``(mat[i][j], end``=``" "``)` `        ``print``()` `# Utility Function``def` `ReplaceWithProduct(mat):` `    ``for` `i ``in` `range``(``0``, M):``        ``mul ``=` `1``        ``for` `j ``in` `range``(``0``, N):``            ``mul ``*``=` `mat[i][j]``        ``for` `j ``in` `range``(``0``, N):``            ``mat[i][j] ``=` `mul ``/``/` `mat[i][j]` `    ``showMatrix(mat)` `# Utility Main function.``if` `__name__ ``=``=` `"__main__"``:` `    ``mat ``=` `[[``3``, ``6``, ``2``],``           ``[``1``, ``4``, ``9``],``           ``[``5``, ``3``, ``8``]]``    ``ReplaceWithProduct(mat)` `# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{``  ``static` `int` `M = 3, N = 3;` `  ``// Show Matrix.``  ``static` `void` `showMatrix(``int` `[,]mat)``  ``{``    ``int` `i, j;``    ``for` `(i = 0; i < M; i++) {``      ``for` `(j = 0; j < N; j++) {``        ``Console.Write(mat[i,j] + ``" "``);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``// Utility Function``  ``static` `void` `ReplaceWithProduct(``int` `[,]mat)``  ``{``    ``int` `mul, i, j;``    ``for` `(i = 0; i < M; i++) {``      ``mul = 1;``      ``for` `(j = 0; j < N; j++)``        ``mul *= mat[i,j];``      ``for` `(j = 0; j < N; j++)``        ``mat[i,j] = mul / mat[i,j];``    ``}``    ``showMatrix(mat);``  ``}` `  ``// Utility Main function.``  ``public` `static` `void` `Main(String []args)``  ``{``    ``int` `[,]mat = { { 3, 6, 2 },``                   ``{ 1, 4, 9 },``                   ``{ 5, 3, 8 } };``    ``ReplaceWithProduct(mat);` `  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```12 6 18
36 9 4
24 40 15```

Time Complexity: O(N*N)
Auxiliary Space: O(1)