lab9/main.cpp at main · reprenter/lab9 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <iostream>
#include <string>
#include <vector>
#include <type_traits>
#include <utility>

template <class KeyT, class ElemT, class SumT>
struct GroupInfo {
  KeyT key{};
  std::size_t count{0};
  ElemT minElem{};
  ElemT maxElem{};
  SumT sum{};
  long double avg{0.0L};
};

template <class ElemT, class KeyFunc, class ValueFunc>
auto groupStats(const ElemT* arr, std::size_t n, KeyFunc keyFunc, ValueFunc valueFunc) {
  using KeyT = std::decay_t<decltype(keyFunc(std::declval<ElemT>()))>;
  using ValT = std::decay_t<decltype(valueFunc(std::declval<ElemT>()))>;
  using SumT = std::common_type_t<long double, ValT>;

  std::vector<GroupInfo<KeyT, ElemT, SumT>> groups;
  groups.reserve(n);

  for (std::size_t i = 0; i < n; ++i) {
    const ElemT& x = arr[i];
    KeyT k = keyFunc(x);
    SumT v = static_cast<SumT>(valueFunc(x));

    // Ищем уже существующую группу по ключу (без готовых группировок из библиотек).
    auto it = groups.end();
    for (auto gIt = groups.begin(); gIt != groups.end(); ++gIt) {
      if (gIt->key == k) {
        it = gIt;
        break;
      }
    }

    if (it == groups.end()) {
      // Новая группа
      GroupInfo<KeyT, ElemT, SumT> g;
      g.key = k;
      g.count = 1;
      g.minElem = x;
      g.maxElem = x;
      g.sum = v;
      g.avg = static_cast<long double>(g.sum) / static_cast<long double>(g.count);
      groups.push_back(std::move(g));
    } else {
      // Обновляем существующую группу
      it->count += 1;
      if (x < it->minElem) it->minElem = x;
      if (it->maxElem < x) it->maxElem = x;
      it->sum += v;
      it->avg = static_cast<long double>(it->sum) / static_cast<long double>(it->count);
    }
  }

  return groups;
}

template <class GroupT>
void printGroups(const std::vector<GroupT>& groups) {
  for (const auto& g : groups) {
    std::cout << g.key << ", "
              << g.count << ", "
              << g.minElem << ", "
              << g.maxElem << ", "
              << g.sum << ", "
              << g.avg << "\n";
  }
}

int main() {
  // 1) Массив int: ключ = последняя цифра, value = само число
  int a1[] = {15, 21, 32, 45, 10, -7, 17, 28, 40};
  auto g1 = groupStats(
      a1, sizeof(a1) / sizeof(a1[0]),
      [](int x) { return x % 10; },
      [](int x) { return x; }
  );

  std::cout << "INT groups (key, count, minElem, maxElem, sum, avg):\n";
  printGroups(g1);
  std::cout << "\n";

  // 2) Массив double: ключ = номер интервала, value = само число
  double a2[] = {-3.5, 0.0, 2.25, 10.0, 10.5, 100.0, -0.1};
  auto g2 = groupStats(
      a2, sizeof(a2) / sizeof(a2[0]),
      [](double x) {
        if (x < 0.0) return 0;
        if (0.0 <= x && x <= 10.0) return 1;
        return 2;
      },
      [](double x) { return x; }
  );

  std::cout << "DOUBLE groups (key, count, minElem, maxElem, sum, avg):\n";
  printGroups(g2);
  std::cout << "\n";

  // 3) Массив std::string: ключ = первая буква (char), value = длина строки
  std::string a3[] = {"apple", "apricot", "banana", "blue", "cherry", "car", "avocado"};
  auto g3 = groupStats(
      a3, sizeof(a3) / sizeof(a3[0]),
      [](const std::string& s) { return s.empty() ? '\0' : s[0]; },
      [](const std::string& s) { return static_cast<int>(s.size()); }
  );

  std::cout << "STRING groups (key, count, minElem, maxElem, sum, avg):\n";
  printGroups(g3);

  return 0;
}