deux somme tableau à deux dimensions

Question

J'ai deux réseau de flotteurs dimensions comme ci-dessous

{0.2,0.0,0.3,0.0,0.0} 
{0.4,0.1,0.0,0.0,0.9} 
{0.0,0.0,0.0,0.3,0.6} 

Je veux obtenir la sortie suivante

{0.6,0.0,0.3,0.0,0.0} 
{0.6,0.1,0.0,0.0,1.5} 
{0.0,0.0,0.0,0.3,1.5} 

Si vous analysez, je résumerai non la valeur zéro de chaque colonne et mettre à jour toutes les valeurs non nulles avec cette valeur de somme. Par exemple, dans la première colonne I somme (0.2 + 0.4 = 0.4) et mis à jour les deux position de valeur avec 0.6. J'utilise Java, comment puis-je effectuer cela? C'est un exemple simple, en temps réel, j'ai vraiment de grands tableaux.

Answer 1

Cela fonctionne en supposant qu'ils sont tous de la même longueur. Les cas spéciaux sont l'exercice pour le lecteur.

class MatTest { 
    static void makeSums(float[][] floats) { 
     // we wouldn't be doing any operations on these inputs anyway, so return 
     if(floats == null || floats.length == 0 || floats.length == 1) return; 

     // check to make sure it's retangular 
     for(float[] arr : floats) { 
      if(arr.length != floats[0].length) { 
       throw new IllegalArgumentException("makeSums() requires rectangular array"); 
      } 
     } 

     for(int i = 0; i < floats[0].length; i++) { 
      // do each column 
      float sum = 0f; 
      for(int j = 0; j < floats.length; j++) { 
       sum += floats[j][i]; 
      } 
      for(int j = 0; j < floats.length; j++) { 
       if(floats[j][i] != 0) floats[j][i] = sum; 
      } 
     } 
    } 

    public static void main(String[] args) { 
     float[][] floats = new float[3][5]; 
     floats[0] = new float[] {0.2f,0.0f,0.3f,0.0f,0.0f}; 
     floats[1] = new float[] {0.4f,0.1f,0.0f,0.0f,0.9f}; 
     floats[2] = new float[] {0.0f,0.0f,0.0f,0.3f,0.6f}; 

     makeSums(floats); 

     for(int i = 0; i < floats.length; i++) { 
      for(int j = 0; j < floats[0].length; j++) { 
       System.out.print(floats[i][j]); 
       System.out.print(" "); 
      } 
      System.out.println(" "); 
     } 
    } 
} 

Et voici le résultat:

C:\Documents and Settings\glow\My Documents>javac MatTest.java 

C:\Documents and Settings\glow\My Documents>java MatTest 
0.6 0.0 0.3 0.0 0.0 
0.6 0.1 0.0 0.0 1.5 
0.0 0.0 0.0 0.3 1.5 

Answer 2

Appelons votre tableau d'entrée float[][] a et tableau de sortie parallèle b initialisé à tous les zéros.

float curSum = 0.0; 
first = true; 
for(int i = 0; i < a[0].length; i++) 
{ 
    for(int j = 0; j < a.length; j++) 
    { 
     if(a[i][j] != 0) 
     { 
      if (first) 
      { 
       for(int k = j; k < a.length; k++) 
        curSum += a[i][k]; 
       first = false; 
      } 
      b[i][j] = curSum; 
     } 
    } 
    curSum = 0.0; 
    first = true; 
} 

Il pourrait y avoir quelques subtilités que vous avez à changer, comme la comparaison des flotteurs et des choses, mais je pense que l'idée est tout ce qu'il ya

Je pense qu'il fonctionne en O (n * m) , et qui n'a pas l'air génial, mais j'ai essayé de garder les itérations aussi courtes que possible. Je ne vois pas de moyen plus rapide de le faire. Même s'il y en a trois pour les boucles, celle avec k ne s'exécutera qu'une seule fois pour chaque boucle j si asymptotiquement qu'elle n'augmente pas du tout la complexité.