prakt-8__01.11.2022

#include <iostream>
#include <set>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

int main()
{


    typedef struct Auditoria{
        int index;
        int aud_capacity;
        bool multimedia = false;
        bool contain_computer = false;
        bool aud_inventory = false;
        vector<tuple<int, int>> index_pairs;

        //Перегрузка оператора "<" для дальнейшей сортировки по возрастанию
        bool operator < (const Auditoria& input_struct) const{
            return (aud_capacity < input_struct.aud_capacity);
        }
    } auditoria;


    typedef struct Group{
        int index;
        int group_amount;
        int group_stream;


        bool operator < (const Group& input_struct) const{
            return (group_amount < input_struct.group_amount);
        }
    } group;


/*
    struct Timetable{
        string lesson_type;
        int lesson_duration;
        string aud_requirements;
    } timetb;
*/


    vector<group> group_array;
    int group_number, aud_number;

    cout << "Введите количество групп: ";
    cin >> group_number;

    for (int i = 0; i < group_number; i++){
        group group_data;

        group_data.index = i+1;

        cout << "Введите численность группы: ";
        cin >> group_data.group_amount;

        cout << "Введите поток группы: ";

        cin >> group_data.group_stream;
        group_array.push_back(group_data);
    }



    vector<auditoria> aud_array;

    cout << "Введите количество аудиторий: ";
    cin >> aud_number;



    for (int j = 0;j < aud_number;j++){
        auditoria aud_data;

        aud_data.index = j+1;

        cout << "Введите вместимость аудитории: ";
        cin >> aud_data.aud_capacity;

        aud_array.push_back(aud_data);


    }


    sort(group_array.begin(), group_array.end());


    sort(aud_array.begin(), aud_array.end());


    for (int i= 0; i < aud_number;i++){
        for (int j = 0; j < group_number;j++){

            if (aud_array[i].aud_capacity >= group_array[j].group_amount){

                aud_array[i].index_pairs.push_back(tuple<int, int>(group_array[j].index, group_array[j].group_stream));


            }
            /*
            else{
                cout << "Группа с индексом " << group_array[j].index << " не помещается в аудиторию с индексом " << aud_array[i].index << endl;
            }
            */
        }
    }

    int output_index, output_stream;

    for (int i = 0; i < aud_number; i++){
        tie(output_index, output_stream) = aud_array[i].index_pairs[i];

        cout << "Auditoria index: "<< aud_array[i].index << "  ";
        cout << "Group index: "<< output_index << "  ";
        cout << "Group stream: "<< output_stream << endl;
    }

    return 0;
}