berechnen Sie den minimalen Wert für jede Spalte in 2D-Array

Question

Ich habe ein 2D-Array, Iam versucht, den Mindestwert für jede Spalte zu berechnen und das Ergebnis in das Ergebnis-Array.

Der folgende Code berechnet den Minimalwert für jede Zeile. Wie kann ich den Mindestwert für jede Spalte ermitteln?

 import java.util.*; 

     class Test20 { 

     public static void main (String [] args) { 


      int[][] array = {{6,3,9}, 
          {0,8,2}, 
          {3,7,5}}; 



      Test20 test = new Test20(); 

     System.out.print(Arrays.toString(test.mincol(array))); 
     } 

    public static int[] mincol (int[][] n) { 
    int[] result = new int[n.length]; 

    for (int i = 0; i < n.length; i++) { 

     int min = n[0][i]; 

     for (int j = 0; j < n[0].length; j++) { 

      if (n[j][i] < min) { 
       min = n[j][i]; 
      } 
     } 
     result[i] = min; 
    } 
    return result; 
    } 
    } 

Answer 1

Gerade die Schleife ändern Sie die folgende Art und Weise:

min = 0; 
for(int i=0;i<n.length;i++){ 
    for(int j=0;j<n[0].length;j++){ 
     if(n[j][i]<n[j][min]){ 
     min=j; 
} 
result[i]=n[min][i]; 
} 

Beachten Sie, dass Sie durch die Länge der ersten Dimension in Ihrem Array Ihr Ergebnis Array instanziiert aber später verwenden die n [] [] param Schleifen und greifen Sie auf die Länge der zweiten Dimension in Ihrer Schleife zu.

Wenn Ihr zwei Dim-Array beispielsweise 4x5 ist, verursacht dies ArrayOutOfBoundsExceptions.

Answer 2

Ihre for-Schleife sieht gut aus. Überprüfen Sie den folgenden Code Ich habe einige kleinere Probleme behoben.

Basierend auf Ihren Code ersetzen Klasse Code mit unter:

public class Test { 
public static void main(String[] args) { 
    int[][]array={{6,1,9}, {0,1,2}, {3,7,5}}; 
    int[] test; 

    test = minrow(array); 
    for(int i=0; i<test.length; i++){ 
     System.out.println(test[i]); 
    } 
} 
public static int[] minrow(int[][] n){ 

    int [] result = new int[n.length]; 
    int min; 

    for(int i=0;i<n.length;i++){ 
     min=0; 
     for(int j=0;j<n[i].length;j++){ 
      if(n[i][j]<n[i][min]){ 
       min=j; 
      } 
     } 
     result[i]=n[i][min]; 
    } 
    return result; 
} 
} 

Answer 3

Sie müssen nur das Gleiche tun, aber die Variablen

for(int i=0;i<n.length;i++){ 
    for(int j=0;j<n[0].length;j++){ 
     if(n[j][i]<n[min][j]){ 
      min=i; 
     } 
     result[j]=n[min][j]; 
    } 

} 

Answer 4

Umkehren Wenn Ihr Code ändern korrekt ist einfach:

if(n[i][j]<n[i][min]){ 
      min=j; 
} 

mit

if(n[i][j]<n[result[i]][j]){ 
      result[i]=i; 
} 

schließlich

for(int i=0;i<n.length;i++) result[i]=n[result[i][j]; 

Sie brauchen min nicht. Aber ändern

int [] result = new int[n.length]; 

zu

int [] result = new int[n[0].length]; 

Answer 5

Wie über Sie Ihre zweidimensionale Anordnung umsetzen wie:

 public static int[][] transpose (int[][] original) { 
     int[][] array = new int[original.length][]; 
     // transpose 
     if (original.length > 0) { 
      for (int i = 0; i < original[0].length; i++) { 
       array[i] = new int[original[i].length]; 
       for (int j = 0; j < original.length; j++) { 
        array[i][j] = original[j][i]; 
       } 
      } 
     } 
     return array; 
    } 

und nennen es dann als:

System.out.print(Arrays.toString(test.minrow(transpose(array)))); 

Oder, wenn Sie wollen ohne Transponieren gehen, das ist es wie geht das:

public static int[] mincol (int[][] n) { 
     int[] result = new int[n.length]; 
     for (int i = 0; i < n.length; i++) { 
      int min = n[0][i]; 
      for (int j = 0; j < n[0].length; j++) { 
       if (n[j][i] < min) { 
        min = n[j][i]; 
       } 
      } 
      result[i] = min; 
     } 
     return result; 
    }