---

#include "func.h"

#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iostream>


void print_menu()
{
    std::cout << "Задача 1. Вариант 8\n";
    std::cout << "1 - решить задачу из input.txt\n";
    std::cout << "2 - сгенерировать input.txt\n";
    std::cout << "0 - выход\n";
}


int read_menu_item()
{
    int value{};

    std::cout << "Выберите пункт: ";
    std::cin >> value;

    return value;
}


bool correct_data(
    flist::FLIST& list,
    int min_value,
    int max_value,
    int min_count,
    int max_count
)
{
    int count{};

    flist::ptrNODE ptr{ list.get_head()->next };

    while (ptr)
    {
        if (ptr->info < min_value || ptr->info > max_value)
            return false;

        ++count;
        ptr = ptr->next;
    }

    return count >= min_count && count <= max_count;
}


bool read_and_check_list(
    flist::FLIST& list,
    const char input_file_name[],
    int min_value,
    int max_value,
    int min_count,
    int max_count
)
{
    std::ifstream input(input_file_name);

    if (!input)
    {
        std::cout << "File error: нет "
            << input_file_name << '\n';

        return false;
    }

    list.create_by_queue(input);

    if (!correct_data(
        list,
        min_value,
        max_value,
        min_count,
        max_count
    ))
    {
        std::cout << "Ошибка данных: в "
            << input_file_name
            << " должно быть от "
            << min_count
            << " до "
            << max_count
            << " чисел в диапазоне "
            << min_value
            << '-'
            << max_value
            << ".\n";

        return false;
    }

    return true;
}


double geometric_mean(flist::FLIST& list)
{
    double proizvedenie{ 1.0 };
    int count{};

    flist::ptrNODE ptr{ list.get_head()->next };

    while (ptr)
    {
        proizvedenie *= ptr->info;
        ++count;

        ptr = ptr->next;
    }

    return std::pow(proizvedenie, 1.0 / count);
}


void insert_geometric_mean(flist::FLIST& list)
{
    double mean{ geometric_mean(list) };

    int rounded_mean{
        static_cast<int>(std::round(mean))
    };

    std::cout << "Среднее геометрическое: "
        << mean << '\n';

    std::cout << "После округления: "
        << rounded_mean << '\n';

    list.push_front(rounded_mean);
}


void process_data(
    const char input_file_name[],
    const char output_file_name[],
    int min_value,
    int max_value,
    int min_count,
    int max_count
)
{
    flist::FLIST list;

    if (!read_and_check_list(
        list,
        input_file_name,
        min_value,
        max_value,
        min_count,
        max_count
    ))
        return;

    std::cout << "Список после чтения из файла:\n";
    list.print();

    list.sorting();

    std::cout
        << "Список после сортировки по возрастанию:\n";

    list.print();

    insert_geometric_mean(list);

    std::cout << "Итоговый список:\n";
    list.print();

    std::ofstream output(output_file_name);

    if (output)
    {
        list.print(output);

        std::cout << "Результат записан в "
            << output_file_name << ".\n";
    }
    else
    {
        std::cout << "File error: не удалось создать "
            << output_file_name << '\n';
    }
}


void generate_input(
    const char file_name[],
    int count,
    int min_value,
    int max_value
)
{
    std::ofstream file(file_name);

    if (!file)
    {
        std::cout << "File error: не удалось создать "
            << file_name << '\n';

        return;
    }

    std::cout << "Сгенерировано чисел: "
        << count << '\n';

    std::cout << "Данные: ";

    for (int i{}; i < count; ++i)
    {
        int elem{
            min_value +
            std::rand() % (max_value - min_value + 1)
        };

        file << elem;
        std::cout << elem;

        if (i != count - 1)
        {
            file << ' ';
            std::cout << ' ';
        }
    }

    file << '\n';

    std::cout << "\nФайл "
        << file_name
        << " создан.\n";
}


---

#pragma once

#include "flist.h"

void print_menu();

int read_menu_item();

bool correct_data(
    flist::FLIST& list,
    int min_value,
    int max_value,
    int min_count,
    int max_count
);

bool read_and_check_list(
    flist::FLIST& list,
    const char input_file_name[],
    int min_value,
    int max_value,
    int min_count,
    int max_count
);

double geometric_mean(flist::FLIST& list);

void insert_geometric_mean(flist::FLIST& list);

void process_data(
    const char input_file_name[],
    const char output_file_name[],
    int min_value,
    int max_value,
    int min_count,
    int max_count
);

void generate_input(
    const char file_name[],
    int count,
    int min_value,
    int max_value
);


----

/*
    ФИО: 
    Задача 1, вариант 8.

    Условие:
    В файле только натуральные числа 1-9, причем их количество от 1 до 18.
    Прочитав данные из файла создать упорядоченный по возрастанию список.
    Найти среднее геометрическое чисел списка, округлить до целого
    и вставить в начало списка. Результат вывести в файл и на консоль.
*/

#include "func.h"

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <windows.h>

int main()
{
    SetConsoleCP(65001);
    SetConsoleOutputCP(65001);

    std::srand(static_cast<unsigned int>(std::time(nullptr)));

    const char input_file_name[]{ "input.txt" };
    const char output_file_name[]{ "output.txt" };

    const int min_value{ 1 };
    const int max_value{ 9 };
    const int min_count{ 1 };
    const int max_count{ 18 };

    int menu_item{};

    do
    {
        print_menu();
        menu_item = read_menu_item();

        std::cout << '\n';

        switch (menu_item)
        {
        case 1:
            process_data(
                input_file_name,
                output_file_name,
                min_value,
                max_value,
                min_count,
                max_count
            );
            break;

        case 2:
        {
            int count{
                min_count +
                std::rand() % (max_count - min_count + 1)
            };

            generate_input(
                input_file_name,
                count,
                min_value,
                max_value
            );

            break;
        }

        case 0:
            std::cout << "Завершение программы\n";
            break;

        default:
            std::cout << "Нет такого пункта меню\n";
        }

        std::cout << '\n';

    } while (menu_item != 0);

    return 0;
}