java24

import java.io.*;
import java.nio.file.*;
import java.util.Scanner;
public class Main {
    final static int MIN_SIZE = 1;
    final static int MAX_SIZE = 50;
    final static int MIN_A = -1000;
    final static int MAX_A = 1000;
    final static int MIN_C = 1;
    final static int MAX_C = 2;
    static Scanner in = new Scanner(System.in);

    public static int inputInteger(final int MIN, final int MAX) {
        boolean isIncorrect;
        int n;
        n = 0;
        do {
            isIncorrect = false;
            System.out.println("Введите значение.");
            try {
                n = Integer.parseInt(in.nextLine());
            } catch (NumberFormatException e) {
                isIncorrect = true;
                System.err.println("Некорректный ввод.");
            }
            if (n < MIN || n > MAX) {
                System.err.println("Введите корректное значение.");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return n;
    }

    public static boolean isEmpty(final String fileName) {
        boolean isEmpty;
        isEmpty = true;
        try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
            String line = br.readLine();
            if (line != null) {
                isEmpty = false;
            }
        } catch (IOException e) {
            System.err.println("Ошибка.");
        }
        return isEmpty;
    }

    public static String requestFileNameForReading() {
        boolean isIncorrect;
        String fileName;
        isIncorrect = true;
        File tempFile;
        Path path;
        do {
            System.out.println("Введите относительный путь к файлу.");
            fileName = in.nextLine();
            path = Paths.get(fileName);
            tempFile = new File(fileName);
            if (!tempFile.exists()) {
                System.err.println("Файл не существует.");
            } else if (fileName.length() < 5 || !fileName.endsWith(".txt")) {
                System.err.println("Файл не является текстовым.");
            } else if (!Files.isReadable(path)) {
                System.err.println("Этот файл невозможно открыть для чтения.");
            } else if (isEmpty(fileName)) {
                System.err.println("Этот файл пустой.");
            } else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return fileName;
    }

    public static String requestFileNameForWriting() {
        boolean isIncorrect;
        String fileName;
        isIncorrect = true;
        File tempFile;
        Path path;
        do {
            System.out.println("Введите относительный путь к файлу.");
            fileName = in.nextLine();
            path = Paths.get(fileName);
            tempFile = new File(fileName);
            if (!tempFile.exists()) {
                System.err.println("Файл не существует.");
            } else if (fileName.length() < 5 || !fileName.endsWith(".txt")) {
                System.err.println("Файл не является текстовым.");
            } else if (!Files.isWritable(path)) {
                System.err.println("Этот файл невозможно открыть для записи.");
            } else {
                isIncorrect = false;
            }
        } while (isIncorrect);
        return fileName;
    }

    public static int inputSizeFromFileForArrA(String fileName) {
        boolean isIncorrect;
        int size;
        do {
            size = 0;
            try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
                String line = br.readLine();
                if (line != null) {
                    size = Integer.parseInt(line.trim());
                    isIncorrect = (size < MIN_SIZE) || (size > MAX_SIZE);
                    if (isIncorrect) {
                        System.out.println("Размер не входит в диапазон от " + MIN_SIZE + " до " + MAX_SIZE);
                        fileName = requestFileNameForReading();
                    }
                } else {
                    System.out.println("Файл пуст.");
                    isIncorrect = true;
                    fileName = requestFileNameForReading();
                }
            } catch (IOException e) {
                System.out.println("Ошибка при чтении файла: ");
                isIncorrect = true;
                fileName = requestFileNameForReading();
            } catch (NumberFormatException e) {
                System.out.println("Ошибка в первой строке. Неправильный размер массива");
                isIncorrect = true;
                fileName = requestFileNameForReading();
            }
        } while (isIncorrect);
        return size;
    }

    public static int inputSizeFromFileForArrB(String fileName) {
        boolean isIncorrect;
        int size;
        do {
            size = 0;
            try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
                br.readLine();
                String line = br.readLine();
                if (line != null) {
                    size = Integer.parseInt(line.trim());
                    isIncorrect = (size < MIN_SIZE) || (size > MAX_SIZE);
                    if (isIncorrect) {
                        System.out.println("Размер не входит в диапазон от " + MIN_SIZE + " до " + MAX_SIZE);
                        fileName = requestFileNameForReading();
                    }
                } else {
                    System.out.println("Файл пуст.");
                    isIncorrect = true;
                    fileName = requestFileNameForReading();
                }
            } catch (IOException e) {
                System.out.println("Ошибка при чтении файла: ");
                isIncorrect = true;
                fileName = requestFileNameForReading();
            } catch (NumberFormatException e) {
                System.out.println("Ошибка в первой строке. Неправильный размер массива");
                isIncorrect = true;
                fileName = requestFileNameForReading();
            }
        } while (isIncorrect);
        return size;
    }

