#include <iostream>
#include <vector>
#include <random>
#include <iomanip>

int main(int argc, char *argv[]){

int randomseed = std::atoi(argv[1]);  			 // pass a random seed
int n = 4;									// no of samples
std::vector <double> Xdata {1,2,3,4,5,6,7,8,9,10};  // how to sample n elements without replacement?

// seed random number generator and distribution
std::mt19937 twister;

std::seed_seq seq{1, 20, 3200, 403, 5*randomseed+1, 12000, 73667, 9474+randomseed, 19151-randomseed};
std::vector <std::uint32_t> seeds(1);
seq.generate(seeds.begin(), seeds.end());
twister.seed(seeds.at(0)); 

std::uniform_int_distribution <> distrib(0, Xdata.size()-1);  // uniform dist. over array indices

// naive way
int index;
std::vector <int> indices(0);	//	stores chosen indices
int i = 0; 					// counts no. if indices already found
bool match;				// alerts if sampled index was already used

while(i < n){

	match = false;
	index = distrib(twister);
	
	for(int j=0; j<indices.size(); ++j){

		if(index == indices[j]) {
			match = true;	
			break;
		}
	
	}
		
	if(match == false){			  // accept index
		indices.push_back(index);
		++i;
	} 	
	
}	
	
// print out my great results
for(int i=0; i<indices.size(); ++i){
	std::cout << Xdata[ indices[i] ] << std::endl;
}

return 0;

}

#include <iostream>
#include <vector>
#include <random>
#include <iomanip>

int main(int argc, char* argv[])
{

   int randomseed = std::atoi(argv[1]);  			 // pass a random seed
   int n = 4;									// no of samples
   std::vector <double> Xdata { 1,2,3,4,5,6,7,8,9,10 };  // how to sample n elements without replacement?

   // seed random number generator and distribution
   std::mt19937 twister;

   std::seed_seq seq { 1, 20, 3200, 403, 5 * randomseed + 1, 12000, 73667, 9474 + randomseed, 19151 - randomseed };
   std::vector <std::uint32_t> seeds(1);
   seq.generate(seeds.begin(), seeds.end());
   twister.seed(seeds.at(0));

   std::uniform_int_distribution <> distrib(0, Xdata.size() - 1);  // uniform dist. over array indices

   // naive way
   int index;
   std::vector <int> indices(0);	//	stores chosen indices
   int i = 0; 					// counts no. if indices already found
   bool match;				// alerts if sampled index was already used

   while (i < n)
   {

      match = false;
      index = distrib(twister);

      for (int j = 0; j < indices.size(); ++j)
      {

         if (index == indices[j])
         {
            match = true;
            break;
         }

      }

      if (match == false)
      {			  // accept index
         indices.push_back(index);
         ++i;
      }

   }

   // print out my great results
   for (int i = 0; i < indices.size(); ++i)
   {
      std::cout << Xdata[indices[i]] << std::endl;
   }

   return 0;

}

#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <algorithm>
#include <numeric>
using namespace std;

int main()
{
   const int SIZE = 10;
   const int n = 4;
   
   vector<double> Xdata( SIZE );
   iota( Xdata.begin(), Xdata.end(), 1 );

   mt19937 gen( time( 0 ) );
   shuffle( Xdata.begin(), Xdata.end(), gen );
   for ( int i = 0; i < n; i++ ) cout << Xdata[i] << " ";
}

#include <iostream>
#include <bitset>
#include <random>
using namespace std;

const int Size = 100, Choose = 30;

int main() {
    mt19937 rnd(random_device{}()); // not demonstrating great seeding here
    uniform_int_distribution<> dist(0, Size - 1);
    bitset<Size> b;
    vector<int> v;

    for (int i = 0; i < Choose; ++i) {
        int r;
        while (b[r = dist(rnd)]) ;
        b.set(r);
        v.push_back(r);
    }

    for (int n: v) cout << n << ' ';
    cout << '\n';
}

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

int main()
{
    std::mt19937 rbg { 42u }; 
    
    std::vector<int> population(1000);
    std::iota(population.begin(), population.end(), 0);
    std::vector<int> samples(10);
    std::sample(population.begin(), population.end(), samples.begin(), samples.size(), rbg);
    
    for (int sample: samples) std::cout << sample << ' '; 
    std::cout << '\n';
}

#include <iostream>
#include <random>
#include <array>
#include <numeric>
using namespace std;

#if defined(__linux__) || defined(linux) || defined(__linux)

#include <fstream>
size_t sysrandom(void* dst, size_t dstlen) {
    char* buffer = reinterpret_cast<char*>(dst);
    std::ifstream stream("/dev/urandom", stream.binary);
    stream.read(buffer, dstlen);
    return dstlen;
}

#elif defined(_WIN32)

#include <wincrypt.h>

bool acquire_context(HCRYPTPROV *ctx) {
    if (!CryptAcquireContext(ctx, 0, 0, PROV_RSA_FULL, 0))
        return CryptAcquireContext(ctx, 0, 0, PROV_RSA_FULL, CRYPT_NEWKEYSET);
    return true;
}
size_t sysrandom(void* dst, size_t dstlen) {
    HCRYPTPROV ctx;
    if (!acquire_context(&ctx))
        throw std::runtime_error("Unable to initialize Win32 crypt library.");
    BYTE* buffer = reinterpret_cast<BYTE*>(dst);
    if(!CryptGenRandom(ctx, dstlen, buffer))
        throw std::runtime_error("Unable to generate random bytes.");
    if (!CryptReleaseContext(ctx, 0))
        throw std::runtime_error("Unable to release Win32 crypt library.");
    return dstlen;
}

#endif

template<typename T>  // can use for mt19937 or mt19937_64
void seed_mt19937(T& rnd) {
    array<typename T::result_type, T::state_size> state;
    sysrandom(state.begin(), state.size() * sizeof(typename T::result_type));
    seed_seq s(state.begin(), state.end());
    rnd.seed(s);
}

const int Size = 100, Choose = 30;

int main() {
    mt19937 rnd;
    seed_mt19937(rnd);

    vector<int> v(Size);
    iota(v.begin(), v.end(), 0);

    for (int i = Size, j = 0; j < 30 && --i > 0; ++j) {
        swap(v[i], v[uniform_int_distribution<>(0, i)(rnd)]);

        cout << v[i] << ' ';
    }
    cout << '\n';
}

#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <algorithm>
#include <numeric>
using namespace std;

mt19937 gen( time( 0 ) );

template<typename T>
void partial_shuffle( vector<T> &V, int n )          // n steps of Fisher-Yates algorithm (assumes n <= V.size())
{                                                    // (https://www.cplusplus.com/forum/beginner/282421/#msg1222335 and following)
   for ( int i = 0; i < n; i++ ) swap( V[i], V[uniform_int_distribution<>(i,V.size()-1)( gen )] );
}

int main()
{
   const int SIZE = 100;
   const int n = 4;
   
   vector<double> X( SIZE );
   iota( X.begin(), X.end(), 1 );

   partial_shuffle( X, n );
   for ( int i = 0; i < n; i++ ) cout << X[i] << " ";
}