0

我有这样的家庭作业问题:

以下数据代表地震的里氏震级数据。编写一个程序来计算和打印任何有效地震数据的平均值。

将 Richter 值存储在名为 quakeLevels 的双精度数组中。

不幸的是,众所周知,您的地震仪有时会产生不可靠的读数(例如本例中的值 10.1)。所以你决定扔掉最大和最小读数。

您的程序应该执行以下操作:

使用以下数据声明并初始化 quakeLevels 数组。 { 5.6, 6.2, 4.0, 5.5, 5.7, 6.1,7.4, 8.5, 5.5, 6.3, 6.4, 2.1, 6.9, 4.3, 3.1, 7.0, 10.1 }

确定数组中的最大值和最小值。计算数组内容的平均值,不包括最大值和最小值。打印数组中不包括最大值和最小值的值。打印平均值。

不能使用数学类,所以这就是为什么所有的东西都被写出来打印最大值和最小值。

到目前为止,这是我的代码:

 public class ARRAYminAndmax0RichterScale
    {
        public static void main(String [] args)
        {
            double [] quakeLevels = { 5.6, 6.2, 4.0, 5.5, 5.7, 6.1 ,7.4, 8.5, 5.5, 6.3, 6.4, 2.1, 6.9, 4.3, 3.1, 7.0, 10.1};    
            double [] quakeLevelsNormalized = new double [(quakeLevels.length - 2)];
            int i;

            int minIndex = 0;  // start with 0th element as min
            for ( i = 1; i < quakeLevels.length; i++) {                 
                if (quakeLevels[i] < quakeLevels[minIndex]) {
                    minIndex = i;                        
                }                    
            }
            System.out.print("Min: " + quakeLevels[minIndex] + "    ");

            int maxIndex = 0;  // start with 0th element as max
            for ( i = 1; i < quakeLevels.length; i++) {                 
                if (quakeLevels[i] > quakeLevels[maxIndex]) {
                    maxIndex = i;                        
                }                    
            }

            System.out.println("Max: " + quakeLevels[maxIndex]);                
           System.out.println("The Richter values, excluding the extrema, are as follows: ");   

            //make a new array excluding the max and min
            for ( i = 1; i < quakeLevels.length - 2; i++ ) {

                if(quakeLevels[i]!= minIndex && quakeLevels[i]!= maxIndex){
                    quakeLevelsNormalized[i] = quakeLevels[i];
                    System.out.printf("%6s\n", quakeLevelsNormalized[i] );
                }                    
            }

          //***THIS LOOP IS HERE TO HELP ME FIGURE OUT THE PROBLEM***
            for( i =0; i < quakeLevelsNormalized.length; i++){
                System.out.println("quakeLevelsNormalized["+i+"] = " + quakeLevelsNormalized[i]);
            }

            //find average of quakeLevelsNormalized
            double arrayTotal = 0;
            double average = 0;
            for (i = 0; i < quakeLevelsNormalized.length; i++) {

                arrayTotal = arrayTotal + quakeLevelsNormalized[ i ];

            }
            average = arrayTotal / quakeLevelsNormalized.length;

            //output

            System.out.println( quakeLevelsNormalized[i-1]);
            System.out.printf("%s%.1f\n","Average Quake Level = ", average);
        }

    }

我得到以下输出:

Min: 2.1    Max: 10.1

The Richter values, excluding the extrema, are as follows: 
   6.2
   4.0
   5.5
   5.7
   6.1
   7.4
   8.5
   5.5
   6.3
   6.4
   2.1
   6.9
   4.3
   3.1
quakeLevelsNormalized[0] = 0.0
quakeLevelsNormalized[1] = 6.2
quakeLevelsNormalized[2] = 4.0
quakeLevelsNormalized[3] = 5.5
quakeLevelsNormalized[4] = 5.7
quakeLevelsNormalized[5] = 6.1
quakeLevelsNormalized[6] = 7.4
quakeLevelsNormalized[7] = 8.5
quakeLevelsNormalized[8] = 5.5
quakeLevelsNormalized[9] = 6.3
quakeLevelsNormalized[10] = 6.4
quakeLevelsNormalized[11] = 2.1
quakeLevelsNormalized[12] = 6.9
quakeLevelsNormalized[13] = 4.3
quakeLevelsNormalized[14] = 3.1
3.1
Average Quake Level = 5.2

问题

所以这显然不是它应该的样子。为什么它最后会给我额外的 3.1?它只有 14 个元素,什么时候应该有 [18 减去两个极端]?我是一个初学者程序员 - 我非常感谢任何和所有的帮助!

4

7 回答 7

1

我认为你在比较时可能有错误。

if(quakeLevels[i]!= minIndex && quakeLevels[i]!= maxIndex)

在这一行中,您询问索引 i 处的 VALUE 是否与最小/最大索引相同。这不符合您的要求,您需要直接将 i 与 maxIndex 和 minIndex 进行比较。

于 2013-10-03T13:31:47.310 回答
1

我认为你甚至不需要quakeLevelsNormalized数组。这是我的解决方案,无论如何这个逻辑可以改进:

public class ARRAYminAndmax0RichterScale {
    public static void main(String[] args) {
        double[] quakeLevels = { 5.6, 6.2, 4.0, 5.5, 5.7, 6.1, 7.4, 8.5, 5.5,
                6.3, 6.4, 2.1, 6.9, 4.3, 3.1, 7.0, 10.1 };
        int i;
        int minIndex = 0; // start with 0th element as min
        for (i = 1; i < quakeLevels.length; i++) {
            if (quakeLevels[i] < quakeLevels[minIndex]) {
                minIndex = i;
            }
        }
        System.out.print("Min: " + quakeLevels[minIndex] + "    ");
        int maxIndex = 0; // start with 0th element as max
        for (i = 1; i < quakeLevels.length; i++) {
            if (quakeLevels[i] > quakeLevels[maxIndex]) {
                maxIndex = i;
            }
        }
        System.out.println("Max: " + quakeLevels[maxIndex]);
        System.out.println();
        System.out.println("The Richter values, excluding the extrema, are as follows: ");
        double arrayTotal = 0;
        // make a new array excluding the max and min
        for (i = 0; i < quakeLevels.length; i++) {
            if (i != minIndex && i != maxIndex) {
                System.out.printf("%6s\n", quakeLevels[i]);
                arrayTotal += quakeLevels[i];
            }
        }
        double average = arrayTotal / (quakeLevels.length - 2);
        // output
        System.out.printf("%s%.1f\n", "Average Quake Level = ", average);
    }

}

希望这会有所帮助。

于 2013-10-03T13:46:51.290 回答
1

一些可能的方法来帮助你:

    /**
     * Get the largest number in the array
     */
    public double getMax(double[] array) {
            double max = Double.MIN_VALUE;
            for (double n : array) {
                    if (n > max) max = n;
            }
            return max;
    }

    /**
     * Get the smallest number in the array
     */
    public double getMin(double[] array) {
            double min = Double.MAX_VALUE;
            for (double n : array) {
                    if (n < min) min = n;
            }
            return min;
    }

    /**
     * Remove the specified number from the array, return a new array with the number removed
     */
    public double[] removeFromArray(double[] array, double number) {
            int count = 0;
            for (double n : array) {
                    if (n==number) count++;
            }
            double[] result = new double[array.length - count];
            int index = 0;
            for (double n : array) {
                    if (n!=number) result[index++] = n;
            }
            return result;
    }

    /**
     * Work out the mean of all the numbers in an array
     */
    public double averageOfArray(double[] array) {
            double total = 0;
            for (double n : array) {
                    total += n;
            }
            return total / array.length;
    }
于 2013-10-03T13:33:44.573 回答
0

我猜你不允许使用 Collection 类型,对吧?

试着把问题分解成它的组成部分,然后一一解决。

1) 仅使用有效数据:您可以通过遍历数组并依次检查每个元素以查看它是 <=0 还是 >=10 来做到这一点。如果有效,则将其粘贴到另一个数组中,如果无效,则忽略它。

2)计算最大值和最小值:你已经完成了这个!存储下一位的索引

3)计算平均值:循环遍历将它们相加并打印出来的值,跳过从上面存储的最小值和最大值

在做下一个之前检查每个部分是否正常工作,这样您调试起来会更容易。

于 2013-10-03T13:30:05.523 回答
0
if(quakeLevels[i]!= minIndex && quakeLevels[i]!= maxIndex) {
           quakeLevelsNormalized[i] = quakeLevels[i];
           System.out.printf("%6s\n", quakeLevelsNormalized[i] );
}

您应该比较索引,而不是与 minIndex 和 maxIndex 关联的值。

另外,你为什么要迭代0...length-2,你应该迭代0.. length-1并检查索引是否不同于minIndexmaxIndex

这:arrayTotal = arrayTotal + quakeLevelsNormalized[ i ]可以简化为

arrayTotal += quakeLevelsNormalized[i] 

如果您可以将 ArrayList 用于规范化级别数据结构,那么您应该不必以这种方式关心索引。

你只会做:

if ((i != minIndex) && (i != maxIndex)) {
    normalized.add(quakeLevels[i])
 }
于 2013-10-03T13:30:40.447 回答
0

您可以改进代码的地方很少。要查找最小值和最大值,您可以使用 collections 方法:

int minIndex = quakeLevels.indexOf(Collections.min(quakeLevels));
int maxIndex = quakeLevels.indexOf(Collections.max(quakeLevels));

你的主要问题在下面一行。

**//make a new array excluding the max and min
            for ( i = 1; i < quakeLevels.length - 2; i++ )**

为什么是quakeLevels.length - 2,应该是quakeLevels.length。并且还验证 i = 1;i = 0;需要在 for 循环中使用。

并删除以下行

System.out.println( quakeLevelsNormalized[i-1]);
于 2013-10-03T13:29:39.470 回答
0

您的问题在于quakeLevelsNormalized数组的计算。检查这个

//you need another index variable for 'quakeLevelsNormalized'
int j = 0;
for (i = 0; i < quakeLevels.length; i++) {

    //check the index, not the value, you have this wrong in your code
    //if(quakeLevels[i]!= minIndex && quakeLevels[i]!= maxIndex){
    if (i != minIndex && i != maxIndex) {
        quakeLevelsNormalized[j] = quakeLevels[i];
        System.out.printf("%6s\n", quakeLevelsNormalized[j]);

        //increment the index of 'quakeLevelsNormalized' array
        j++;
    }
}
于 2013-10-03T13:39:42.360 回答