    public static int[] readArrAFromFile(int size, String fileName) {
        int[] arr;
        boolean isIncorrect;
        String[] intInString;
        String tempLine;
        do {
            isIncorrect = false;
            arr = new int[size];
            try (BufferedReader fReader = new BufferedReader(new FileReader(fileName))) {
                fReader.readLine();
                fReader.readLine();
                for (int i = 0; i < size; i++) {
                    tempLine = fReader.readLine();
                    if (tempLine != null) {
                        intInString = tempLine.split(" ");
                            arr[i]= Integer.parseInt(intInString[i]);
                            if (arr[i] < MIN_A || arr[i] > MAX_A) {
                                isIncorrect = true;
                            }
                        }
                    }
                if (isIncorrect) {
                    System.err.println("Элементы массива выходят за диапазон допустимых значений.");
                }
            } catch (NumberFormatException e) {
                System.err.println("Некорректный тип данных.");
                isIncorrect = true;
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
            }
            if (isIncorrect) {
                fileName = requestFileNameForReading();
                size = inputSizeFromFileForArrA(fileName);
            }
        } while (isIncorrect);
        return arr;
    }

    public static int[] readArrBFromFile(int size, String fileName) {
        int[] arr;
        boolean isIncorrect;
        String[] intInString;
        String tempLine;
        do {
            isIncorrect = false;
            arr = new int[size];
            try (BufferedReader fReader = new BufferedReader(new FileReader(fileName))) {
                fReader.readLine();
                fReader.readLine();
                fReader.readLine();
                for (int i = 0; i < size; i++) {
                    tempLine = fReader.readLine();
                    if (tempLine != null) {
                        intInString = tempLine.split(" ");
                        arr[i]= Integer.parseInt(intInString[i]);
                        if (arr[i] < MIN_A || arr[i] > MAX_A) {
                            isIncorrect = true;
                        }
                    }
                }
                if (isIncorrect) {
                    System.err.println("Элементы массива выходят за диапазон допустимых значений.");
                }
            } catch (NumberFormatException e) {
                System.err.println("Некорректный тип данных.");
                isIncorrect = true;
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
            }
            if (isIncorrect) {
                fileName = requestFileNameForReading();
                size = inputSizeFromFileForArrA(fileName);
            }
        } while (isIncorrect);
        return arr;
    }

    public static int[] createArray(final int n) {
        int[] arr = new int[n];
        boolean isIncorrect;
        for (int i = 0; i < n; i++) {
                do {
                    isIncorrect = false;
                    System.out.println("Введите " + (i + 1) + " элемент массива: ");
                    try {
                        arr[i] = Integer.parseInt(in.nextLine());
                    } catch (NumberFormatException e) {
                        isIncorrect = true;
                        System.err.println("Некорректный ввод. Введите число.");
                    }
                    if (!isIncorrect && (arr[i] < MIN_A || arr[i] > MAX_A) || (i > 0 && arr[i] < arr[i - 1])) {
                        isIncorrect = true;
                        System.err.println("Диапазон значений A от " + MIN_A + " до " + MAX_A + ". Массивы должны быть упорядочены по возрастанию");
                    }
                } while (isIncorrect);
        }
        return arr;
    }

    public static int countSizeOfArrC(int[] arrA, int[] arrB) {
        int count = 0;
        int j = 0;

        for (int i = 0; i < arrA.length; i++) {
            if (i == 0 || arrA[i] != arrA[i - 1]) {
                while (j < arrB.length && arrB[j] < arrA[i]) {
                    if (j == 0 || arrB[j] != arrB[j - 1]) {
                        count++;
                    }
                    j++;
                }
                if (j >= arrB.length || arrA[i] != arrB[j]) {
                    count++;
                }
            }
        }

        for (int k = j; k < arrB.length; k++) {
            if (k == 0 || arrB[k] != arrB[k - 1]) {
                count++;
            }
        }

        return count;
    }

