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

package chapt01.b;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import static chapt01.b.OperationsWithNumbersSolver.*;

/**
 * @author m1st
 * 
 */

// TODO translate rus text to eng
// TODO for immutable rus text see native2ascii, ResourceBundle

public class OperationsWithNumbersStarter {
	public static void main(String[] args) {
		// 0. Ввести с консоли n целых чисел и поместить их в массив. На консоль
		// вывести:
		Scanner in = new Scanner(System.in);
		List<Integer> input = new ArrayList<Integer>();
		System.out.print("Введите целые числа через пробел, "
				+ "для окончания введите q: ");
		while (true) {
			String number = in.next();
			if (number.equals("q")) {
				break;
			} else {
				try {
					input.add(Integer.parseInt(number));
				} catch (NumberFormatException e) {
					System.out.print("Неправильный формат. Повторите ввод: ");
				}
			}
		}
		if (input.size() == 0) {
			System.exit(0);
		}
		int[] sourceNumbers = new int[input.size()];
		System.arraycopy(toIntArray(input), 0, sourceNumbers, 0, input.size());
		// 1. Четные и нечетные числа
		findEvenAndOddNumbers(sourceNumbers);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package chapt01.b;

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

import static java.util.Collections.*;

public class OperationsWithNumbersSolver {
	public static List<Integer> toIntegerList(int[] array) {
		List<Integer> result = new ArrayList<Integer>();
		for (int anArray : array)
			result.add(anArray);
		return result;
	}

	public static int[] toIntArray(List<Integer> list) {
		int[] result = new int[list.size()];
		for (int i = 0; i < list.size(); i++) {
			result[i] = list.get(i);
		}
		return result;
	}

	public static void findEvenAndOddNumbers(int[] 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);
	}

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

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

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

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

	public static void findNumbersWithThreeDifferentDigits(int[] sourceNumbers) {
		String number;
		System.out.print("\nВсе трехзначные числа, "
				+ "в десятичной записи которых нет одинаковых цифр: ");
		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))) {
				System.out.print(sourceNumber + ", ");
			}
		}
		System.out.println();
	}

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

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

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

	public static void findLeastCommonMultiple(int[] 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(int[] sourceNumbers) {
		System.out.print("Простые числа: ");
		for (Integer sourceNumber : sourceNumbers) {
			if (isPrimeNumber(sourceNumber)) {
				System.out.print(sourceNumber + ", ");
			}
		}
	}

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

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

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

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

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

	public static void findPalindromicNumbers(int[] sourceNumbers) {
		System.out.print("Числа-палиндромы: ");
		for (Integer sourceNumber : sourceNumbers) {
			StringBuilder s = new StringBuilder(sourceNumber.toString());
			if (s.toString().equals(s.reverse().toString())) {
				System.out.print(s + ", ");
			}
		}
		System.out.println();
	}

	public static void findNumbersOfHalfSumOfNeighbors(int[] sourceNumbers) {
		System.out.print("Элементы, которые равны полусумме соседних "
				+ "элементов: ");
		for (int i = 1; i < sourceNumbers.length - 1; i++) {
			if (sourceNumbers.length < 3) {
				break;
			}
			if (sourceNumbers[i] == ((sourceNumbers[i - 1] + sourceNumbers[i + 1]) / 2)) {
				System.out.print(sourceNumbers[i] + ", ");
			}
		}
	}

	public static void findPeriodForTwoFirstPositiveNumbersInARow(
	// Algorithm by RodionGork
			int[] 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("\nПериод десятичной дроби 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;
			}
		}
	}

	public static void buildPascalTriangleForFirstPositiveNumber(
			int[] sourceNumbers) {
		// TODO найти первый номер, а не список c первым номером
		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();
		}
	}
}

package chapt01.b;

import static chapt01.b.OperationsWithNumbersSolver.*;

/**
 * @author m1st
 * 
 */
