metodo SommaMinori (esercizio su matrici)

[fefuccia]

salve mi trovo a dover affrontare questo esercizio :
Scrivere un metodo matriceSommeMinori che, data una matrice di valori interi, restituisce una nuova matrice in cui ogni elemento in posizione i,j è dato dalla somma di tutti gli elementi della matrice originaria, esclusi quelli facenti parte della riga i-esima e della colonna j-esima.
Ho provato a farlo ma non ci sono riuscita posto il codice che ho scritto :

public class SommeMinori
{
	public static int[][] matriciSommeMinori(int [][]mat)
	{
		int b[][]=new int[mat.length][mat[0].length];
		int somma=0;
	  for(int i=0;i<mat.length;i++)
	  {
		  for(int k=1;k<mat.length;k++)
		  {
			  for(int j=0;j<mat[0].length;j++)
			  {
				  for(int h=1;h<mat[0].length;h++)
			  
				  { 
					//  somma +=mat[k][h];
					  if(k==i | h==j)
					    mat[k][h]=0;
					  	somma+=mat[k][h];
					  	b[i][j]= somma   ;
		          }
		  
	           }
		  }
	  }
	  return b;
	}

}

[desa]

Prova così:

public class SommeMinori
{
  public static int[][] matriciSommeMinori(int [][]mat)
  {
    int b[][] = new int[mat.length][mat[0].length];
    
    for (int i = 0; i < b.length; i++)
    {
      for (int j = 0; j < b[0].length; j++)
      {
        int somma = 0;

        for (int k = 0; k < mat.length; k++)
        {
          for (int h = 0; h < mat[0].length; h++)
          {
            if (k != i && h != j)
            {
              somma += mat[k][h];
            }
          }
        }
        
        b[i][j] = somma;
      }
    }

    return b;
  }
}

Mi sembra che nella tua implementazione ci fosse qualche problema con i .length considerati nelle condizioni di uscita dei cicli.

Ti segnalo qualche criticità:
- nel tuo algoritmo, se ti trovi nella riga i-esima o nella colonna j-esima azzeri l'elemento i,j di "mat", successivamente aggiungendo di fatto 0 alla somma calcolata fino a quel momento. Non è mai buona pratica (se puoi evitarlo) andare a modificare i parametri che ricevi, visto che potrebbero servire ancora al chiamante;
- quando fai mat[0].length recuperi la lunghezza della PRIMA RIGA della matrice: ma Java ti permette di avere matrici con righe di lunghezza diversa, quindi potrebbe anche essere che le righe successive siano più lunghe o più corte (o anche null). Questo è solo un esercizio, ma tienilo sempre presente in futuro;
- l'algoritmo, così com'è, è particolarmente pesante in termini computazionali: ad ogni singolo elemento di "b" devi andare a rifare la somma di TUTTA la matrice "mat". Se la matrice è piccola non te ne accorgi, ma se fosse molto grande? (Ricordati che quando sviluppi un algoritmo devi sempre considerare che potrebbe essere utilizzato su molti più dati di quelli che usi per fare dei test "caserecci"). Una soluzione più efficiente potrebbe essere quella di calcolare una volta sola la somma e, per ogni elemento i,j , andare a inserire in "b" il valore:

b[i][j] = somma_matrice - somma_riga[i] - somma_colonna[j] + mat[i][j]

Attenzione al "+ mat[i][j]", non è facoltativo!