work24

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int const MIN_SIZE = 1;
int const MAX_SIZE = 50;
int const MIN_C = 1;
int const MAX_C = 2;
int const MIN_A = -1000;
int const MAX_A = 1000;

int inputInteger(bool isIncorrect, const int MIN, const int MAX) {
    int n;
    n = 0;
    do {
        isIncorrect = false;
        cout << "Введите значение: " << endl;
        cin >> n;
        if (cin.fail()) {
            isIncorrect = true;
            cout << "Некорректный ввод." << endl;
            cin.clear();
            while (cin.get() != '\n');
        }
        if (!isIncorrect && (n < MIN || n > MAX)) {
            isIncorrect = true;
            cout << "Введите корректное значение." << endl;
        }
        if (!isIncorrect && cin.get() != '\n') {
            cout << "Введите корректное значение.";
            isIncorrect = true;
            cin.clear();
            while (cin.get() != '\n');
            cout << endl;
        }
    } while (isIncorrect);
    return n;
}

void createArray(const int n, bool isIncorrect, int* arr) {
    for (int i = 0; i < n; i++) {
            do {
                cout << "Введите " << i + 1 << " элемент массива : " << endl;
                isIncorrect = false;
                cin >> arr[i];
                if (cin.fail()) {
                    isIncorrect = true;
                    cout << "Некорректный ввод. Введите число." << endl;
                    cin.clear();
                    while (cin.get() != '\n');
                }
                if (!isIncorrect && (arr[i] < MIN_A || arr[i] > MAX_A) || (i > 0 && arr[i] < arr[i - 1])) {
                    isIncorrect = true;
                    cout << "Массивы должны быть упорядочены по возрастанию. Диапазон значений А от " << MIN_A << " до " << MAX_A << "." << endl;
                }
                if (!isIncorrect && cin.get() != '\n') {
                    cout << "Введите число. " << endl;
                    isIncorrect = true;
                    cin.clear();
                    while (cin.get() != '\n');
                    cout << endl;
                };
            } while (isIncorrect);
        }
    }


bool isFileTxt(string path, bool isIncorrect) {
    return (path.length() >= 4 && path.substr(path.length() - 4) == ".txt");
}

string takeFilePath(string path, bool isIncorrect) {
    do {
        isIncorrect = false;
        cout << "Введите относительный путь к файлу." << endl;
        cin >> path;
        fstream in(path);
        if (!isFileTxt(path, isIncorrect) || !in.is_open())
        {
            cout << "Проверьте нахождение файла по заданному пути." << endl;
            isIncorrect = true;
        }
        in.close();
    } while (isIncorrect);
    return path;
}

