C++ Random number within range with exclusion

Question

I want to generate random number in range from 0 to 5, but for example, in some cases I don't need number 3, I only need 0, 1, 2, 4, 5. How can I generate random number within range, but with option to exclude numbers I don't need.

Answer 1

Here is yet another solution using modern features of C++ 11.

#include <functional>
#include <iostream>
#include <ostream>
#include <random>

int main()
{
    std::random_device rd;

    unsigned long seed = rd();
    std::cout << "seed " << seed << std::endl;

    std::mt19937 engine(seed);

    // Distribution  {0, 1, 2, 4, 5}
    std::discrete_distribution<> dist {{1, 1, 1, 0, 1, 1}};
    auto rng = std::bind(dist, std::ref(engine));

    const int n = 10;
    for (int i = 0; i != n; ++i)
    {
        int x = rng();
        std::cout << x << std::endl;
    }

    return 0;
}

Answer 2

Are the numbers you want to exclude known at compile time? Then a simple lookup table should do:

static int table[] = {0, 1, 2, 4, 5};
int index = rand() % (sizeof table / sizeof *table);
int number = table[index];

Of course, rand() is a terrible pseudo random number generator, but that's a different topic.

Answer 3

Just throw away the 3 in a loop:

template <typename Rng>
int rand_no_three (Rng& rng)
{
    std::uniform_int_distribution<> dist (0, 5);
    int c;

    do {
       c = dist (rng);
    } while (c == 3);

    return c;
}

Example usage:

std::mt19937 rng;
int c = rand_no_three (rng);

Answer 4

Here's a way of doing this without a lookup table in case you have memory constraints.

int map_fun(int i)
{ 
  switch(i)
  {
    case 3: return 4;
    case 4: return 5;
  }
  return i;
}

int main()
{
   int i= map_fun(random_between(0, 4));
}

Answer 5

here's an example using the java-code from this post: How can I generate a random number within a range but exclude some? translated to c++.

This is a little bit more generic and no unnecessary loops are used.

I also made a distribution, range and occurance - check in this program:

#include <iostream>
#include <vector>
#include <cstdlib>
#include <time.h>
#include <map>
using namespace std;


int getRandomWithExclusion(int start, int end, vector<int> &excludes){
    unsigned int max = end - start + 1 - excludes.size();
    int random = start+(rand() % max);
    for (unsigned int i = 0;i<excludes.size();i++) {
        int ex = excludes[i];
        if (random < ex){
            break;
        }
        random++;
    }
    return random;
}

int main()
{
    srand (time(NULL));
    vector<int> excl;

    map<int,int> distMap;

    excl.push_back(-2);
    excl.push_back(3);




    for(int i=0;i<100000;i++){

        int val = getRandomWithExclusion(-5,5,excl);
        if (distMap.find(val) == distMap.end()){
            distMap[val]=0;
        }
        int key = distMap[val]+1;
        distMap[val]=key;
    }
    map<int, int>::iterator p;
    for(p = distMap.begin(); p != distMap.end(); p++) {
        cout << p->first <<" occurs " <<p->second << endl;

    }

    cout << "seems legit: even distributed and correct" << endl;

    return 0;
}

Answer 6

This c++ function should handle the task:

int getRandomIntExcludingRange(int start, int end, int start_range, int end_range) {

    // handle bad input gracefully
    if (start > end) {
        std::swap(start, end);
    }
    if (start_range > end_range) {
        std::swap(start_range, end_range);
    }
    std::clamp(start_range, start, end);
    std::clamp(end_range, start, end);

    auto range_length = end_range - start_range;
    auto adj_end      = end - range_length;
    auto shifted_end  = adj_end - start;

    int rand_int = (rand() % shifted_end) + start;

    if (rand_int >= start_range) {
        rand_int = (rand_int - start_range) + end_range;
    }
    return rand_int;
}