Reemplace cada elemento de Matrix con su producto de fila excepto ese elemento

Dado un mat[][] de array 2D de orden M*N . La tarea es reemplazar cada elemento de cada fila con el producto de otros elementos de la misma fila.

Ejemplos: 

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

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

Enfoque: La idea es sencilla. Recorra la array por filas y encuentre el producto de cada fila. En el segundo recorrido, encuentre el valor de reemplazo para cada celda de la fila. Siga los pasos a continuación para resolver el problema:

• Inicialice las variables mul, i y j.
• Itere sobre el rango [0, M) usando la variable i y realice las siguientes tareas:
  • Establezca el valor de mul en 1.
  • Itere sobre el rango [0, N) usando la variable j y realice las siguientes tareas:
    • Establezca el valor de mul como mul*mat[i][j].
  • Itere sobre el rango [0, N) usando la variable j y realice las siguientes tareas:
    • Establezca el valor de mat[i][j] como mul/mat[i][j].
• Después de realizar los pasos anteriores, imprima los valores de mat[][] como respuesta.

A continuación se muestra la implementación del enfoque anterior.

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
const int M = 3, N = 3;
 
// Show Matrix.
void showMatrix(vector<vector<int> >& 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<vector<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.
int main()
{
    vector<vector<int> > mat = { { 3, 6, 2 },
                                 { 1, 4, 9 },
                                 { 5, 3, 8 } };
    ReplaceWithProduct(mat);
    return 0;
}

// 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 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# 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

<script>
      // JavaScript code for the above approach
 
      let M = 3, N = 3;
 
      // Show Matrix.
      function showMatrix(mat) {
          let i, j;
          for (i = 0; i < M; i++) {
              for (j = 0; j < N; j++) {
                  document.write(mat[i][j] + " ");
              }
              document.write('<br>')
          }
      }
 
      // Utility Function
      function ReplaceWithProduct(mat) {
          let 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.
 
      let mat = [[3, 6, 2],
      [1, 4, 9],
      [5, 3, 8]];
      ReplaceWithProduct(mat);
 
// This code is contributed by Potta Lokesh
  </script>

12 6 18 
36 9 4 
24 40 15

Complejidad temporal: O(N*N)
Espacio auxiliar: O(1)