Header 1

#include <iostream>     // Библиотека ввода-вывода
#include <vector>       // Библиотека для работы с векторами
#include <ctime>        // Библиотека для работы со временем
#include <iterator>     // Подключаем итераторы
#include <string>       // Библиотека для работы со строками
#include <cmath>        // Библиотека для использования математических функций
#include <map>          // Библиотека для работы с ассоциативными массивами
#include <list>         // Библиотека для работы со списками
#include <set>          // Множества
#include <fstream>      // Библиотека для чтения информации из файла
#include <deque>        // Библиотека для работы с очередями

using namespace std;

// Прототипы функций для работы с массивами
void array_function();
void output_array(double *mas, int n);
void arithmetic_average(double *mas, int n);

// Прототип функции для работы с векторами
void vector_function();

// Прототип функции для работы со списком
void list_function();

// Прототипы функций для работы с ассоциативными массивами
void read_from_file_map(map<string, double> &glass, const string& filename);
void map_function();

// Прототипы функций для работы с очередями и мноествами
void deque_set_function();

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. МАССИВ
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Функция вывода значений массива на экран
// В функцию передается массив (mas []) и кол-во элементов этого массива (n)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void output_array(double *mas, int n)
{
    // Приветствие
    cout<<"Hello! There is an array of 10:"<<endl<<endl;
    // Обход элементов массива от 0 до 10
    for(int i=0; i<n; i++)
    {
        // Вывод элемента и его значения
        cout<<"mas["<<i<<"] = "<<mas[i]<<endl;
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Функция считает среднее арифметическое элементов массива
// В функцию передается массив (mas []) и кол-во элементов этого массива (n)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void arithmetic_average(double *mas, int n)
{
    double sum = 0; // Переменная для храниния суммы
    for(int i=0; i<n; i++)
    {
        sum += mas[i];
    }
    // Информируем пользователя
    cout<<endl<<"The arithmetic mean of the elements: "<<sum / n<<endl<<endl;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Основная функция
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void array_function()
{
    int n=10;    // Кол-во элементов
    double *mas; // Указатель на массив
    mas = new double[n]; // Указатель на 0-й элемент массива, состоящего из n элементов

    // Инициализация всех элементов массива с помощью цикла
    // Значение каждого элемента больше его индекса в 10 раз
    for(int i=0; i<10; i++)
    {
        mas[i] = i*10;
    }

    // Вывод массива на экран
    output_array(mas, 10);
    // Вывод среднего арифметического на экран
    arithmetic_average(mas, 10);

    delete [] mas; // Освобождение памяти
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 2. ВЕКТОР
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Основная функция
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void vector_function()
{
    vector<double> myVector(10); // Создали новый вектор из 10 элементов (каждый элемент равен 0)
    srand(time(0)); // Необходимо, чтобы каждый раз числа были случайными
    // Заполняем в цикле вектор случайными числами в диапазоне от -20 до 20
    for(int i=0; i<10; i++)
    {
        myVector[i] = (rand()%40 - 20);
    }

    // Вывод вектора на экран
    cout<<endl<<"There is a vector of 10:"<<endl;
    for(int i=0; i<myVector.size(); i++)
    {
        cout<<myVector[i]<<" ";
    }

    double s = 0; // В переменной s будет храниться сумма квадратов элементов вектора
    // Вычисляем сумму квадратов элементов с помощью цикла
    for(int i=0; i<myVector.size(); i++)
    {
       s+=myVector[i]*myVector[i];
    }
    s = sqrt(s/10); // Среднее квадратическое
    cout<<endl<<endl<<"The average quadratic: "<<s<<endl;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 3. СПИСОК
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Основная функция
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void list_function()
{
    list<double> myList; // Создаем список

    // В цикле организуем ввод элементов списка пользователем
    string s="Y";
    while ((s == "Y") || (s == "y"))
    {
        // Выводим на экран поясняющее сообщение
        cout<<endl<<"Enter the item of the list: ";
        // Создаем переменную типа double
        double x = 0;
        // Считываем очередное число, введенное пользователем, в переменную типа double
        cin>>x;
        // Помещаем это число в конец нашего списка
        myList.push_back(x);

        // Запрос на продолжение ввода данных
        cout<<endl<<"One more item? Y/N"<<endl;
        cin>>s;
    }

    // Вывод списка на экран
    copy(myList.begin(), myList.end(), ostream_iterator<double>(cout," "));

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Альтернативный код для поиска максимального по модулю элемента
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
    list<double>::iterator it; // Создаем итератор
    double max = abs(*myList.begin());
    for(it=myList.begin(); it != myList.end(); it++)
    {
       if  (max < abs(*it))
       {
           max = abs(*it);
       }
    }
    cout<<endl<<"MAX = "<<max<<endl;
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    myList.sort(); // Сортируем стандартным методом
    if (abs(myList.front()) > abs(myList.back()))  // Если модуль первого элемента больше модуля последнего элемента
    {
        cout<<"Maximum modulus: "<<myList.front(); // Выводим первый элемен (но не его модуль!)
    }
    else
    {
        cout<<"Maximum modulus: "<<myList.back();  // Иначе выводим последний элемент
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 4. АССОЦИАТИВНЫЙ МАССИВ
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Функция для ввода из файла в контейнер map
// В качестве первого параметра выступает контейнер, в который будут записываться данные
// В качестве второго параметра выступает строковая константа - имя файла с данными
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void read_from_file_map(map<string, double> &glass, const string& filename)
{
    ifstream ifile(filename); // создание потока ввода из файла по его имени

    while(!ifile.eof())       // пока не достигнут конец файла
    {
        string key;
        double n;
        ifile >> key >> n;    // считываем очередную марку стекла и показатель преломления
        glass[key] = n;       // создаем пару ключ-значение в нашем контейнере Map
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Основная функция
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void map_function()
{
    setlocale(LC_ALL, "rus");           // Для корректного отображения кирилицы
    map<string, double> glass;          // Объявление контейнера map для хранения марок стекла и
                                        // показателей преломления
    map<string, double>::iterator it;   // Создаем итератор - "указатель" на элемент, хранящийся в map
    read_from_file_map(glass, "glass.txt"); // Считывание из файла каталога оптических стекол

    // Вывод каталога оптических стекол на экран
    for(it = glass.begin(); it != glass.end(); it++)
    {
        cout<< it->first<<" : "<< it->second<<endl;
    }

    // Поиск максимального и минимального показателей преломления и соответствующих этим показателям
    // марок стекол
    double max = 0;
    double min = 1000;
    string maxname;
    string minname;

    for(it = glass.begin(); it != glass.end(); it++)
    {
        if (max < it->second)
        {
            max = it->second;
            maxname = it->first;
        }

        if (min > it->second)
        {
            min = it->second;
            minname = it->first;
        }
    }

    // Вывод максимального и минимального показателей преломления на экран пользователя
    cout<<endl<<endl<<"MAX:"<<endl<<maxname<<" "<<max<<endl;
    cout<<"MIN:"<<endl<<minname<<" "<<min;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 5. ОЧЕРЕДЬ И МНОЖЕСТВО
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Основная функция
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void deque_set_function()
{
    srand(time(NULL));                   // Инициализация генератора случайных чисел
    int dequeSize = 15;                  // Размер очереди
    deque<double> myDeque(dequeSize);    // Создали очередь
    set<double> mySet;                 // Создали множество
    for(int i=0; i<myDeque.size(); i++)  // Заполняем очередь
    {
        myDeque[i] = rand()%20-10;
    }
    copy(myDeque.begin(), myDeque.end(), ostream_iterator<double>(cout," ")); // Вывод очереди на экран

    for(int i=0; i<myDeque.size(); i++)
    {
        mySet.insert(myDeque[i]);
    }

    cout<<endl<<endl;
    // Вывод множества на экран
    copy(mySet.begin(), mySet.end(), ostream_iterator<double>(cout," ")); // Вывод очереди на экран
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////