public class OperationsWithNumbersStarter {
    public static void main(String[] args) {
	// 0. Ввести с консоли n целых чисел и поместить их в массив. На консоль
	// вывести:
	int[] sourceNumbers = readInput();
	if (sourceNumbers.length == 0) {
	    System.out.println("sourceNumbers.length == 0");
	    System.exit(0);
	}
	// 1. Четные и нечетные числа
	findEvenAndOddNumbers(sourceNumbers);

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

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

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

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

	// 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. Элементы, которые равны полусумме соседних элементов.
	int[] sourceNumbersClone2 = sourceNumbers.clone();
	findNumbersOfHalfSumOfNeighbors(sourceNumbersClone2);

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

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

package chapt01.b;

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

/**
 * @author m1st
 * 
 */
public class OperationsWithNumbersSolver {
    public static void println(Object obj) {
	System.out.println(obj);
    }

    public static void print(Object obj) {
	System.out.print(obj);
    }

    public static void println() {
	System.out.println();
    }

    public static int[] toIntArray(Collection<Integer> list) {
	int[] result = new int[list.size()];
	Iterator<Integer> it = list.iterator();
	for (int i = 0; i < list.size(); i++) {
	    result[i] = it.next();
	}
	return result;
    }

    public static int[] readInput(Scanner sc) {
	List<Integer> input = new ArrayList<Integer>();
	print("Введите целые числа через пробел, для окончания введите q: ");
	while (sc.hasNext()) {
	    String number = sc.next();
	    if (number.equals("q")) {
		break;
	    } else {
		try {
		    input.add(Integer.parseInt(number));
		} catch (NumberFormatException e) {
		    sc.close();
		    print("Неправильный формат. Программа завершена. ");
		    System.exit(0);
		}
	    }
	}
	return toIntArray(input);
    }

    public static int[] readInput(InputStream is) {
	return readInput(new Scanner(is));
    }

    public static int[] readInput() {
	return readInput(System.in);
    }

    public static List<Integer> toIntegerList(int[] array) {
	List<Integer> result = new ArrayList<Integer>(array.length);
	for (int element : array) {
	    result.add(element);
	}
	return result;
    }

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

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

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

    public static void findModNumbers(int divider1, int divider2,
	    int[] sourceNumbers) {
	print("Числа, которые делятся на " + divider1 + " и на " + divider2
		+ ": ");
	for (int sourceNumber : sourceNumbers) {
	    if ((sourceNumber % divider1 == 0)
		    && (sourceNumber % divider2 == 0)) {
		print(sourceNumber + ", ");
	    }
	}
	println();
    }

    public static void sortNumbersWithBubbleReverseByAbs(int[] sourceNumbers) {
	boolean swapped;
	int temp, j = 0;
	do {
	    swapped = false;
	    j++;
	    for (int i = 0; i < sourceNumbers.length - j; i++) {
		if (Math.abs((long) sourceNumbers[i]) < Math
			.abs((long) sourceNumbers[i + 1])) {
		    temp = sourceNumbers[i];
		    sourceNumbers[i] = sourceNumbers[i + 1];
		    sourceNumbers[i + 1] = temp;
		    swapped = true;
		}
	    }
	} while (swapped);
	print("Элементы, расположенные методом пузырька по убыванию модулей: "
		+ Arrays.toString(sourceNumbers) + "\n");
    }

    public static void findNumbersWithThreeDifferentDigits(int[] sourceNumbers) {
	int digit1, digit2, digit3;
	print("Все трехзначные числа, в десятичной записи которых нет одинаковых цифр: ");
	for (int sourceNumber : sourceNumbers) {
	    digit1 = sourceNumber / 100;
	    digit2 = sourceNumber / 10 % 10;
	    digit3 = sourceNumber % 10;
	    // Ищем трехзначные числа
	    if ((sourceNumber >= 100 && sourceNumber <= 999)
		    || (sourceNumber <= -100 && sourceNumber >= -999)) {
		if ((digit1 != digit2) && (digit2 != digit3)
			&& (digit1 != digit3)) {
		    print(sourceNumber + ", ");
		}
	    }
	}
	println();
    }

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

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

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

    /**
     * Метод вычисляет НОК чисел в массиве. Вычисление завершается на первом
     * нулевом числе (оно не входит в НОК). <strong>Результат метода в случае
     * переполнения не определен</strong>
     * 
     * @param sourceNumbers
     *            числа для нахождения НОК
     * @return НОК. В случае переполнения результат не определен.
     */
    public static void findLeastCommonMultiple(int[] sourceNumbers) {
	long result = sourceNumbers[0];
	if (result == 0) {
	    println("Наименьшее общее кратное: " + result);
	} else {
	    for (int i = 1; i < sourceNumbers.length; i++) {
		if (sourceNumbers[i] == 0) {
		    break;
		}
		result = findLeastCommonMultiple(result, sourceNumbers[i]);
	    }
	}
	println("Наименьшее общее кратное: " + result);
    }

    public static boolean isPrimeNumber(int number) {
	if (number <= 1) {
	    return false;
	}
	if (number == 2) {
	    return true;
	}
	if (number % 2 != 0) {
	    return true;
	}
	final double ceiledNumberSqrt = Math.ceil(Math.sqrt(number));
	for (long i = 3; i <= ceiledNumberSqrt; i += 2) {
	    if (number % i == 0) {
		return false;
	    }
	}
	return false;
    }

    public static void findPrimeNumbers(int[] sourceNumbers) {
	print("Простые числа: ");
	for (int sourceNumber : sourceNumbers) {
	    if (isPrimeNumber(sourceNumber)) {
		print(sourceNumber + ", ");
	    }
	}
	println();
    }

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

    public static Map<Integer, Integer> sortNumbersWithDescByValue(
	    Map<Integer, Integer> map) {
	List<Entry<Integer, Integer>> frequencyList = new ArrayList<Entry<Integer, Integer>>(
		map.entrySet());
	Collections.sort(frequencyList,
		new Comparator<Entry<Integer, Integer>>() {
		    public int compare(Entry<Integer, Integer> o1,
			    Entry<Integer, Integer> o2) {
			return ((Entry<Integer, Integer>) (o2)).getValue()
				.compareTo(
					((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;
    }

    public static void findNumbersFrequencyByDesc(int[] sourceNumbers) {
	List<Integer> numbers = toIntegerList(sourceNumbers);
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	int frequency = 1;
	for (Integer number : numbers) {
	    if (map.containsKey(number)) {
		map.put(number, ++frequency);
	    } else {
		map.put(number, 1);
	    }
	}
	println("Числа в порядке убывания частоты встречаемости чисел (число=встречаемость): "
		+ sortNumbersWithDescByValue(map));
    }

    public static void findHappyNumbers(int[] sourceNumbers) {
	print("“Счастливые” числа (сумма 1-ой пары чисел = сумме 2-ой пары): ");
	int digit1, digit2, digit3, digit4;
	for (int sourceNumber : sourceNumbers) {
	    if ((sourceNumber >= 1000 && sourceNumber <= 9999)
		    || (sourceNumber <= -1000 && sourceNumber >= -9999)) {
		digit1 = sourceNumber / 1000;
		digit2 = sourceNumber / 100 % 10;
		digit3 = sourceNumber % 100 / 10;
		digit4 = sourceNumber % 10;
		if (digit1 + digit2 == digit3 + digit4) {
		    print(sourceNumber + ", ");
		}
	    }
	}
	println();

    }

    /**
     * Метод находит числа Фибоначчи в массиве. <strong>Результат метода в
     * случае переполнения не определен</strong>
     * 
     * @param sourceNumbers
     *            числа для нахождения чисел Фибоначчи
     * @return числа Фибоначчи. В случае переполнения результат не определен.
     */
    public static void findFibonacciNumbers(int[] sourceNumbers) {
	print("Числа Фибоначчи: ");
	if (sourceNumbers.length >= 3) {
	    if (sourceNumbers[0] == 0) {
		print("0, ");
		if (sourceNumbers[1] == 1) {
		    print("1, ");
		}
	    }
	    for (int i = 2; i < sourceNumbers.length; i++) {
		if (sourceNumbers[i] == ((long) sourceNumbers[i - 2] + (long) sourceNumbers[i - 1])) {
		    print(sourceNumbers[i] + ", ");
		}
	    }
	} else {
	    print("sourceNumbers.length < 3");
	}
	println();
    }

    public static long reverseInt(int value) {
	long result = 0;
	while (value != 0) {
	    result = result * 10 + value % 10;
	    value /= 10;
	}
	return result;
    }

    public static void findPalindromicNumbers(int[] sourceNumbers) {
	print("Числа-палиндромы: ");
	for (int sourceNumber : sourceNumbers) {
	    if (sourceNumber == reverseInt(sourceNumber)) {
		print(sourceNumber + ", ");
	    }
	}
	println();
    }

    /**
     * Метод находит элементы, которые равны полусумме соседних элементов в
     * массиве. <strong>Результат метода в случае переполнения не
     * определен</strong>
     * 
     * @param sourceNumbers
     *            числа для нахождения элементов, которые равны полусумме
     *            соседних элементов в массиве
     * @return элементы, которые равны полусумме соседних элементов в массиве. В
     *         случае переполнения результат не определен.
     */
    public static void findNumbersOfHalfSumOfNeighbors(int[] sourceNumbers) {
	print("Элементы, которые равны полусумме соседних элементов: ");
	if (sourceNumbers.length >= 3) {
	    for (int i = 1; i < sourceNumbers.length - 1; i++) {
		if (sourceNumbers[i] == ((double) ((long) sourceNumbers[i - 1] + (long) sourceNumbers[i + 1]) / 2)) {
		    print(sourceNumbers[i] + ", ");
		}
	    }
	} else {
	    print("sourceNumbers.length < 3");
	}
	println();
    }

    public static int[] findFirstTwoPositiveNumbersInARow(int[] sourceNumbers) {
	int[] twoPositiveNumbers = new int[2];
	for (int i = 0; i < sourceNumbers.length - 1; i++) {
	    if ((sourceNumbers[i] > 0) && (sourceNumbers[i + 1] > 0)) {
		twoPositiveNumbers[0] = sourceNumbers[i];
		twoPositiveNumbers[1] = sourceNumbers[i + 1];
		break;
	    }
	}
	return twoPositiveNumbers;
    }

    public static void findPeriodForFirstTwoPositiveNumbersInARow(
	    int[] sourceNumbers) {
	String message = "Период десятичной дроби для первых двух целых положительных чисел, расположенных подряд: ";
	if (sourceNumbers.length < 2) {
	    println(message + "sourceNumbers.length < 2");
	    return;
	}
	int[] twoPositiveNumbers = findFirstTwoPositiveNumbersInARow(sourceNumbers);
	if (twoPositiveNumbers.length < 2) {
	    println(message
		    + "нет двух целых положительных чисел, расположенных подряд");
	    return;
	}
	int numerator = twoPositiveNumbers[0];
	int denominator = twoPositiveNumbers[1];
	if (numerator % denominator == 0) {
	    print(numerator / denominator + ".(0)");
	    return;
	}
	// Выделение из знаменателя наибольшей 2^
	int s = denominator % 2;
	int l = 0;
	while (s == 0) {
	    denominator = denominator / 2;
	    s = denominator % 2;
	    l++;
	}
	// Выделение из знаменателя наибольшей 5^
	s = denominator % 5;
	int l1 = 0;
	while (s == 0) {
	    denominator = denominator / 5;
	    s = denominator % 5;
	    l1++;
	}
	// Вычисление длины периода с новым знаменателем
	int periodLenth = 1;
	int r = 10;
	while (r != 1) {
	    r = (10 * r) % denominator;
	    if (r == 0) {
		break;
	    }
	    periodLenth++;
	}
	long beforePeriodLenth;
	if (l1 > l) {
	    beforePeriodLenth = l1;
	} else {
	    beforePeriodLenth = l;
	}
	denominator = twoPositiveNumbers[1];
	print(message + numerator / denominator + ".");
	numerator = numerator % denominator;
	for (int i = 0; i < beforePeriodLenth; i++) {
	    print((numerator * 10) / denominator);
	    numerator = (numerator * 10) % denominator;
	}
	print("(");
	for (int i = 0; i < periodLenth; i++) {
	    print((numerator * 10) / denominator);
	    numerator = (numerator * 10) % denominator;
	}
	print(") = " + twoPositiveNumbers[0] + " / " + twoPositiveNumbers[1] + "\n");
    }

    public static int findFirstPositiveNumber(int[] sourceNumbers) {
	for (int sourceNumber : sourceNumbers) {
	    if (sourceNumber > 0) {
		return sourceNumber;
	    }
	}
	return 0;
    }

    public static void buildPascalTriangleForFirstPositiveNumber(
	    int[] sourceNumbers) {
	final int firstPositiveNumber = findFirstPositiveNumber(sourceNumbers);
	if (firstPositiveNumber == 0) {
	    println("!in.hasNext()");
	} else {
	    print("Сколько строк треугольника Паскаля для числа "
		    + firstPositiveNumber + " отображать? ");
	    Scanner sc = new Scanner(System.in);
	    if (!sc.hasNext()) {
		sc.close();
		println("Треугольник Паскаля для первого положительного числа: нет чисел > 0");
	    } else {
		final int rows = sc.nextInt();
		for (int y = 0; y < rows; y++) {
		    int c = firstPositiveNumber;
		    for (int i = 0; i < rows - y; i++) {
			print("   ");
		    }
		    for (int x = 0; x <= y; x++) {
			print("   " + c + " ");
			c = c * (y - x) / (x + 1);
		    }

		    println();
		}
	    }
	    sc.close();
	}
    }
}