    public static int[] mergeArrays(int[] arrA, int[] arrB, int k)  {
        int i = 0;
        int j = 0;
        int index = 0;
        int[] arrC = new int[k];
        while (i <= arrA.length - 1 && j <= arrB.length - 1) {
            if (arrA[i] < arrB[j]) {
                if (index == 0 || arrC[index - 1] != arrA[i]) {
                    arrC[index] = arrA[i];
                    index++;
                }
                i++;
            } else if (arrA[i] > arrB[j]) {
                if (index == 0 || arrC[index - 1] != arrB[j]) {
                    arrC[index] = arrB[j];
                    index++;
                }
                j++;
            } else {
                if (index == 0 || arrC[index - 1] != arrA[i]) {
                    arrC[index] = arrA[i];
                    index++;
                }
                i++;
                j++;
            }
        }
        while (i <= arrA.length - 1) {
            if (index == 0 || arrC[index - 1] != arrA[i]) {
                arrC[index] = arrA[i];
                index++;
            }
            i++;
        }
        while (j <= arrB.length - 1) {
            if (index == 0 || arrC[index - 1] != arrB[j]) {
                arrC[index] = arrB[j];
                index++;
            }
            j++;
        }
        return arrC;
    }

    public static void printToConsole(int[] arrC, int k) {
        for (int i = 0; i < k; i++) {
            System.out.print(arrC[i] + " ");
        }
        System.out.println();
    }

    public static void printToFile(String fileName, int[] arrC, int k) {
        boolean isIncorrect;
        isIncorrect = false;
        do {
            try (BufferedWriter fWriter = new BufferedWriter(new FileWriter(fileName))) {
                for (int i = 0; i < k; i++) {
                    fWriter.write((arrC[i]) + " ");
                }
                System.out.println("Результат выведен в файле.");
            } catch (IOException e) {
                System.err.println("Непредвиденная ошибка.");
                isIncorrect = true;
                fileName = requestFileNameForReading();
            }
        } while (isIncorrect);
    }

    public static void main(String[] args) {
        int choice;
        int n;
        int m;
        int k;
        int[] arrA;
        int[] arrB;
        int[] arrC;
        String fileName;
        System.out.println("Данная программа выполняет слияние двух упорядоченных по возрастанию массивов целых чисел в один упорядоченный массив (без повторений)." +
                "\nДиапазон размеров массивов : " + MIN_SIZE + "..." + MAX_SIZE +  "\nДиапазон для значений элементов массива : " + MIN_A +
                "..." + MAX_A + "\nПри работе с файлом в нём сначала должны быть прописаны размеры массивов, а затем сами массивы." +
                "\nОткуда Вы хотите вводить данные ? " + "1 - консоль, 2 - файл.");
        choice = inputInteger(MIN_C, MAX_C);
        if (choice == 1) {
            System.out.println("Введите размер массива А.");
            n = inputInteger(MIN_SIZE, MAX_SIZE);
            arrA = createArray(n);
            System.out.println("Введите размер массива В.");
            m = inputInteger(MIN_SIZE, MAX_SIZE);
            arrB = createArray(m);
        } else {
            fileName = requestFileNameForReading();
                n = inputSizeFromFileForArrA(fileName);
                m = inputSizeFromFileForArrB(fileName);
                arrA = readArrAFromFile(n, fileName);
                arrB = readArrBFromFile(m, fileName);
        }
        k = countSizeOfArrC(arrA, arrB);
        arrC = mergeArrays(arrA, arrB, k);
        System.out.println("Куда Вы хотите вывести результат? \n1 - консоль, 2 - файл.");
        choice = inputInteger(MIN_C, MAX_C);
        if (choice == 1) {
            printToConsole(arrC, k);
        } else {
            fileName = requestFileNameForWriting();
            printToFile(fileName, arrC, k);
        }
        in.close();
    }
}