Java-解决简单数组地震程序

Question

I have a home work problem like this:

The following data represent Richter Scale data for earthquakes. Write a program to calculate and print the average of any valid earthquake data.

Store the Richter values in an array of doubles named quakeLevels.

Unfortunately, your seismograph is known to sometimes produce unreliable readings (like the value of 10.1 in this example). So you decide to throw out the maximum and minimum readings.

Your program should do the following:

Declare and initialize the quakeLevels array using the following data. { 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 }

Determine the maximum and minimum values in the array. Compute the average of the array contents, excluding the maximum and minimum values. Print the values in the array excluding the maximum and minimum values. Print the average.

I cannot use the Math class, so that is why everything is written out to print max and min.

Here is my code so far:

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

    }

And I get the following output:

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

Problem

So this is obviously not what it is supposed to look like. Why does it give me the extra 3.1 on the end? And it only has 14 elements, when it is supposed to have [18 minus the two extremes]? I'm a beginner programmer- and I greatly appreciate any and all help!!

Answer 1

I think you may have a mistake in comparisons.

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

In this line, you ask if the VALUE at index i is the same as the min/max index. This is not accurate to what you desire, youll want to compare i with maxIndex and minIndex directly.

Answer 2

Some possible methods to help you:

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

I think you don't even need the quakeLevelsNormalized array. Here my solution, anyway this logic could be improved:

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

}

Hope this was helpful.

Answer 4

There are few areas you can improve your code. For finding minimum and maximum you can use the collections method:

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

and your main problem is in the following line.

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

why it is quakeLevels.length - 2 , it should be quakeLevels.length . and also verify i = 1; or i = 0; need to be used in for loops.

and remove the following line

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

Answer 5

I'm guessing you're not allowed to use Collection types, right?

Try splitting the problem down into it's component parts and doing them one by one.

1) Only use the valid data: you could do this by looping through the array and checking each element in turn to see if it's <=0 or >=10. If it's valid, stick it in another array, if it's not, ignore it.

2) Calculate the max and min values: you've done this one! Store the indexes for the next bit

3) Calculate the average: loop through the values adding them up and printing them out as you go along, skipping the min and max you stored from above

Check each part is working before doing the next, it'll be easier for you to debug.

Answer 6

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

You should compare the index, not the values associated to the minIndex and maxIndex.

Also, why do you do iterate on 0...length-2 , you should just iterate on 0.. length-1 and check that the index is different than minIndex and maxIndex

This : arrayTotal = arrayTotal + quakeLevelsNormalized[ i ] can be simplified as

arrayTotal += quakeLevelsNormalized[i] 

If you can use an ArrayList for the normalized levels datastructure, you should, you don't have to care about the index this way.

You will just do:

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

Answer 7

Your problem is in the calculation of the quakeLevelsNormalized array. Check this

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