It seems like that is actually a bit unwieldy. Another try:

#!/usr/bin/env perl

use strict;
use warnings;
use Algorithm::Permute;
use Data::Dump;
use List::Util qw(shuffle);
use feature    qw(say);

my @n = shuffle( 1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7, 8, 11, 12, 13,
+ 14, 14, 15 );
my $p = Algorithm::Permute->new( \@n, 20 );

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

PERMUTE: {
    my @r = $p->next;
    dd \@r;
    my $s = pack( "(A*)*", @r );
    if ( $s =~ /($m3)/ ) {
    # say $1;
    # sleep 1;
        goto PERMUTE;
    }
    if ( $s =~ /($m2)/ ) {
        # say $1;
        # sleep 1; 
        goto PERMUTE;
    }
    say join " ", @r;
}

__END__
[download]

Minor update: Fixed dead code.

A good algorithm must not fail on edge cases.

One can easily find many where there are no or only few solutions.

Now try blindly guessing permutations, till you find the only possible solution for ( (1)x8 , 2..8 )

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

Do you mean like this (1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8)? Because then I actually get more results quickly. However, something is not quite right with the regular expressions. I must be swapping $m3 with $m2. This is a bit of a mystery to me at the moment.

«The Crux of the Biscuit is the Apostrophe»