sparse vector look up table, C++ (vc++)

Language: Layout:

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <random>
#include <ctime>

constexpr std::size_t N = 1000000 ; // #unique random numbers
constexpr std::size_t NRUNS = 112 ; // #runs
constexpr int  MINV = 1000000 ; // min_value
constexpr int  MAXV = 9999999 ; // max value

std::vector<int> make_population() // return vector with all numbers in [MINV,MAXV]
{
    std::vector<int> pop( MAXV-MINV + 1 ) ;
    std::iota( std::begin(pop), std::end(pop), MINV ) ;
    return pop ;
}

std::vector<int> generate() // generate N unique random integers in [MINV,MAXV]
{
    static std::vector<int> population = make_population() ;
    static std::mt19937 rng( std::random_device{}() ) ;

// return the first N numbers of the randomly shuffled vector
    std::shuffle( std::begin(population), std::end(population), rng ) ;
    return { std::begin(population), std::begin(population)+N } ;
}

std::vector<unsigned char> create_lookup_table( const std::vector<int>& unique_ids )
{
    static_assert( MINV >= 0 && MINV <= MAXV, "written for non-negative values" ) ;
    std::vector<unsigned char> lookup_table( MAXV-MINV + 1 ) ;
    for( unsigned int v : unique_ids ) lookup_table[v-MINV] = true ;
    return lookup_table ;
}

bool look_up( const std::vector<unsigned char>& lookup_table, int id )
{
    return lookup_table[id-MINV] ;
}

int main()
{
    unsigned long r = 0 ;

const auto lookup_table = create_lookup_table( generate() ) ;

// time time taken to lookup all numbers in [MINV,MAXV] NRUNS times
    const auto start = std::clock() ;

for( std::size_t run = 0 ; run < NRUNS ; ++run )
    {
        for( int id = MINV ; id <= MAXV ; ++id ) r += look_up( lookup_table, id ) ;
    }

const auto end = std::clock() ;
    std::cout << ( MAXV-MINV + 1 ) * NRUNS << " look ups in "
              << double(end-start) / CLOCKS_PER_SEC << " seconds\n" ;

return r > N * NRUNS ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,93 sec, absolute running time: 1,88 sec, absolute service time: 3,82 sec