Pick random element subset from map - c++

Question

I have a map of elements:
std::map<char,int> values;
values['a']=10;
values['b']=30;
values['c']=50;
values['d']=70;
values['e']=90;
values['f']=100;
values['g']=120;
So I need to pick N elements from values as a map of pairs preferably (output format as well as input format).
I tried other different solutions from stackoverflow but they mostly applicable for vector not for any type of C++ 11 container or looks too complicated for me.
I need some more effective way than just random_shuffle which actually mutates C++ container.
Also it would be nice if this function would be applicable for any type of C++ container.

Answer 1

You could copy the keys of the std::map<char, int> into an std::vector<char>. Then, shuffle this vector with std::random_shuffleX. Finally, return num elements of the map: the ones whose keys are the num last keys in the vector:
std::vector<std::pair<char, int>> pick_random(const std::map<char, int>& m, size_t num)
{
std::vector<char> keys;
keys.reserve(m.size());
// copy the map's keys
std::transform(m.begin(), m.end(), std::back_inserter(keys),
[](const std::pair<const char, int>& p) {
return p.first;
}
);
// shuffle the keys
std::random_shuffle(keys.begin(), keys.end());
// number of elements to pick
num = std::min(num, m.size());
std::vector<std::pair<char, int>> res;
res.reserve(num);
// pick num elements
std::generate_n(std::back_inserter(res), num,
[&keys, &m]() {
auto it = m.find(keys.back());
keys.pop_back();
return *it;
}
);
return res;
}
The idea is to randomly shuffle the elements in the vector containing the keys (i.e., keys). Therefore, you shuffle the keys, which map to elements in the map. You use these randomly shuffled keys to obtain elements from the map in a random way.
Xor std::shuffle insted since std::random_shuffle has been deprecated in C++14 and removed in C++17.

Answer 2

std::sample is C++17, but you can implement it yourself pretty easily in C++11. For example, for forward iterators (and std::map iterator does satisfy this requirement) typical implementation relies on the selection sampling algorithm. Its description can be found in Vol.2. of Knuth's TAOCP, p.142.
Simplest implementation:
template<class Forw_it, class Out_it, class URBG>
void sample(Forw_it first, Forw_it last, Out_it out, std::ptrdiff_t n, URBG&& g) {
auto sz = std::distance(first, last);
n = std::min(n, sz);
while (n != 0) {
std::uniform_int_distribution<std::ptrdiff_t> d(0, --sz);
if (d(g) < n) {
*out++ = *first;
--n;
}
++first;
}
}
Usage example:
std::map<char, int> values;
// ... assign values ...
std::vector<std::pair<char, int>> vec;
sample(values.begin(), values.end(), std::back_inserter(vec), 4, std::mt19937{});
for (auto p : vec)
std::cout << p.first << ' ' << p.second << '\n';
Sample output:
b 30
e 90
f 100
g 120
Full demo