bool isFileEmpty(bool isIncorrect, string path) {
    ifstream in(path);
    do {
        isIncorrect = false;
        if (!in.is_open()) {
            cout << "Ошибка открытия файла." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
    } while (isIncorrect);
    return in.peek() == ifstream::traits_type::eof();
}

int readSizeFromFileForArrA(int& n, string path, bool isIncorrect) {
    ifstream in(path);
    do {
        isIncorrect = false;
        if (!in.is_open()) {
            cout << "Ошибка открытия файла." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
        else if (isFileEmpty(isIncorrect, path)) {
            cout << "Файл пустой." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
        else {
            do {
                isIncorrect = false;
                in >> n;
                if (!isIncorrect && (n < MIN_SIZE || n > MAX_SIZE)) {
                    isIncorrect = true;
                    cout << "Размер массива должен быть в диапазоне от " << MIN_SIZE << " до " << MAX_SIZE << "." << endl;
                    path = takeFilePath(path, isIncorrect);
                    n = readSizeFromFileForArrA(n, path, isIncorrect);
                }
            } while (isIncorrect);

        }
    } while (isIncorrect);
    in.close();
    return n;
}

int readSizeFromFileForArrB(int& n, string path, bool isIncorrect) {
    string str;
    str = "";
    ifstream in(path);
    getline(in, str);
    do {
        isIncorrect = false;
        if (!in.is_open()) {
            cout << "Ошибка открытия файла." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
        else if (isFileEmpty(isIncorrect, path)) {
            cout << "Файл пустой." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
        else {
            do {
                isIncorrect = false;
                in >> n;
                if (!isIncorrect && (n < MIN_SIZE || n > MAX_SIZE)) {
                    isIncorrect = true;
                    cout << "Размер массива должен быть в диапазоне от " << MIN_SIZE << " до " << MAX_SIZE << "." << endl;
                    path = takeFilePath(path, isIncorrect);
                    n = readSizeFromFileForArrB(n, path, isIncorrect);
                }
            } while (isIncorrect);

        }
    } while (isIncorrect);
    in.close();
    return n;
}

void readArrAFromFile(int n, int*& arrA, string path, bool isIncorrect) {
    string str;
    str = "";
    ifstream in(path);
    getline(in, str);
    getline(in, str);
    do {
        isIncorrect = false;
        for (int i = 0; i < n; i++) {
            in >> arrA[i];
            if (!isIncorrect && (arrA[i] < MIN_A || arrA[i] > MAX_A)) {
                isIncorrect = true;
            }
        }
        if (isIncorrect) {
            cout << "Диапазон значений элементов от " << MIN_A << " до " << MAX_A << endl;
            path = takeFilePath(path, isIncorrect);
            n = readSizeFromFileForArrA(n, path, isIncorrect);
            readArrAFromFile(n, arrA, path, isIncorrect);
        }
    } while (isIncorrect);
    in.close();
}


void readArrBFromFile(int n, int*& arrB, string path, bool isIncorrect) {
    string str;
    str = "";
    ifstream in(path);
    getline(in, str);
    getline(in, str);
    getline(in, str);
    do {
        isIncorrect = false;
        for (int i = 0; i < n; i++) {
            in >> arrB[i];
            if (!isIncorrect && (arrB[i] < MIN_A || arrB[i] > MAX_A)) {
                isIncorrect = true;
            }
        }
        if (isIncorrect) {
            cout << "Диапазон значений элементов от " << MIN_A << " до " << MAX_A << endl;
            path = takeFilePath(path, isIncorrect);
            n = readSizeFromFileForArrA(n, path, isIncorrect);
            readArrAFromFile(n, arrB, path, isIncorrect);
        }
    } while (isIncorrect);
    in.close();
}

int сountSizeOfArrC(int*& arrA, int sizeA, int*& arrB, int sizeB) {
    int count = 0;
    int j = 0;

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

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

    return count;
}

void mergeArrays(int* arrA, int sizeA, int* arrB, int sizeB, int* arrC, int k) {
    int index = 0;
    int i = 0;
    int j = 0;

    while (i < sizeA && j < sizeB && index < k) {
        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 < sizeA && index < k) {
        if (index == 0 || arrC[index - 1] != arrA[i]) {
            arrC[index] = arrA[i];
            ++index;
        }
        ++i;
    }
    while (j < sizeB && index < k) {
        if (index == 0 || arrC[index - 1] != arrB[j]) {
            arrC[index] = arrB[j];
            ++index;
        }
        ++j;
    }
}

void printToConsole(int* arr, int n) {
    for (int  i = 0; i < n; i++) {
        cout << arr[i] << "\t";
    }
    cout << "\n";
}

void printToFile(int* arr, string path, bool isIncorrect, const int n) {
    ofstream in(path);
    do {
        isIncorrect = false;
        if (!in.is_open()) {
            cout << "Файл невозможно открыть для записи." << endl;
            isIncorrect = true;
            path = takeFilePath(path, isIncorrect);
        }
    } while (isIncorrect);
    for (int i = 0; i < n; i++) {
        in << arr[i] << "\t";
    }
    in.close();
    cout << "Результат выведен в файле.";
}

int main() {
    setlocale(LC_ALL, "RU");
    int n;
    int m;
    int k;
    int choice;
    bool isIncorrect;
    string path;
    int* arrA = nullptr;
    int* arrB = nullptr;
    int* arrC = nullptr;
    n = 0;
    m = 0;
    choice = 0;
    isIncorrect = true;
    path = "";
    cout << "Данная программа выполняет слияние двух упорядоченных по возрастанию массивов целых чисел в один упорядоченный массив (без повторений)." << endl <<
        "Диапазон размеров массивов : " << MIN_SIZE << "..." << MAX_SIZE << endl << "Диапазон для значений элементов массива : " << MIN_A <<
        "..." << MAX_A << endl << "При работе с файлом в нём сначала должны быть прописаны размеры массивов, а затем сами массивы." <<
        "Откуда Вы хотите вводить данные ? " << "1 - консоль, 2 - файл." << endl;
    choice = inputInteger(isIncorrect, MIN_C, MAX_C);
    if (choice == 1) {
        cout << "Введите размер массива А. " << endl;
        n = inputInteger(isIncorrect, MIN_SIZE, MAX_SIZE);
        arrA = new int[n];
        createArray(n, isIncorrect, arrA);
        cout << "Введите размер массива В. " << endl;
        m = inputInteger(isIncorrect, MIN_SIZE, MAX_SIZE);
        arrB = new int[m];
        createArray(m, isIncorrect, arrB);
    }
    else {
        path = takeFilePath(path, isIncorrect);
        n = readSizeFromFileForArrB(n, path, isIncorrect);
        arrA = new int[n];
        readArrAFromFile(n, arrA, path, isIncorrect);
        m = readSizeFromFileForArrB(m, path, isIncorrect);
        arrB = new int[m];
        readArrBFromFile (m, arrB, path, isIncorrect);
    }
    k = сountSizeOfArrC(arrA, n, arrB, m);
    arrC = new int[k];
    mergeArrays(arrA, n, arrB, m, arrC, k);
    cout << "Куда Вы хотите вывести результат? 1 - консоль, 2 - файл." << endl;
    choice = inputInteger(isIncorrect, MIN_C, MAX_C);
    if (choice == 1) {
        printToConsole(arrC, k);
    }
    else {
        path = takeFilePath(path, isIncorrect);
        printToFile(arrC, path, isIncorrect, n);
    }
    delete[] arrA;
    delete[] arrB;
    delete[] arrC;

}