2 डी सरणी में प्रत्येक कॉलम के औसत मूल्य की गणना कैसे करें?

यह है कि आप प्रत्येक पंक्ति और स्तंभों के योग और औसत की गणना कैसे कर सकते हैं: नीचे दिया गया उदाहरण कोड एक ही विधि में योग और औसत को प्रिंट करेगा और किसी भी मूल्य को वापस नहीं करेगा। यदि आपको वास्तविक राशि और औसत वापस करने की आवश्यकता है तो आपको डबल [] वापस करने की आवश्यकता है जिसमें एक डबल के बजाय सभी रकम या औसत होंगे।

कोड

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

यदि आप एक 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()सरणियों के औसत की गणना करने के लिए उपयोग करते हैं।

1. आपको फ़ंक्शन के double[]बजाय लौटने की आवश्यकता है 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]