Wow, I didn't know the empty capture and backreference trick, nice!

I also didn't know the trick where you put the pattern on the left side of the =~ operator and still get results somehow ;-)

I suspect there's some unexpected behavior in the backtracking?

use v5.20;
use Data::Dump "pp";

my @z = glob('{a,b,c}'x6);
my $z = '(?:a()|a()|b()|b()|c()|c()){6}\1\2\3\4\5\6';

for my $j (@z)
{
    $j =~ $z and say pp {$j => \@- };
}
[download]

...
{ acbcaa => [0, 6, 6, 3, 3, 4, 4] }
{ acbcab => [0, 5, 5, 6, 6, 4, 4] }
{ acbcac => [0, 5, 5, 3, 3, 6, 6] }
{ acbcba => [0, 6, 6, 5, 5, 4, 4] }
{ acbcca => [0, 6, 6, 3, 3, 5, 5] }
{ accaab => [0, 5, 5, 6, 6, 3, 3] }
{ accaba => [0, 6, 6, 5, 5, 3, 3] }
...
{ cccbab => [0, 5, 5, 6, 6, 3, 3] }
{ cccbac => [0, 5, 5, 4, 4, 6, 6] }
{ cccbba => [0, 6, 6, 5, 5, 3, 3] }
{ cccbca => [0, 6, 6, 4, 4, 5, 5] }
{ ccccab => [0, 5, 5, 6, 6, 4, 4] }
{ ccccba => [0, 6, 6, 5, 5, 4, 4] }
[download]

Is there some other magic to DWIM?

my @y = glob('{a,b,c}'x6);
my $y = '(?:(?!\1)a()|(?!\2)a()|(?!\3)b()|(?!\4)b()|(?!\5)c()|(?!\6)c(
+)){6}\1\2\3\4\5\6';

for my $j (@y)
{
    $j =~ $y and say $j;
}
[download]

aabbcc
aabcbc
aabccb
aacbbc
aacbcb
aaccbb
ababcc
abacbc
abaccb
...
ccbaab
ccbaba
ccbbaa
[download]

Edit: this also works actually (without \1\2\3\4\5\6 at the end):

# edit reformatted as a multiline regex for clarity
my $y = qr/(?:
               (?!\1) a ()
             | (?!\2) a ()
             | (?!\3) b ()
             | (?!\4) b ()
             | (?!\5) c ()
             | (?!\6) c ()
           ){6}
         /x;
[download]

I also didn't know the trick where you put the pattern on the left side of the =~ operator and still get results somehow ;-

Ugh. Major brain fart. And it still works!

The (?!\1)xxx(() element is great, thanks.

-QM
--
Quantum Mechanics: The dreams stuff is made of

#!/usr/bin/perl -l

# https://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographi
+c_order

use strict;
use warnings;

$_ = 'aabbcc';

1 while print,
  s/.*\K # find the last
  (.) # char such that
  (.*) # there is a later (latest)
  (.)(??{$1 ge $3 and '(*F)'}) # char greater than it
  (.*) # and get rest
  # swap those two chars ( $1 & $3 )
  # then reverse everything after the first swapped char
  / $3 . reverse $2.$1.$4 /xe
[download]

OK. That's probably pretty fast too.

But I think you misunderstood? I can generate them, but I wanted to _match_ any permutation of a given string.

Update: Oh, I had the =~ backwards, and that led you astray.

(Not shown in the OP is a programmatic way to generate the regex solution based on the input string, but that was left out for clarity.)

-QM
--
Quantum Mechanics: The dreams stuff is made of

Like so ?

#!/usr/bin/perl -l

# https://perlmonks.org/?node_id=1226058

use strict;
use warnings;

$_ = 'aabbcc';

my $len = length;
my $inner = join ',', split //, tr///csr;
my $glob = "{$inner}" x $len;

my $re = "^(?=.{$len}\$)";
while( /./ )
  {
  my $count = s/$&//g;
  $re .= "(?=(?:.*$&){$count})";
  }

$_ =~ $re and print for glob $glob;
[download]

Outputs the 90 valid permutations.

#!/usr/bin/perl -l

# https://perlmonks.org/?node_id=1226058

use strict;
use warnings;

$_ = 'abc';

/(.).*\1/ or print for glob "{@{[ s/\B/,/gr ]}}" x length;
[download]

#!/usr/bin/perl
    
    # https://www.perlmonks.org/?node_id=1226058
    
    use warnings;
    use re 'eval';
    
    $\ = $/;
    
    for my $tc (
        [ 'abc', 1 ],
        [ 'abc', 2 ],
        [ 'abc', 3 ],
        ){
        
        my( $string, $times ) = @{ $tc };
        
        $_ = ( ',' . reverse $string ) x ( $times * length $string );
        
        print;
        
        my @permutations;
        
        my %occ;
        
        my $re = 
            ', \w*(\w)\w* 
            (?:
                (?{ $occ{ $^N } ++ })
                |
                (?{ $occ{ $^N } -- }) 
                (*F)
            )
            ' x ( $times * length $string );
            ;
        
        /
            $re
            $
            (??{ ( grep $_ != $times, values %occ ) ? '(*F)' : '' })
            (?{ push @permutations, 
                join '', 
                grep length, 
                $1, $2, $3, 
                $4, $5, $6, 
                $7, $8, $9, 
                })
            (*F)
        /x;

        print for 
            @permutations, 
            ~~ @permutations
            ;
        
        }
[download]

        my $re = 
            ', \w*(\w)\w* 
            (?:
                (?{ $occ{ $^N } ++ })
                |
                (?{ $occ{ $^N } -- }) 
                (*F)
            )
            (??{ ( grep $_ > $times, values %occ ) ? "(*F)" : "" })
            ' x ( $times * length $string );
            ;
[download]

I had the regex terms backwards. And the glob was just for testing purposes -- I wasn't trying to generate permutations, but to match one permutation of a known string.

-QM
--
Quantum Mechanics: The dreams stuff is made of