Comment calculer la valeur moyenne de chaque colonne dans un tableau 2D?
J'essaie de calculer la valeur moyenne des colonnes dans un tableau 2D, mais je ne peux pas comprendre le code. La fonction doit renvoyer la valeur moyenne de chaque colonne. Et je ne peux pas imprimer le résultat dans la fonction. L'impression doit être en fonction principale.
static double average_columns(double matrix[][]) {
int i, j, sum = 0, average=0;
for (i = 0; i < matrix.length; i++) {
for (j = 0; j < matrix[i].length; j++) {
sum=(int) (sum+matrix[i][j]);
}
average=sum/matrix[i].length;
sum=0;
}
return average;
}
Réponses
Voici comment vous pouvez calculer la somme et les moyennes de chaque ligne et colonne: L'exemple de code ci-dessous imprimera la somme et les moyennes dans la même méthode et ne retournera aucune valeur. Si vous avez besoin de renvoyer la somme réelle et la moyenne, vous devez renvoyer double [] qui contiendra toutes les sommes ou moyennes au lieu d'un double.
CODE
public class Test {
static int m = 3;
static int n = 3;
public static void main(String[] args) {
int i,j;
int [][]matrix = new int[m][n];
int x = 1; // x fills up the value of the matrix
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
matrix[i][j] = x++;
System.out.println("The matrix is : \n");
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println("\nPrinting the avg of each col ::");
average_columns(matrix);
System.out.println("\nPrinting the avg of each row ::");
average_rows(matrix);
System.out.println("\nPrinting the sum of each col ::");
sum_columns(matrix);
System.out.println("\nPrinting the sum of each row ::");
sum_rows(matrix);
}
public static void average_rows(int matrix[][]) {
int i, j;
double sum = 0, average = 0;
for (i = 0; i < matrix.length; i++) {
for (j = 0; j < matrix[i].length; j++) {
sum=sum+matrix[i][j];
}
average=sum/matrix[i].length;
System.out.println("Average of row " + (i+1) + " = " + average);
sum=0;
}
}
public static void average_columns(int matrix[][]) {
int i, j;
double sum = 0, average = 0;
for (i = 0; i < matrix.length; i++) {
for (j = 0; j < matrix[i].length; j++) {
sum=sum+matrix[j][i];
}
average=sum/matrix[i].length;
System.out.println("Average of column " + (i+1) + " = " + average);
sum=0;
}
}
public static void sum_columns(int matrix[][]) {
int i,j;
double sum = 0;
for (i = 0; i < matrix.length; ++i) {
for (j = 0; j < matrix.length; ++j) {
sum = sum + matrix[j][i];
}
System.out.println("Sum of column " + (i+1) + " = " + sum);
sum = 0;
}
}
public static void sum_rows(int matrix[][]) {
int i,j;
double sum = 0;
for (i = 0; i < matrix.length; ++i) {
for (j = 0; j < matrix.length; ++j) {
sum = sum + matrix[i][j];
}
System.out.println( "Sum of row " + (i+1) + " = " + sum);
sum = 0;
}
}
}
PRODUCTION
The matrix is :
1 2 3
4 5 6
7 8 9
Printing the avg of each col ::
Average of column 1 = 4.0
Average of column 2 = 5.0
Average of column 3 = 6.0
Printing the avg of each row ::
Average of row 1 = 2.0
Average of row 2 = 5.0
Average of row 3 = 8.0
Printing the sum of each col ::
Sum of column 1 = 12.0
Sum of column 2 = 15.0
Sum of column 3 = 18.0
Printing the sum of each row ::
Sum of row 1 = 6.0
Sum of row 2 = 15.0
Sum of row 3 = 24.0
Si vous supposez une NxN
matrice, vous pouvez résoudre avec des flux:
double[][] matrix = { { 1, 5, 15}, { 1, 2, 2}, { 25, 109, 150} };
List<Double> column_average = Arrays.stream(IntStream.range(0, matrix[0].length)
.mapToObj(c1 -> Arrays.stream(matrix).mapToDouble(doubles -> doubles[c1]).toArray())
.toArray(double[][]::new))
.map(i -> Arrays.stream(i).average().getAsDouble())
.collect(Collectors.toList());
ou plus lisible
double[][] matrix_transpose = IntStream.range(0, matrix[0].length)
.mapToObj(c -> Arrays.stream(matrix).mapToDouble(doubles -> doubles[c]).toArray())
.toArray(double[][]::new);
List<Double> column_average = Arrays.stream(matrix_transpose)
.map(col -> Arrays.stream(col).average().getAsDouble())
.collect(Collectors.toList());
Vous faites la transposition de la matrice et ensuite vous utilisez Arrays.stream(...).average().getAsDouble()
pour calculer les moyennes des tableaux.
- Vous devez renvoyer un
double[]
au lieu d'un àdouble
partir de la fonction. - Puisque les nombres sont de type
double
,, le type desum
devrait êtredouble
.
Si toutes les lignes sont de longueur égale:
- Puisque vous souhaitez ajouter les valeurs de chaque colonne, vous devez ajouter
matrix[j][i]
(au lieu dematrix[i][j]
) àsum
et leaverage[i]
sera en conséquencesum / matrix.length
.
Démo:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// Test
double[][] nums = { { 10, 15, 20 }, { 1, 2, 3 }, { 5, 10, 15 } };
System.out.println(Arrays.toString(averageColumns(nums)));
}
static double[] averageColumns(double matrix[][]) {
int i, j;
double[] average = new double[matrix.length];
for (i = 0; i < matrix.length; i++) {
double sum = 0;
for (j = 0; j < matrix[i].length; j++) {
sum += matrix[j][i];
}
average[i] = sum / matrix.length;
}
return average;
}
}
Production:
[5.333333333333333, 9.0, 12.666666666666666]
Si les lignes sont de longueur différente:
- Vous devez d'abord trouver le maximum de la longueur des lignes qui deviendra la taille du fichier
double[] average
. - Enfin, utilisez une boucle imbriquée à 2 niveaux pour calculer les valeurs de
average[]
. La boucle externe fonctionnera jusqu'àaverage.length
et la boucle interne atteindra le nombre de lignes. Lors du traitement de chaque colonne, utilisez un compteur (par exempleint count
) pour garder une trace du nombre de valeurs qui sont ajoutéessum
. A la fin de la boucle interne,average[i] = sum / count
.
Démo:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// Test
double[][] nums = { { 10, 15, 20 }, { 1, 2 }, { 5, 10, 15, 25 } };
System.out.println(Arrays.toString(averageColumns(nums)));
}
static double[] averageColumns(double matrix[][]) {
// Find the maximum of the length of rows
int max = matrix[0].length;
for (int i = 0; i < matrix.length; i++) {
if (matrix[i].length > max) {
max = matrix[i].length;
}
}
int i, j;
double[] average = new double[max];
for (i = 0; i < average.length; i++) {
double sum = 0;
int count = 0;
for (j = 0; j < matrix.length; j++) {
if (matrix[j].length - 1 >= i) {
sum += matrix[j][i];
count++;
}
}
average[i] = sum / count;
}
return average;
}
}
Production:
[5.333333333333333, 9.0, 17.5, 25.0]