Отсортировать вектор классов

mas.group

mas.zad

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
 
//===================================================================
struct student
{
  std::string secondName;
  std::string group;
  int numberOfTests;
};
 
using pr = std::pair<std::string, int>;
 
//===================================================================
int main()
{ 
  std::vector<student> vs;
  vs.push_back({ "Gusev", "group2", 4 });
  vs.push_back({ "Ivanov", "group1", 1 });
  vs.push_back({ "Sidorov", "group2", 3 });
  vs.push_back({ "Petuhov", "group3", 3 });
  vs.push_back({ "Petrov", "group1", 5 });
 
  std::sort(vs.begin(), vs.end(),
            [] (const student& a, const student& b)
            { return a.group < b.group || (a.group == b.group && a.numberOfTests < b.numberOfTests); });
 
  for (const auto& j : vs)
    std::cout << std::setw(10) <<  j.secondName << " "
              << std::setw(10) << j.group << " "
              << std::setw(10) << j.numberOfTests << std::endl;
 
  std::vector<pr> result;
  auto it = vs.cbegin();
  while (it != vs.cend())
  {
    std::string tempGroup = it->group;
    result.push_back({tempGroup,
                     std::accumulate(it,
                                     std::find_if(it, vs.cend(), [&tempGroup] (const student& a) { return a.group != tempGroup; }),
                                     0,
                                     [] (int a, const student& b) { return a + b.numberOfTests; })});
    it = std::find_if(it, vs.cend(),
                      [&tempGroup] (const student& a) { return a.group != tempGroup; });
  }
 
  std::sort(result.begin(), result.end(),
            [] (const pr& a, const pr& b) { return a.second > b.second; });
 
  std::cout << "\n\nResult:\n";
  for (const auto& j : result)
    std::cout << std::setw(10) << j.first << " "
              << std::setw(10) << j.second << std::endl;
 
  return 0;
}

//есть вектор с полями
 
//mas.group
//и
//mas.zad
 
//первый тип строковый, второй int, короче нужно в векторе по полю
//"групп" сгруппировать, а zad сложить каждой группы, и все это дело
//отсортировать по уменьшению zad. Какие есть идеи? На данный момент
//имеется компаратор для сортировки всего вектора по zad.
//Получиться должно так
//например было так
//-----------------------
//fam |group |zad|
//-----------------------
//Иванов |group1 |1|
//Петров |group1 |5|
//Сидоров |group2 |3|
 
//Гусев |group2 |4|
//Петухов |group3 |3|
 
//должно стать так
//group2 |7|
//group1|6|
//group3|3|
///////////////////////////////////////////////////////////////////////////////
#include <functional>
#include <iostream>
#include <map>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
struct  T_student
{
    //-------------------------------------------------------------------------
    T_str   name_;
    T_str   group_;
    int     test_count_;
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_student             >   T_students;
typedef std::map        < T_str,        int     >   T_test_count_of_group;
///////////////////////////////////////////////////////////////////////////////
typedef std::multimap
    <
        int,
        T_str,
        std::greater< int >
    >
    T_group_of_test_count;
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_students  students    {
                                { "Ivanov",     "group_1",  1   },
                                { "Petrov",     "group_1",  5   },
                                { "Sidorov",    "group_2",  3   },
 
                                { "Gusev",      "group_2",  4   },
                                { "Petukhov",   "group_3",  3   }
                            };
 
    T_test_count_of_group   test_count_of_group;
 
    for( auto   const   &   student     :   students )
    {
        test_count_of_group[ student.group_ ]   +=  student.test_count_;
    }//for
 
    T_group_of_test_count   group_of_test_count;
 
    for( auto   const   &   group_and_test_count    :   test_count_of_group )
    {
        auto    group       =   group_and_test_count.first;
        auto    test_count  =   group_and_test_count.second;
 
        group_of_test_count.insert  (
                                        { test_count,   group   }
                                    );
    }//for
 
    for( auto   const   &   test_count_and_group    :   group_of_test_count )
    {
        std::cout   <<  test_count_and_group.second
                    <<  '\t'
                    <<  test_count_and_group.first
                    <<  std::endl;
    }//for
}