Продвинутый рандом (возможность задать рандомное число в нескольких диапазонах)

#include <iostream>
#include <vector>
#include <time.h>
#include <conio.h>
 
using namespace std;
 
struct Range
{
    int min;
    int max;
};
 
int random(Range range, ...)
{
    static bool flag = false;
    if (!flag)
    {
        srand(time(0));
        flag = true;
    }
    Range* value = &range;
    vector<int> values;
    while (value->min || value->max)
    {
        values.push_back(value->min + rand() % (value->max - value->min));
        value++;
    }
    return values[rand() % values.size()];
}
 
int main(int argc, char *argv[])
{
    for (int i = 0; i < 10; i++)
    {
        int x = random(Range({ 0, 10 }), Range({ 50, 60 }));
        cout << "x[" << i << "] = " << x << endl;
    }
    return getch();
}

int x = random(map<int, int>{ -10, 10 }, map<int, int>{ 50, 60 }, map<int, int>{ 100, 120 });

int random(vector<Range> ranges)

#include <iostream>
#include <vector>
#include <time.h>
#include <conio.h>
#include <map>
 
using namespace std;
 
struct SrandFlag
{
    SrandFlag() { srand(time(0)); };
};
 
int random(map<int, int> ranges)
{
    static SrandFlag flag;
    vector<int> values;
    for (auto range : ranges)
        values.push_back(range.first + rand() % (range.second - range.first));
    return values[rand() % values.size()];
}
 
int main()
{
    for (int i = 0; i < 100; i++)
    {
        int x = random(map<int, int> { {-10, 10}, { 50, 60 } });
        cout << "x[" << i << "] = " << x << endl;
    }
    return getch();
}

#include <cmath>
#include <iostream>
#include <forward_list>
#include <vector>
#include <utility>
 
using type = int;
 
struct SrandFlag
{
    SrandFlag() { std::srand(time(0)); };
};
 
type random(const std::forward_list<std::pair<type, type>> &ranges)
{
    static SrandFlag flag;
    std::vector<type> values;
    for (auto range : ranges)
        values.push_back(range.first + rand() % std::abs(range.second - range.first));
    return values[rand() % values.size()];
}
 
int main()
{
    for (int i = 0; i < 100; i++)
    {
        const type x = random({ {-10, 10}, { 50, 60 } });
        std::cout << "x[" << i << "] = " << x << std::endl;
    }
}

int random(vector<Range> ranges)
//...
int main()
{
//...
        int x = random(vector<Ranges> { {-10, 10}, { 50, 60 } });
//...
}

#include <iostream>
#include <vector>
#include <time.h>
#include <conio.h>
#include <forward_list>
 
using namespace std;
 
struct SrandFlag
{
    SrandFlag() { srand(static_cast<unsigned int>(time(0))); };
};
 
int random(const forward_list<pair<int, int>> &ranges)
{
    static SrandFlag flag;
    vector<int> values;
    for (auto range : ranges)
        values.push_back(range.first + rand() % (range.second - range.first));
    return values[rand() % values.size()];
}
 
int main()
{
    for (int i = 0; i < 100; i++)
    {
        int x = random({ {-10, 10}, { 50, 60 } });
        cout << "x[" << i << "] = " << x << endl;
    }
    return getch();
}

#include <iostream>
#include <random>
#include <ctime>
 
struct Range
{
    int min_;
    int max_;
 
    operator int() const
    {
        return min_ + rand() % (max_ - min_);
    }
};
 
template <typename ...RangeT>
int random(RangeT const & ...args)
{
    static struct srand_randomize
    {
        srand_randomize() { std::srand(time(0)); }
    } randomize_;
 
    int values[] = { args... };
    return values[std::rand() % sizeof...(args)];
}
 
int main()
{
    std::cout << "random: " << random(Range{1, 10}, Range{25, 30}) << std::endl;
}

random(Range{ 0, 1 }, Range{ 100, 30000 })

#include <iostream>
#include <random>
#include <ctime>
 
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
                >::type
>
int random(RangeT const &...args)
{
    static std::mt19937 mt(static_cast<unsigned>(time(nullptr)));
    auto gen = [](Range const & x, std::mt19937 & g)
    {
        return std::uniform_int_distribution<int>(x.min, x.max)(g);
    };
    int const values[] = { gen(args, mt)... };
    std::discrete_distribution<int> idx({ std::fabs(args.min - args.max)... });
    return values[idx(mt)];
}
 
int main()
{
    for(int i = 0; i < 10; ++i)
    {
        std::cout << random(Range{ 0, 99 }, Range{ 100, 30000 }) << std::endl;
    }
}