问题

Question

我有这样的家庭工作问题：

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

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

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

我无法使用Math类，因此这就是为什么所有内容都被写出来打印max和min。

到目前为止，这是我的代码：

 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减去两个极端]时？我是初学程序员 - 我非常感谢所有人的帮助!!

Answer 1

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

if（quakeLevels [i]！= minIndex＆amp;＆amp; quakeLevels [i]！= maxIndex）

在此行中，您询问索引i处的VALUE是否与最小/最大索引相同。这对你想要的不准确，你想直接将我与maxIndex和minIndex进行比较。

Answer 2

一些可能的方法可以帮助您：

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

Answer 3

我认为你甚至不需要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);
    }

}

希望这有用。

Answer 4

您可以在几个方面改进代码。要查找最小值和最大值，可以使用集合方法：

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。并且还要验证{for循环中需要使用i = 1;或i = 0;。

并删除以下行

System.out.println( quakeLevelsNormalized[i-1]);

Answer 5

我猜你不允许使用收藏类型，对吧？

尝试将问题分解为组件部分并逐个进行。

1）仅使用有效数据：您可以通过循环遍历数组并依次检查每个元素来查看它是否为＆lt; = 0或＆gt; = 10。如果它有效，请将其粘贴到另一个数组中，如果不是，请忽略它。

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

3）计算平均值：循环输出值并将其打印出来，跳过从上面存储的最小值和最大值

检查每个部分是否正常工作，然后再进行调试。

Answer 6

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进行迭代并检查索引是否与minIndex和maxIndex不同

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

arrayTotal += quakeLevelsNormalized[i]

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

你会这样做：

if ((i != minIndex) && (i != maxIndex)) {
    normalized.add(quakeLevels[i])
 }

Answer 7

您的问题在于计算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++;
    }
}

Java - 解决简单阵列地震程序

我得到以下输出：

问题

7 个答案: