[c++] shuffle container

template < class RandomIt, class UniformRandomNumberGenerator >
    void shuffle(RandomIt first, RandomIt last, UniformRandomNumberGenerator && g)
{
    typedef typename std::iterator_traits < RandomIt >::difference_type diff_t;
    typedef typename std::make_unsigned < diff_t >::type udiff_t;
    typedef typename std::uniform_int_distribution < udiff_t > distr_t;
    typedef typename distr_t::param_type param_t;

    distr_t D;
    diff_t n = last - first;
    for (diff_t i = n - 1; i > 0; --i)
    {
        using std::swap;
        swap(first[i], first[D(g, param_t(0, i))]);
    }
}

usage:

std::random_device rd;
std::mt19937 g(rd());

std::shuffle(vec.begin(), vec.end(), g);

 

[c++] print integer vector

void printVector(std::vector<int> &v)
{
    std::cout << "[";
    for (std::vector<int>::iterator it = v.begin() ; it != v.end() ; it++)
    {
        std::cout << *it;
        if (it != v.end()-1)
            std::cout << ",";
    }
    std::cout << "]";

}

[c++] hashing for vector

//key space might be restricted, don't use in production
size_t hashVector(std::vector<int> &v)
{
    size_t res = 2473;   //seed
    std::hash<std::string> hasher;
    std::vector<int>::const_iterator it;
    for ( it = v.begin() ; it != v.end() ; it++)
        res ^= hasher(std::to_string(*it)) * res;

    int i = static_cast<int>(res);
    return hasher(std::to_string(i));
}