I briefly looked at Algorithm::Loops by tye this morning but didn't quite understand it yet. Not quite intuitive I would say. BTW, my mathematical understanding is poor. Why is it 15!/8!?

NextPermute() and NextPermuteNum() modify the input array in place, and (to traverse all permutations) require that the input starts off sorted. So minimally adapting your previous code to use Algorithm::Loops would look (untested) something like this:

#!/usr/bin/env perl

use strict;
use warnings;
use Algorithm::Loops qw(NextPermuteNum);
use Data::Dump;
use feature    qw(say);

my @n = sort { $a <=> $b } ( 1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7, 8,
+ 11, 12, 13, 14, 14, 15 );

my $m3 = qr/(.)\1\1/;
my $m2 = qr/(.)\1/;

do {
    my $s = pack( "(A*)*", @n );
    if ( $s =~ /($m3)/ ) {
        say $1;
        sleep 1;
        goto PERMUTE;
    }
    if ( $s =~ /($m2)/ ) {
        goto PERMUTE;
        say $1;
        sleep 1;
    }
    say join " ", @n;
  PERMUTE:
    ; # empty statement to attach the label to
} while (NextPermuteNum( @n ));

__END__
[download]

As for the 15!/8! figure: imagine each of the 1s is a different colour, then there are 15! distinguishable ways to arrange the numbers. Take any one of those (valid solution or not) and it has 8 coloured 1s in some order; and each of the 8! ways to order those colours will appear once in what is otherwise the same arrangement of numbers.

>

    if ( $s =~ /($m2)/ ) {
        goto PERMUTE;
        say $1;
        sleep 1;
    }
[download]

Looks like dead code after the goto

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

Thanks, very nice. I wasn’t aware of the empty statement.

«The Crux of the Biscuit is the Apostrophe»

15! is the number of ways to sort 15 different elements.

But you have 8 identical 1 which would always create 8! duplicates for each solution by swapping 1s (well rather symmetries or congruence classes)

hence 15!/8!

update

WP has nice graphics visualizing it

https://en.wikipedia.org/wiki/Permutation#Permutations_of_multisets

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

> I count 7! = 5,040 solutions.

Of course you are right, what my my brain saw was that there is only one possible way to position the 1s.°

What I should better have shown is

(1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2)

which has only one solution

(1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)

and 15! divided by 7! is still a very big number.

> I don't see mention in Algorithm::Permute of how it handles duplicate elements,

Assuming worst case means it's not handling duplicates differently. Many hear just use shuffle which certainly doesn't care.

°) off by one permutation group ;)

karl@h3002993:~/src/perl$ time ./pmute.pl
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1

real    0m0,064s
user    0m0,044s
sys     0m0,005s
[download]

«The Crux of the Biscuit is the Apostrophe»

The 15 came from the OP,

But as I said

> If this doesn't convince you that try-and-error isn't a good idea, try adding even more 1s and 2s.

for instance ((1)x 51, (2) x 50)

==>

((101!) / (51!)) / (50!) = 1.99804427433e+29

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}