স্টাড :: ভেক্টর কীভাবে পরিবর্তন করবেন?

Question 1

আমি std::vectorসি ++ এ এলোমেলো করার জন্য একটি জেনেরিক, পুনরায় ব্যবহারযোগ্য উপায়ের সন্ধান করছি। আমি বর্তমানে এটি এটি করি তবে আমি মনে করি এটি খুব কার্যকরী নয় কারণ এটির একটি মধ্যবর্তী অ্যারে প্রয়োজন এবং এটি আইটেমের ধরণটি জানতে হবে (এই উদাহরণে ডেককার্ড):

srand(time(NULL));

cards_.clear();

while (temp.size() > 0) {
    int idx = rand() % temp.size();
    DeckCard* card = temp[idx];
    cards_.push_back(card);
    temp.erase(temp.begin() + idx);
}

Question 2

সি ++ 11 থেকে আপনার পছন্দ করা উচিত:

#include <algorithm>
#include <random>

auto rng = std::default_random_engine {};
std::shuffle(std::begin(cards_), std::end(cards_), rng);

Live example on Coliru

rngআপনি std::shuffleযদি প্রতিবার বিভিন্ন ক্রিয়াকলাপ উত্পন্ন করার উদ্দেশ্যে থাকেন তবে একাধিক কলগুলিতে একই উদাহরণ পুনরায় ব্যবহার করতে ভুলবেন না !

তদুপরি, আপনি যদি চান যে আপনার প্রোগ্রামটি প্রতিবার সঞ্চালনের সময় বিভিন্ন ধরণের শ্যাফলগুলি তৈরি করতে চান, আপনি এর আউটপুট দিয়ে এলোমেলো ইঞ্জিনের নির্মাতাকে বীজ করতে পারেন std::random_device:

auto rd = std::random_device {}; 
auto rng = std::default_random_engine { rd() };
std::shuffle(std::begin(cards_), std::end(cards_), rng);

সি ++ 98 এর জন্য আপনি ব্যবহার করতে পারেন:

#include <algorithm>

std::random_shuffle(cards_.begin(), cards_.end());

Question 3

http://www.cplsplus.com/references/algorithm/shuffle/

// shuffle algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::shuffle
#include <vector>       // std::vector
#include <random>       // std::default_random_engine
#include <chrono>       // std::chrono::system_clock

int main () 
{
    // obtain a time-based seed:
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::default_random_engine e(seed);

    while(true)
    {
      std::vector<int> foo{1,2,3,4,5};

      std::shuffle(foo.begin(), foo.end(), e);

      std::cout << "shuffled elements:";
      for (int& x: foo) std::cout << ' ' << x;
      std::cout << '\n';
    }

    return 0;
}

Question 4

@ সিকাডা যা বলেছিল তা ছাড়াও আপনার প্রথমে বীজ বোধ করা উচিত,

srand(unsigned(time(NULL)));
std::random_shuffle(cards_.begin(), cards_.end());

প্রতি ফ্রেডলারসনের মন্তব্য:

র্যান্ডম_স্যাফেল () এর এই সংস্করণটির জন্য এলোমেলোতার উত্সটি বাস্তবায়ন সংজ্ঞায়িত করা হয়েছে, সুতরাং এটি র্যান্ড () ব্যবহার করতে পারে না। তাহলে srand () এর কোনও প্রভাব নেই।

তাই ওয়াইএমএমভি।

Question 5

আপনি যদি বুস্ট ব্যবহার করে থাকেন তবে আপনি এই শ্রেণিটি ব্যবহার করতে পারেন ( debug_modeসেট আপ করা হয়েছে false, যদি আপনি চান যে এলোমেলোকরণের পূর্বাভাসের মধ্যে এটি নির্ধারণ করা যেতে পারে যে আপনি নির্ধারণ করতে পারেন true):

#include <iostream>
#include <ctime>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <algorithm> // std::random_shuffle

using namespace std;
using namespace boost;

class Randomizer {
private:
    static const bool debug_mode = false;
    random::mt19937 rng_;

    // The private constructor so that the user can not directly instantiate
    Randomizer() {
        if(debug_mode==true){
            this->rng_ = random::mt19937();
        }else{
            this->rng_ = random::mt19937(current_time_nanoseconds());
        }
    };

    int current_time_nanoseconds(){
        struct timespec tm;
        clock_gettime(CLOCK_REALTIME, &tm);
        return tm.tv_nsec;
    }

    // C++ 03
    // ========
    // Dont forget to declare these two. You want to make sure they
    // are unacceptable otherwise you may accidentally get copies of
    // your singleton appearing.
    Randomizer(Randomizer const&);     // Don't Implement
    void operator=(Randomizer const&); // Don't implement

public:
    static Randomizer& get_instance(){
        // The only instance of the class is created at the first call get_instance ()
        // and will be destroyed only when the program exits
        static Randomizer instance;
        return instance;
    }

    template<typename RandomAccessIterator>
    void random_shuffle(RandomAccessIterator first, RandomAccessIterator last){
        boost::variate_generator<boost::mt19937&, boost::uniform_int<> > random_number_shuffler(rng_, boost::uniform_int<>());
        std::random_shuffle(first, last, random_number_shuffler);
    }

    int rand(unsigned int floor, unsigned int ceil){
        random::uniform_int_distribution<> rand_ = random::uniform_int_distribution<> (floor,ceil);
        return (rand_(rng_));
    }
};

আপনি এই কোড দিয়ে এটি পরীক্ষা করতে পারেন তার চেয়ে:

#include "Randomizer.h"
#include <iostream>
using namespace std;

int main (int argc, char* argv[]) {
    vector<int> v;
    v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);
    v.push_back(6);v.push_back(7);v.push_back(8);v.push_back(9);v.push_back(10);

    Randomizer::get_instance().random_shuffle(v.begin(), v.end());
    for(unsigned int i=0; i<v.size(); i++){
        cout << v[i] << ", ";
    }
    return 0;
}

Question 6

এটি এমনকি সহজ হতে পারে, বপন সম্পূর্ণভাবে এড়ানো যায়:

#include <algorithm>
#include <random>

// Given some container `container`...
std::shuffle(container.begin(), container.end(), std::random_device());

প্রোগ্রামটি চালিত হওয়ার পরে এটি একটি নতুন শ্যাফেল তৈরি করবে। কোডটির সরলতার কারণে আমি এই পদ্ধতিকেও পছন্দ করি।

এটি কাজ করে কারণ আমাদের যা প্রয়োজন তা std::shuffleহ'ল একটি UniformRandomBitGenerator, যার প্রয়োজনীয়তা std::random_deviceপূরণ করে।

দ্রষ্টব্য: যদি বারবার random_deviceপরিবর্তন হয় তবে স্থানীয় ভেরিয়েবলের মধ্যে সঞ্চয় করা ভাল :

std::random_device rd;
std::shuffle(container.begin(), container.end(), rd);

Question 7

আপনাকে যে স্ট্যান্ডার্ডটি অনুসরণ করতে হবে তার উপর নির্ভর করে (সি ++ 11 / সি ++ 14 / সি ++ 17) এই "সিপ্রেফারেন্স" পৃষ্ঠাটি বেশ ভাল উদাহরণ সরবরাহ করে: https://en.cppreferences.com/w/cpp/algorithm/ random_shuffle ।