Ввести с консоли n целых чисел и поместить их в массив. На консоль вывести:
1. Четные и нечетные числа.
2. Наибольшее и наименьшее число.
3. Числа, которые делятся на 3 или на 9.
4. Числа, которые делятся на 5 и на 7.
5. Элементы, расположенные методом пузырька по убыванию модулей.
6. Все трехзначные числа, в десятичной записи которых нет одинаковых цифр.
7. Наибольший общий делитель и наименьшее общее кратное этих чисел.
8. Простые числа.
9. Отсортированные числа в порядке возрастания и убывания.
10. Числа в порядке убывания частоты встречаемости чисел.
11. “Счастливые” числа.
12. Числа Фибоначчи: f0 = f1 = 1, f (n) = f (n–1) + f (n–2).
13. Числа-палиндромы, значения которых в прямом и обратном порядке совпадают.
14. Элементы, которые равны полусумме соседних эле¬ментов.
15. Период десятичной дроби p = m/n для первых двух целых положительных чисел n и m, расположенных подряд.
16. Построить треугольник Паскаля для первого положительного числа.

package chapt01.b;

import java.util.*;
import java.util.Map.Entry;

import static java.util.Collections.*;

/**
 * @author m1st
 */

// TODO translate rus to eng

public class OperationsWithNumbers2 {
    private static void findEvenAndOddNumbers(Integer[] sourceNumbers) {
        List<Integer> evens = new ArrayList<Integer>();
        List<Integer> odds = new ArrayList<Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            if (sourceNumber % 2 == 0) {
                evens.add(sourceNumber);
            } else {
                odds.add(sourceNumber);
            }
        }
        System.out.println("Чётные числа: " + evens);
        System.out.println("Нечётные числа: " + odds);
    }

    private static void findMaxAndMinNumbers(Integer[] sourceNumbers) {
        List<Integer> numbers = Arrays.asList(sourceNumbers);
        System.out.println("Наибольшее число: " + max(numbers));
        System.out.println("Наименьшее число: " + min(numbers));
    }

    private static void findModNumbers(int divider, Integer[] sourceNumbers) {
        System.out.print("Числа, которые делятся на " + divider + ": ");
        for (Integer sourceNumber : sourceNumbers) {
            if (sourceNumber % divider == 0) {
                System.out.print(sourceNumber + ", ");
            }
        }
        System.out.println();
    }

    private static void sortNumbersWithBubbleReverseByAbs(
            Integer[] sourceNumbers) {
        Integer[] result = sourceNumbers.clone();
        boolean swapped = true;
        int j = 0;
        int temp;
        while (swapped) {
            swapped = false;
            j++;
            for (int i = 0; i < result.length - j; i++) {
                if (Math.abs(result[i]) < Math.abs(result[i + 1])) {
                    temp = result[i];
                    result[i] = result[i + 1];
                    result[i + 1] = temp;
                    swapped = true;
                }
            }
        }
        System.out.println("Элементы, расположенные методом пузырька "
                + "по убыванию модулей: " + Arrays.asList(result));
    }

    private static void findNumbersWithThreeDifferentDigits(
            Integer[] sourceNumbers) {
        String number;
        List<Integer> result = new ArrayList<Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            number = sourceNumber.toString();
            if (number.length() == 3 && number.charAt(0) != number.charAt(1)
                    && number.charAt(1) != number.charAt(2)
                    && number.charAt(0) != number.charAt(2)) {
                result.add(sourceNumber);
            }
        }
        System.out.println("Все трехзначные числа, "
                + "в десятичной записи которых нет одинаковых цифр: " + result);
    }

    private static long findGreatestCommonDivisor(long a, long b) {
        while (b > 0) {
            long temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    private static void findGreatestCommonDivisor(Integer[] sourceNumbers) {
        long result = sourceNumbers[0];
        for (int i = 1; i < sourceNumbers.length; i++) {
            result = findGreatestCommonDivisor(result, sourceNumbers[i]);
        }
        System.out.println("Наибольший общий делитель: " + result);
    }

    private static long findLeastCommonMultiple(long a, long b) {
        return a * (b / findGreatestCommonDivisor(a, b));
    }

    private static void findLeastCommonMultiple(Integer[] sourceNumbers) {
        long result = sourceNumbers[0];
        for (int i = 1; i < sourceNumbers.length; i++) {
            if ((sourceNumbers[i] == 0 || sourceNumbers[0] == 0)
                    || (sourceNumbers[i] < 0 || sourceNumbers[0] < 0)) {
                break;
            }
            result = findLeastCommonMultiple(result, sourceNumbers[i]);
        }
        System.out.println("Наименьшее общее кратное: " + result);
    }

    public static boolean isPrimeNumber(int n) {
        boolean prime = true;
        for (long i = 3; i <= Math.sqrt(n); i += 2) {
            if (n <= 1)
                return false;
            if (n == 2)
                return true;
            if (n % i == 0) {
                prime = false;
                break;
            }
        }
        return (n % 2 != 0 && prime && n > 2) || n == 2;
    }

    public static void findPrimeNumbers(Integer[] sourceNumbers) {
        List<Integer> result = new ArrayList<Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            if (isPrimeNumber(sourceNumber)) {
                result.add(sourceNumber);
            }
        }
        System.out.println("Простые числа: " + result);
    }

    public static void sortNumbersByAscAndDesc(Integer[] sourceNumbers) {
        List<Integer> numbers = Arrays.asList(sourceNumbers.clone());
        sort(numbers);
        System.out.println("Отсортированные числа в порядке возрастания: "
                + numbers);
        reverse(numbers);
        System.out.println("Отсортированные числа в порядке убывания: "
                + numbers);
    }

    private static Map<Integer, Integer> sortNumbersWithDescByValue(
            Map<Integer, Integer> map) {
        List<Map.Entry<Integer, Integer>> frequencyList = new LinkedList<Map.Entry<Integer, Integer>>(
                map.entrySet());
        sort(frequencyList, new Comparator<Object>() {
            @SuppressWarnings("unchecked")
            public int compare(Object o1, Object o2) {
                return ((Entry<Integer, Integer>) (o2)).getValue().compareTo(
                        ((Map.Entry<Integer, Integer>) (o1)).getValue());
            }
        });
        Map<Integer, Integer> result = new LinkedHashMap<Integer, Integer>();
        for (Entry<Integer, Integer> frequency : frequencyList) {
            result.put(frequency.getKey(), frequency.getValue());
        }
        return result;
    }

    private static void findNumbersFrequencyByDesc(Integer[] sourceNumbers) {
        Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            map.put(sourceNumber,
                    frequency(Arrays.asList(sourceNumbers), sourceNumber));
        }
        System.out.println("Числа в порядке убывания частоты встречаемости "
                + "чисел <Число=Встречаемость>: "
                + sortNumbersWithDescByValue(map));
    }

    private static void findHappyNumbers(Integer[] sourceNumbers) {
        String number;
        List<Integer> result = new ArrayList<Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            number = sourceNumber.toString();
            if (number.length() == 4
                    && number.charAt(0) + number.charAt(1) == number.charAt(2)
                            + number.charAt(3)) {
                result.add(sourceNumber);
            }
        }
        System.out.println("“Счастливые” числа (Сумма 1-ой пары чисел "
                + "= Сумме 2-ой пары): " + result);
    }

    private static void findFibonacciNumbers(Integer[] sourceNumbers) {
        // TODO не отображает 2 последних числа, если они являются числами
        // Фибоначчи
        List<Integer> result = new ArrayList<Integer>();
        for (int i = 0; i < sourceNumbers.length - 2; i++) {
            if (sourceNumbers.length < 3)
                break;
            else if (sourceNumbers[i + 2] == sourceNumbers[i]
                    + sourceNumbers[i + 1])
                result.add(sourceNumbers[i]);
        }
        System.out.println("Числа Фибоначчи: " + result);
    }

    private static void findPalindromicNumbers(Integer[] sourceNumbers) {
        List<StringBuilder> result = new ArrayList<StringBuilder>();
        for (Integer sourceNumber : sourceNumbers) {
            StringBuilder s = new StringBuilder(sourceNumber.toString());
            if (s.toString().equals(s.reverse().toString())) {
                result.add(s);
            }
        }
        System.out.println("Числа-палиндромы: " + result);
    }

    private static void findNumbersOfHalfSumOfNeighbors(Integer[] sourceNumbers) {
        Integer[] numbers = sourceNumbers.clone();
        List<Integer> result = new ArrayList<Integer>();
        for (int i = 1; i < numbers.length - 1; i++) {
            if (numbers.length < 3) {
                break;
            }
            if (numbers[i] == (numbers[i - 1] + numbers[i + 1]) / 2) {
                result.add(numbers[i]);
            }
        }
        System.out.println("Элементы, которые равны полусумме соседних "
                + "элементов: " + result);
    }

    private static void findPeriodForTwoFirstPositiveNumbersInARow(
    // Algorithm @author is RodionGork
            Integer[] sourceNumbers) {
        long p, q, r, l, t, i;
        for (int n = 0; n < sourceNumbers.length - 1; n++) {
            if (sourceNumbers.length < 2) {
                break;
            } else if (sourceNumbers[n] >= 0 && sourceNumbers[n + 1] >= 0) {
                p = sourceNumbers[n];
                q = sourceNumbers[n + 1];
                r = p;
                for (i = 0; i < q; i++) {
                    r = (r * 10) % q;
                }
                t = r;
                l = 0;
                do {
                    r = (r * 10) % q;
                    l++;
                } while (r != t);
                t = r = p;
                System.out.print("Период десятичной дроби p = m/n для "
                        + "первых двух целых положительных чисел n и m, "
                        + "расположенных подряд: 0.");
                for (i = 0; i < l; i++) {
                    r = (r * 10) % q;
                }
                for (i = 0; r != t; i++) {
                    System.out.print(t * 10 / q);
                    r = (r * 10) % q;
                    t = (t * 10) % q;
                }
                System.out.print('(');
                for (i = 0; i < l; i++) {
                    System.out.print(t * 10 / q);
                    t = (t * 10) % q;
                }

                System.out.println(')' + " = " + p + "/" + q);
                break;
            }
        }
    }

    private static void buildPascalTriangleForFirstPositiveNumber(
            Integer[] sourceNumbers) {
        List<Integer> positiveNumbers = new ArrayList<Integer>();
        for (Integer sourceNumber : sourceNumbers) {
            if (sourceNumber >= 0) {
                positiveNumbers.add(sourceNumber);
            } else {
                break;
            }
        }
        int firstPositiveNumber = positiveNumbers.get(0);
        System.out.print("Сколько строк треугольника Паскаля для числа "
                + firstPositiveNumber + " отображать? ");
        Scanner in = new Scanner(System.in);
        int rows = in.nextInt();
        for (int y = 0; y < rows; y++) {
            int c = firstPositiveNumber;
            for (int i = 0; i < rows - y; i++) {
                System.out.print("   ");
            }
            for (int x = 0; x <= y; x++) {
                System.out.print("   " + c + " ");
                c = c * (y - x) / (x + 1);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        // 0. Ввести с консоли n целых чисел и поместить их в массив.
        System.out.print("Сколько целых чисел вы собираетесь ввести? ");
        Scanner in = new Scanner(System.in);
        int size = in.nextInt();
        if (size == 0) {
            System.out.print("Программа завершена.");
            System.exit(0);
        }
        Integer[] sourceNumbers = new Integer[size];
        System.out.print("Введите целые числа через пробел "
                + "и нажмите <Enter>: ");
        for (int i = 0; i < size; i++) {
            sourceNumbers[i] = in.nextInt();
        }
        // 1. Четные и нечетные числа
        findEvenAndOddNumbers(sourceNumbers);

        // 2. Наибольшее и наименьшее число.
        findMaxAndMinNumbers(sourceNumbers);

        // 3. Числа, которые делятся на 3 или на 9.
        findModNumbers(3, sourceNumbers);
        findModNumbers(9, sourceNumbers);

        // 4. Числа, которые делятся на 5 и на 7.
        findModNumbers(5, sourceNumbers);
        findModNumbers(7, sourceNumbers);

        // 5. Элементы, расположенные методом пузырька по убыванию модулей.
        sortNumbersWithBubbleReverseByAbs(sourceNumbers);

        // 6. Все трехзначные числа, в десятичной записи которых нет одинаковых
        // цифр.
        findNumbersWithThreeDifferentDigits(sourceNumbers);

        // 7. Наибольший общий делитель и наименьшее общее кратное этих чисел.
        findGreatestCommonDivisor(sourceNumbers);
        findLeastCommonMultiple(sourceNumbers);

        // 8. Простые числа.
        findPrimeNumbers(sourceNumbers);

        // 9. Отсортированные числа в порядке возрастания и убывания.
        sortNumbersByAscAndDesc(sourceNumbers);

        // 10. Числа в порядке убывания частоты встречаемости чисел.
        findNumbersFrequencyByDesc(sourceNumbers);

        // 11. “Счастливые” числа.
        findHappyNumbers(sourceNumbers);

        // 12. Числа Фибоначчи: f0 = f1 = 1, f (n) = f (n–1) + f (n–2).
        findFibonacciNumbers(sourceNumbers);

        // 13. Числа-палиндромы, значения которых в прямом и обратном порядке
        // совпадают.
        findPalindromicNumbers(sourceNumbers);

        // 14. Элементы, которые равны полусумме соседних элементов.
        findNumbersOfHalfSumOfNeighbors(sourceNumbers);

        // 15. Период десятичной дроби p = m/n для первых двух целых
        // положительных чисел n и m, расположенных подряд.
        findPeriodForTwoFirstPositiveNumbersInARow(sourceNumbers);

        // 16. Построить треугольник Паскаля для первого положительного числа.
        buildPascalTriangleForFirstPositiveNumber(sourceNumbers);
    }
}