Untitled

import java.util.*;

public class Runner {

    public static double calculateStandardDeviation(double average, ArrayList<Integer> numbers){
        double standardDeviation = 0.0;
        int length = numbers.size();

        for(Integer num : numbers){
            standardDeviation += Math.pow(num - average, 2);
        }

        return Math.sqrt(standardDeviation/length);
    }

    public static boolean isPalindrom(Integer num){
        String stringNum = num.toString();
        int strLength = stringNum.length();
        StringBuilder reverseStr = new StringBuilder("");
        for (int i = (strLength - 1); i >=0; --i) {
            reverseStr.append(stringNum.charAt(i));
        }

        if(stringNum.equals(reverseStr.toString())){
            return true;
        }

        return false;
    }

    public static double calculateMedian(ArrayList<Integer> numbers){
        double median = 0.0;
        int length = numbers.size();

        Collections.sort(numbers);

        if (length % 2 == 0) {
            int sumOfMiddleElements = numbers.get(length / 2) +
                    numbers.get(length / 2 - 1);
            // calculate average of middle elements
            median = ((double) sumOfMiddleElements) / 2;
        } else {
            // get the middle element
            median = (double) numbers.get(length / 2);
        }
        return median;
    }

    public static void main(String[] args) {
        //TODO: handling exceptions
        //TODO: check accuracy of functions
        //we assume that the number of integers is unfamiliar
        Scanner stdin = new Scanner(System.in);
        ArrayList<Integer> numbers = new ArrayList<>();

        //diff numbers with their frequencies
        TreeMap<Integer, Integer> diffNumbers = new TreeMap<>();

        //we assume that the input is correct
        int numOfOdds = 0;
        int numOfEvens = 0;
        while(stdin.hasNextInt()){
            int tmp = stdin.nextInt();
            numbers.add(tmp);

            if (tmp % 2 == 0){
                numOfEvens++;
            }
            else{
                numOfOdds++;
            }

            if (diffNumbers.containsKey(tmp)){
                diffNumbers.put(tmp, diffNumbers.get(tmp) + 1);
            }
            else{
                diffNumbers.put(tmp, 1);
            }
        }

        //1. print number of elements
        System.out.println("Number of elements: " + numbers.size());
        //2. print number of different elements
        System.out.println("Number of different elements: " + diffNumbers.size());
        //3. print number of even numbers
        System.out.println("Number of evens: " + numOfEvens);
        //4. print number of odd numbers
        System.out.println("Number of odds: " + numOfOdds);
        //5. print frequency of repetition for each number (percentage)
        double maxPercentage = 0;
        int maxOccurrence = -1;
        for(Map.Entry<Integer, Integer> item: diffNumbers.entrySet()) {
            double percentage = (double)item.getValue() / numbers.size() * 100.0;
            if(percentage >= maxPercentage){
                maxPercentage = percentage;
                maxOccurrence = item.getKey();
            }
            System.out.println("Number " + item.getKey() + " has frequency of " + percentage + "%.");
        }
        //6. print the number with the maximum occurrence
        System.out.println("Number with max occurrence: " + maxOccurrence);
        //TreeMap stores sorted keys
        //7. print largest number
        int largestNum = diffNumbers.lastKey();
        System.out.println("Largest number: " + largestNum);
        //8. print second-smallest number
        int i = 0;
        int secondSmallest = -1;
        for(Map.Entry<Integer, Integer> item: diffNumbers.entrySet()){
            if(i==1){
                secondSmallest = item.getKey();
                break;
            }
            i++;
        }
        System.out.println("Second smallest number: " + secondSmallest);
        //9. print average of all numbers
        int sum = numbers.stream().reduce(0, Integer::sum);
        double avg = (double)sum / numbers.size();
        System.out.println("Average of all numbers: " + avg);
        //10. print standard deviation
        System.out.println("Standard deviation: " + calculateStandardDeviation(avg, numbers));
        //11. print median
        ArrayList copy = (ArrayList) numbers.clone();
        System.out.println("Median: " + calculateMedian(copy));
        //12. print sum of all numbers
        System.out.println("Sum of all numbers: " + sum);
        //13. print number of palindromes
        int numOfPalindromes = 0;
        int maxPalindrome = 0;
        for(Map.Entry<Integer, Integer> item: diffNumbers.entrySet()){
            int currNumber = item.getKey();
            if(isPalindrom(currNumber)){
                numOfPalindromes += item.getValue();
                if(currNumber>=maxPalindrome && currNumber<largestNum){
                    maxPalindrome = currNumber;
                }
            }
        }
        System.out.println("Number of palindromes: " + numOfPalindromes);
        //14. print largest palindrome that is smaller then the greatest number
        System.out.println("The largest palindrome number: " + maxPalindrome);
        //15. print numbers in reverse order
        System.out.print('[');
        for(i=numbers.size()-1; i>=1; i--){
            System.out.print(numbers.get(i) + ", ");
        }
        System.out.println(numbers.get(i) + "]");
    }

}