Efficient combined min and mean computation of a vector - c++

Question

I need both the minimum and the mean of the values in a vector.
I'm computing them separately with the following:
template <class T>
T Minimum(std::vector<T> & v){ return *min_element(begin(v), end(v)); }
template <class T>
T Mean(std::vector<T> & v)
{
T sum = std::accumulate(v.begin(), v.end(), static_cast<T>(0));
T mean = sum / v.size();
return mean;
}
Both of these have to sweep the vector.
Is there a std efficient way to compute both minimum and mean of a vector sweeping it only once?

Answer 1

Yes, you can accumulate the minimum and the sum in the same call. No, it probably won't be more efficient, nor will it be less efficient.
template <typename T>
std::pair<T, T> MeanAndMin(const std::vector<T> & v)
{
auto zero = std::make_pair(static_cast<T>(0), std::numeric_limits<T>::max());
auto plus = [](auto pair, auto elem) { return std::make_pair(pair.first + elem, std::min(pair.second, elem)); };
auto res = std::accumulate(begin(v), end(v), zero, plus);
res.first /= v.size();
return res;
}

Answer 2

You can use std::accumulate, paired with custom functors:
#include <iostream>
#include <vector>
#include <numeric>
#include <limits>
#include <algorithm>
struct average_and_min {
int sum = 0;
int min = std::numeric_limits<int>::max();
std::size_t num_of_elements = 0;
int get_sum() {
return sum;
}
double get_average() {
return static_cast<double>(sum) / num_of_elements;
}
int get_min() {
return min;
}
};
int main() {
std::vector<int> vec = {1, 2, 5, 4, 4, 2, 4};
auto func_accumulate = [](average_and_min acc, int value) {
return average_and_min{acc.sum + value, std::min(acc.min, value), acc.num_of_elements + 1};
};
auto data = std::accumulate(vec.cbegin(), vec.cend(), average_and_min{}, func_accumulate);
std::cout << "avg: " << data.get_average() << '\n'
<< "min: " << data.get_min() << '\n';
}
EDIT:
As #Caleth suggested in the comments, it might be a good idea not to use lambdas to combine your struct and the value - you can overload operator + inside average_and_min like so:
average_and_min operator + (int value) {
return average_and_min{sum + value, std::min(min, value), num_of_elements + 1};
}
and the line
auto data = std::accumulate(vec.cbegin(), vec.cend(), average_and_min{}, func_accumulate);
can now become
auto data = std::accumulate(vec.cbegin(), vec.cend(), average_and_min{});