#include <iostream>
#include <random>
#include <algorithm>
#include <ctime>
#include <map>
 
struct Range
{
    int min;
    int max;
};
 
template <typename... T>
struct and_
    : std::true_type
{};
 
template <typename First, typename... Other>
struct and_<First, Other...>
    : std::integral_constant<bool, First::value && and_<Other...>::value>
{};
 
template < typename ...RangeT
         , typename = typename std::enable_if<
                    (and_<
                        std::is_same<RangeT, Range>...
                    >::value) && (sizeof...(RangeT) > 0)
                >::type
>
int random(std::mt19937 & mt, RangeT const & ...args)
{
    int sum = 0;
    struct MRange
    {
        const int min, max;
        const int distance;
 
        MRange(int min, int max, int & sum)
            : min(min), max(max), distance(std::abs(min - max))
        {
            sum += distance;
        }
    } const ranges[] =
    {
        MRange(args.min, args.max, sum)...
    };
    int index = std::uniform_int_distribution<int>(0, sum)(mt);
 
    int ret = ranges[0].min + index;
    if(ret > ranges[0].max)
    {
        index -= ranges[0].distance;
        for(size_t i = 1; i < sizeof...(args); ++i)
        {
            ret = ranges[i].min + index;
            if(ret > ranges[i].max)
            {
                index -= ranges[i].distance;
            }
            else
            {
                break;
            }
        }
    }
    return ret;
}
int main()
{
    std::mt19937 mt(static_cast<unsigned>(std::time(nullptr)));
 
    std::map<int, int> m;
    for(size_t n = 0; n < 10000; ++n)
    {
        ++m[random(mt, Range{ 0, 2 }, Range{ 50, 100 })];
    }
    for(auto p : m)
    {
        std::cout << p.first << " generated " << p.second << " times\n";
    }
}

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