2D 배열에서 각 열의 평균 값을 계산하는 방법은 무엇입니까?

Question

2D 배열에서 열의 평균 값을 계산하려고하는데 코드를 알아낼 수 없습니다. 함수는 각 열의 평균 값을 반환해야합니다. 그리고 함수에서 결과를 인쇄 할 수 없습니다. 인쇄는 주 기능에 있어야합니다.

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;
}

Answer 1

이것은 각 행과 열의 합계와 평균을 계산하는 방법입니다. 아래 예제 코드는 동일한 방법으로 합계와 평균을 인쇄하고 값을 반환하지 않습니다. 실제 합계와 평균을 반환해야하는 경우 double 대신 모든 합계 또는 평균을 포함하는 double []을 반환해야합니다.

암호

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; 
        } 
    } 


}

산출

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

Answer 2

NxN행렬 을 가정하면 스트림으로 풀 수 있습니다.

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());

이상 읽기

 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());

행렬의 전치를 수행 한 다음 Arrays.stream(...).average().getAsDouble()배열의 평균을 계산하는 데 사용 합니다.

Answer 3

1. 함수에서 double[]대신 a를 반환해야 double합니다.
2. 숫자는 유형 double이므로의 유형은 sum이어야합니다 double.

모든 행의 길이가 같은 경우 :

1. 각 컬럼의 값을 추가 할 수 있기 때문에, 당신은 추가해야합니다 matrix[j][i](대신 matrix[i][j]에) sum따라 average[i]될 것입니다 sum / matrix.length.

데모:

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;
    }
}

산출:

[5.333333333333333, 9.0, 12.666666666666666]

행의 길이가 다른 경우 :

1. 먼저의 크기가 될 행의 최대 길이를 찾아야합니다 double[] average.
2. 마지막으로 2 단계 중첩 루프를 사용하여의 값을 계산합니다 average[]. 외부 루프는 최대 average.length행까지 실행되고 내부 루프는 최대 행 수까지 실행됩니다. 각 열을 처리하는 동안 카운터 (예 :)를 사용하여 int count에 추가되는 값의 수를 추적합니다 sum. 내부 루프의 끝에서 average[i] = sum / count.

데모:

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;
    }
}

산출:

[5.333333333333333, 9.0, 17.5, 25.0]