If you change the set size or the maximun number of consecutive repetitions instead, then the ranking is not so stable. The benchmarks below show it.

I have also added a new solution salva2 (much faster in average) and some variations of almut's one.

The code:

And the benchmarking results:

Actually, the number of reps allowed is the one parameter that doesn't vary for my scenario. Also, the length of the string will never be less than the size of the set.

The approach you use in salva2 is very interesting, and does make it come out first in every benchmark I've run. One of my own alternatives used a similar approach: Generate a big string completely at random and then pick out a compliant N-char length lump with a regex and return it. Your innovations of a) making the whole string compliant using a regex, b) retaining the buffer across calls; combine to make the approach viable.

The funny thing is that I'm already effectively using the latter part in my code (but not the benchmarks), in as much as I need a bunch of short strings, but I'm calling the generator for one long string and then chopping it into bits using unpack "(A$N)*', gen( $N * 100, @set ). That negates a part of salva2's advantage, and also trades the cost of unpack against the cost of multiple calls to the generator.

Now I have to consider whether your generate a big string and the regex it into compliance approach would still be quicker in-situ. It's not an easy thing to benchmark. Neither is considering the affect it has on the randomness of the result.

It's quite amazing how many variations can result from an ostensibly simple spec. Many thanks for your input.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy

Neither is considering the affect it has on the randomness of the result

Well, actually it is!

Given the $size of the test, the probability of salva2 generating a string starting by two equal characters is 1/($size+1) instead of the 1/$size in the other methods.

The funny thing is that salva2 is unbiased, they are the other methods that are actually biased!!!

The following code counts the number of repetitions at any given position in the generated strings:

@set = (1..3);
$max_reps = 2;
$len = 10;

my @acu = ([], []);
my @gen = (\&gen_salva, \&gen_salva2);

my ($total, $ds) = (0,0);
my $n = 10000000;
for (1..$n) {
    for (0, 1) {
        my $out = $gen[$_]->();
        while ($out =~ /(.)\1/g) {
            $acu[$_]->[pos($out) - 2]++;
        }
    }
}

use Data::Dumper;
print Dumper \@acu;
[download]

And this is the result:

salva  => [ 3333044, 2222094, 2591285, 2469706, 2509595, 2496496, 2501
+039, 2501529, 2497584 ]
salva2 => [ 2500639, 2498220, 2499044, 2501878, 2500880, 2500962, 2498
+685, 2499675, 2508077 ]
[download]

So, with salva2 the probability of finding a repetition at any position is 1/($size+1) while with the rest of methods the probability varies between the maximum 1/$size (at position 0) and the minimum ($size-1)/$size**2 (at position 1).

I think there might be a little bug in salva2. I copied the code from Re^5: Random data generation to try my own solution (middle of the pack, not worth posting), but while studying the code, I noticed a potential problem. my $buf is declared just before gen_salva2.

my $buf;
sub gen_salva2 {
    while (length $buf < $len) {
        $buf .= $set[rand @set] for (1..$len*100);
        $buf =~ s/(.)\1{$max_reps,}/$1 x $max_reps/ge;
    }
    substr($buf, -$len, $len, '');
}
[download]

So I put it inside sub gen_salva2{} and ran it again. I bencharked only for $elements = 6, $max_reps = 2, to match BrowserUK's original parameters. That and the change to gen_salva2 are the only changes. Notice how the rankings change.

elements: 6 max_reps: 2
              Rate   salva2     salva almut_mod3 almut_mod4 almut_mod2
+     almut
salva2      1077/s       --      -98%       -98%       -98%       -98%
+      -98%
salva      54086/s    4922%        --       -10%       -13%       -13%
+      -17%
almut_mod3 59766/s    5450%       11%         --        -4%        -4%
+       -8%
almut_mod4 61953/s    5653%       15%         4%         --        -1%
+       -5%
almut_mod2 62270/s    5682%       15%         4%         1%         --
+       -5%
almut      65222/s    5956%       21%         9%         5%         5%
+        --
[download]

I thought gen_salva2 got its amazing speed boost by using an already populated $buf. After running the benchmark, I reduced the count to 100 and added a print line before creating $buf to test this theory.

my $buf;
sub gen_salva2 {
    print "$buf\n";
    while (length $buf < $len) {
        $buf .= $set[rand @set] for (1..$len*100);
        $buf =~ s/(.)\1{$max_reps,}/$1 x $max_reps/ge;
    }
    substr($buf, -$len, $len, '');
}
[download]

This printed a string 1164 chars long: 4235621656212414423622661645561656223662351124233115.... Each time through, it reduces the length by 12, which is then printed. When the string is too small, it generates a new one. The while() loop is simply not executed very often -- about 1 in 96 to 98 times on average.

--marmot

It is not a bug, gen_salva2 is designed to work that way!

$buf is populated by gen_salva2 but instead of generating data for just one output string it generates data for 100 of them (a few less, actually). Next calls to gen_salva2 do not need to fill $buf again as it already contains data (until exhausted, then it is refilled).

That's also the reason my previous comment said it was faster on average!