fork download 
  1. import java.util.*;
  2. import java.lang.*;
  3. import java.io.*;
  4.  
  5. class Main {
  6.  
  7.     public static void main (String args[]) {
  8.  
  9.         int numbers[]= {1,5,-9,12,-3,89, 18,23,4,-6};
  10.  
  11.         try {
  12.             // Find minimum (lowest) value in array using loop
  13.             System.out.println("Minimum Value = " + getMinValue(numbers));
  14.  
  15.             // Find maximum (largest) value in array using loop
  16.             System.out.println("Maximum Value = " + getMaxValue(numbers));
  17.  
  18.             // ADD CODE TO CALL getAvgValue AND PRINT THE AVERAGE  
  19.             // Don't forget to call the avg method below ... call it just like 
  20.             // the two methods above ...
  21.             // Add any challenge method calls here ....
  22.             System.out.println("Average Value = " + getAvgValue(numbers));
  23.  
  24.             // CHALLENGE 1: CALL THE MEDIAN METHOD
  25.             System.out.println("Median Value = " + getMedianValue(numbers));
  26.  
  27.             // ADD CODE TO SORT THE NUMBERS IN THE ARRAY, PRINT THE SORTED ARRAY 
  28.             // Use the built-in array sort method on the array 
  29.             // ... then add a loop here (no need to call a method) to print 
  30.             // the now sorted array. See our lecture notes for examples. 
  31.  
  32.             Arrays.sort(numbers);
  33.             System.out.print("Sorted Array = ");
  34.             for (int i = 0; i < numbers.length; i++) {
  35.                 System.out.print(numbers[i] + " ");
  36.             }
  37.             System.out.println();
  38.  
  39.         } catch (ArithmeticException e) {
  40.             System.out.println("Arithmetic error: " + e.getMessage());
  41.         } catch (ArrayIndexOutOfBoundsException e) {
  42.             System.out.println("Array index error: " + e.getMessage());
  43.         }
  44.  
  45.     }  // main
  46.  
  47.  
  48.     // Find maximum (largest) value in array using loop  
  49.     public static int getMaxValue(int[] numbers) {
  50.  
  51.         int maxValue = numbers[0];  // set the first array element (index of 0) as the max
  52.  
  53.         // ... remember that arrays start with an index of 0  
  54.         // ADD CODE TO ADD A LOOP, CHECK EACH ARRAY ELEMENT 
  55.         // AGAINST THE CURRENT maxValue (USE AN IF STATEMENT)   
  56.  
  57.         // The key is to use a loop with the length property of the array 
  58.         // to access and check every element after the first element. The if statement 
  59.         // each time will check the current max value against the current 
  60.         // array value. At the end of the loop, maxValue will contain 
  61.         // the largest number in the array. 
  62.  
  63.         // Access each array element starting with the second element (i = 1, not 0)
  64.         for (int i = 1; i < numbers.length; i++) {
  65.             if (numbers[i] > maxValue) {  // current element > current max value ?
  66.                 maxValue = numbers[i];    // the current element is now the max value
  67.             }  // end if
  68.         }  // end for
  69.  
  70.         return maxValue; // return the largest array element value  
  71.     } // getMaxValue
  72.  
  73.  
  74.     // Find minimum (lowest) value in array using loop 
  75.     public static int getMinValue(int[] numbers) {
  76.  
  77.         int minValue = numbers[0];
  78.  
  79.         // ADD CODE TO ADD A LOOP, CHECK EACH ARRAY ELEMENT 
  80.         // AGAINST THE CURRENT minValue (USE AN IF STATEMENT) 
  81.  
  82.         // Hint: This is just like the for loop in the max function above, 
  83.         // just revise to check for min value instead of max value
  84.  
  85.         for (int i = 1; i < numbers.length; i++) {
  86.             if (numbers[i] < minValue) {
  87.                 minValue = numbers[i];
  88.             }
  89.         }
  90.  
  91.         return minValue;
  92.     } // getMinValue  
  93.  
  94.  
  95.     // Find the average of an array of integers 
  96.     public static double getAvgValue(int[] numbers) {
  97.  
  98.         // ADD CODE TO SET UP NEEDED VARIABLES, ONE TO SUM ALL ARRAY ELEMENT VALUES, AND 
  99.         // AND ANOTHER ONE, average, TO BE USED TO CALCULATE THE AVERAGE OF 
  100.         // ALL ARRAY ELEMENT VALUES 
  101.  
  102.         double average = 0;
  103.         double sum = 0;
  104.  
  105.         // ADD CODE TO ADD A LOOP TO COMPUTE A RUNNING TOTAL OF ALL ARRAY ELEMENTS 
  106.  
  107.         // use a loop like in the max function, but instead of an if, add the current 
  108.         // array element value to sum. This will keep a running total as each element value 
  109.         // is added to sum as it is accessed in the loop: sum = sum + numbers[i] ;
  110.  
  111.         for (int i = 0; i < numbers.length; i++) {
  112.             sum += numbers[i];
  113.         }
  114.  
  115.         // ADD CODE TO COMPUTE THE AVERAGE  
  116.  
  117.         // The average just takes the sum variable and divides it by the total 
  118.         // number of array items  (i.e., numbers.length)
  119.  
  120.         if (numbers.length == 0) {
  121.             throw new ArithmeticException("Cannot compute average of empty array.");
  122.         }
  123.  
  124.         average = sum / numbers.length;
  125.         return average;
  126.  
  127.     } // getAvgValue  
  128.  
  129.  
  130.     // CHALLENGE METHOD: Get the median of the array
  131.     public static double getMedianValue(int[] numbers) {
  132.         // Copy and sort the array without modifying the original
  133.         int[] sorted = Arrays.copyOf(numbers, numbers.length);
  134.         Arrays.sort(sorted);
  135.  
  136.         if (sorted.length == 0) {
  137.             throw new ArithmeticException("Cannot compute median of empty array.");
  138.         }
  139.  
  140.         if (sorted.length % 2 == 1) {
  141.             return sorted[sorted.length / 2];
  142.         } else {
  143.             int mid1 = sorted[(sorted.length / 2) - 1];
  144.             int mid2 = sorted[sorted.length / 2];
  145.             return (mid1 + mid2) / 2.0;
  146.         }
  147.     } // getMedianValue
  148.  
  149.     // Add any Challenge methods here ... 
  150.  
  151. } // Main Class
  152.  
Success #stdin #stdout 0.2s 57892KB
comments (?)
stdin 
Standard input is empty
stdout 
Minimum Value = -9
Maximum Value = 89
Average Value = 13.4
Median Value = 4.5
Sorted Array = -9 -6 -3 1 4 5 12 18 23 89
https://ideone.com/xIjuCj
language:
Java (HotSpot 12)
created:
18 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!