Уменьшение случайного равномерного распределения int на каждом проходе
Работаем над классом с размером блока 256 элементов. И каждый раз, когда вызывается моя функция добавления, прежде чем что-то сохранить; Я хочу сгенерировать равномерное случайное int в диапазоне [0,255]. То, что я хотел бы сделать, это до того, как эта функция завершит работу, чтобы отследить предыдущие использованные значения, чтобы в следующий раз через функцию равномерное распределение случайных чисел автоматически пропустило эти значения вместо того, чтобы проверять, есть ли там что-то уже ,
template<class T>
class SomeClass {
struct Node {
unsigned idx;
std::shared_ptr<T> pT;
Node() : idx(-1), pT(nullptr) {}
Node( unsigned idx_, std::shared_ptr<T>& pT_ ) : idx(idx_), pT(pT_) {}
}; // Node
private:
Node m_storage[256];
static unsigned m_elementCount;
std::set<unsigned> m_indexesUsed;
public:
SomeClass(){}
~SomeClass(){}
void add( T& obj );
}; // SomeClass
template<class T>
unsigned SomeClass<T>::m_elementCount = 0;
template<class T>
void SomeClass<T>::add( T& obj ) {
if ( m_elementCount == 256 ) {
return; // My Code Base Is Bigger - If This Is Full This Array gets pushed into a vector,
// and all values get reset to default and we start over.
}
Node n;
// Generate Uniform Random In Distribution In The Range of [0,255]
// Excluding the Values from m_listIndexesUsed.
n.idx = std::uniform_random_int_distribution from [0,255] excluding previous selected numbers
n.pT = std::make_shared<T>( obj );
m_storage[n.idx] = n;
m_indexesUsed.insert( n.idx );
m_elementCount++;
}
Может ли определение значения между указанным диапазоном в моем случае [0,255] быть сгенерировано, когда при каждом последующем вызове определяют другое случайное значение, которое ранее не было выбрано с равномерным случайным распределением int? Если так, как это будет сделано?
РЕДАКТИРОВАТЬ
После рассмотрения некоторых комментариев ниже, они подняли хороший вопрос. Что действительно необходимо в моем случае, так это набор из 256 уникальных значений ключей в диапазоне от 0 до 255, и они должны быть случайным образом перемешаны или перемешаны. Я подумаю над тем, как это сделать, но если кто-то захочет получить хороший пример, это приемлемо. Я не против заняться работой, но иногда, когда я достигаю точки, которую я, кажется, не могу пройти, и начинаю тратить на нее слишком много времени, я просто хочу пройти эту точку, чтобы я мог двигаться на.
Решение
У нас есть стандартный алгоритм тасования последовательностей; это называется, ну, shuffle, Поэтому сделайте последовательность 0 … 255, перемешайте ее, затем возьмите из полученного списка, пока вы не исчерпаете ее, и повторите. Оберните все это в шаблон класса, если хотите:
template<size_t N>
struct index_generator {
// seeding method for illustration purposes only
// see http://www.pcg-random.org/posts/cpp-seeding-surprises.html
index_generator() : rng(std::random_device()()) {
std::iota(indices.begin(), indices.end(), size_t{});
reset();
}
explicit operator bool() const { return current < N; }
// use [] if you don't need the bounds checking
size_t operator()() { return indices.at(current++); }
void reset() {
std::shuffle(indices.begin(), indices.end(), rng);
current = 0;
}
private:
std::array<size_t, N> indices;
size_t current;
std::mt19937 rng;
};
Использование в соответствии с
index_generator<256> gen; // static(?) data member
// ...
if ( !gen ) {
// we've exhausted the 256 indices
// do whatever you need to do
gen.reset();
return;
}
Node n;
n.idx = gen();
// other stuff
Другие решения
Других решений пока нет …