Random string generator c++ - c++

Question

I would like to generate list of strings with no repeats as follows
A1, A2 , A3 , A4 , B1 , B2 , B3 , B4 , C1, C2, C3, C4
this is the way I generate out my list of strings
std::string columns[] ={"A","B","C"};
std::string rows[]={"1","2","3","4"};
std::string columnsAndRows;
for(int i=0; i<10; i++) {
for(int j=0; j<10; j++) {
columnsAndRows=columns[i]+row[j];
//possible to do something like this?
columnAndRows.rand();
}
}
but the problem is, I read about rand() and it returns a pseudo-random integral number in the range between 0 and RAND_MAX. what should I do to generate a random string base on my desired requirements?

Answer 1

Using std::rand with the modulus might not be a good idea. Instead you can easily construct a std::vector of possible elements and do a std::random_shuffle on that container:
std::vector<std::string> cols = {"A", "B", "C"};
std::vector<std::string> rows = {"1", "2", "3", "4"};
std::vector<std::string> vec;
for (auto i : cols)
for (auto j : rows)
vec.emplace_back(i + j);
std::random_shuffle(vec.begin(), vec.end());
And here's the running code results.
As hinted by DyP, std::random_shuffle might use rand inside its implementation (the truth is that it's implementation defined) therefore you might incur in the problem of keep getting the same results over and over again because you did not seed the random function.
Thankfully C++11 introduces std::shuffle that allow us to pass a third argument and define our own random generator functor. The great thing about this is that we can easily use <random> to feed that argument:
std::mt19937 rand_func(std::random_device{}());
std::shuffle(vec.begin(), vec.end(), rand_func);
And here's the running code results.

Answer 2

So why can't you use rand()? Because it may return a too-large value? Then pick a random value and if it's too large, (a) don't use it but pick another or (b) clip off the too large part using the % (modulus) operator:
my1stOwnRandomValue = rand() % 4;
my2ndOwnRandomValue = rand() % 4;
columnsAndRows=columns[my1stOwnRandomValue]+rows[my2ndOwnRandomValue];
This does not address "with no repeats", to do so you need more code. You may keep a list of 'used' values, or create a list of all possible combinations (after all there are only 16) and pick one at random from this list, then remove the picked combination from the list.

Answer 3

you can use time as the seed of random function this can aviod pseudo-random
srand((unsigned) time(NULL)); /*set seed must #include <time.h>*/
for(int i=0; i<10; i++) {
for(int j=0; j<10; j++) {
columnValue=rand() % 4;
rowValue=rand() % 4;
columnsAndRows=columns[columnValue]+row[rowValue];
}
}

Answer 4

Here's a C++11 version:
#include <random>
#include <algorithm>
#include <iostream>
#include <cstddef>
#include <vector>
// helper to get the size (extent) of a raw array
template<class T, std::size_t N>
constexpr std::size_t get_extent(T&)
{ return std::extent<T>::value; }
int main()
{
std::string const chars[] = {"A","B","C"};
std::string const digits[] = {"1","2","3","4"};
// vector containing the resulting strings
std::vector<std::string> result;
// create the "ordered" sequence A1, A2, A3, A4, B1, ..
for(auto const& eChar : chars)
for(auto const& eDigit : digits)
result.push_back( eChar+eDigit );
// shuffle the sequence
{
// random device to seed the PRNG
std::random_device rd;
// create a MT19937 PRNG, seeded
std::mt19937 g(rd());
std::shuffle(begin(result), end(result), g);
}
// output result
for(auto const& e : result) std::cout << e << ", ";
std::cout << "\n";
}
A C++03 version:
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <cstddef>
#include <vector>
// helper to get the size (extent) of a raw array
template<class T, std::size_t N>
std::size_t get_extent(T (&)[N])
{ return N; }
int main()
{
std::string const chars[] = {"A","B","C"};
std::string const digits[] = {"1","2","3","4"};
// vector containing the resulting strings
typedef std::vector<std::string> result_t;
result_t result;
// create the "ordered" sequence A1, A2, A3, A4, B1, ..
for(std::string const* pChar = chars;
pChar != chars + get_extent(chars);
++pChar)
for(std::string const* pDigit = digits;
pDigit != digits + get_extent(digits);
++pDigit)
result.push_back( *pChar+*pDigit );
// shuffle the sequence
{
std::srand( std::time(NULL) );
std::random_shuffle(result.begin(), result.end());
}
// output result
std::copy(result.begin(), result.end(),
std::ostream_iterator<std::string>(std::cout, ", "));
std::cout << "\n";
}

Answer 5

string strcat1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string strcat2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int stringl1 = strcat1.size() - 1;
int stringl2 = strcat1.size() - 1;
auto strfn1 = [&]() {return strcat2[rand() % stringl2];}; //will return a single char
auto strfn2 = [&]() {return strcat2[rand() % stringl2];};
while (true)
{
this_thread::sleep_for(500ms);
std::string str1(1, strfn1()); //fill 1 string/char space with arg2 here strfn1
std::string str2(1, strfn2());
std::string str3(1, strfn2());
str1 += str2;
str1 = str3 + str2 + str1 + str3; //as many adjacent string as you want
cout << str1<<" ";
}

Answer 6

#Jongware
You can avoid generating a number larger than the provided range by using the minimum and the difference between the maximum and minimum range instead.
So rather than:
int x = rand() % max + min;
Use:
int diff = max - min;
int x = rand() % diff + min;