You are *so* the monk!

The regex works because if the variable ength of the space (0-full line) before matching the backreference. And lookaheads can be variable length.

This is essentially the converse approach to what I was thinking trying to solve the problem. Someday...

while (<DATA>) {
   chomp;
   if ( /^(?:([smtwhfa])(?!.*\1))*$/ ) {
      print "$_ : OK\n";
   } else {
      print "$_ : Not OK\n";
   }
}

__DATA__
swma
smqa
smsa
fhtm
ttma
t2ms

__END__
swma : OK
smqa : Not OK
smsa : Not OK
fhtm : OK
ttma : Not OK
t2ms : Not OK
[download]

So let's see if I understand this and please correct me if I'm wrong.

The ?: means that the parens are just for grouping and will load any matches into $1, $2, etc.
Then the character class in parens
and then the lookahead...
?! means that it is a negative lookahead
.* means any character 0 or more times (very greedy)
\1 is related to the character matched from the character class
It's the .* that is throwing me off. To me, that looks like it would match a single character repeated any number of times but not separated duplicate characters. I just don't understand it ... yet. I will keep looking.

s/will load/will not load/, right?

The .* is saying there can be any number of characters in the string between the first match (the character class) and the backreference (\1) match, from zero (two characters next to each other) on up...

Say out first match was 'a', then 'a' is also referred to in \1. Then we have a.*a: aa,  a.a,  a..a,  a...a,  a....a, etc. And its a negative lookahead, so if any one of those combinations matches, the regex will fail.

--
Allolex

perl -MYAPE::Regex::Explain -e 'print YAPE::Regex::Explain->new(q/^(?:
+([smtwhfa])(?!.*\1))*$/)->explain'
The regular expression:

(?-imsx:^(?:([smtwhfa])(?!.*\1))*$)

matches as follows:

NODE                     EXPLANATION
----------------------------------------------------------------------
(?-imsx:                 group, but do not capture (case-sensitive)
                         (with ^ and $ matching normally) (with . not
                         matching \n) (matching whitespace and #
                         normally):
----------------------------------------------------------------------
  ^                        the beginning of the string
----------------------------------------------------------------------
  (?:                      group, but do not capture (0 or more times
                           (matching the most amount possible)):
----------------------------------------------------------------------
    (                        group and capture to \1:
----------------------------------------------------------------------
      [smtwhfa]                any character of: 's', 'm', 't', 'w',
                               'h', 'f', 'a'
----------------------------------------------------------------------
    )                        end of \1
----------------------------------------------------------------------
    (?!                      look ahead to see if there is not:
----------------------------------------------------------------------
      .*                       any character except \n (0 or more
                               times (matching the most amount
                               possible))
----------------------------------------------------------------------
      \1                       what was matched by capture \1
----------------------------------------------------------------------
    )                        end of look-ahead
----------------------------------------------------------------------
  )*                       end of grouping
----------------------------------------------------------------------
  $                        before an optional \n, and the end of the
                           string
----------------------------------------------------------------------
)                        end of grouping
----------------------------------------------------------------------
[download]

Wow, I wish I had known about YAPE::Regex::Explain a long time ago. This will provide a much greater understanding of regexes and faster troubleshooting. All hail japhy!!

Again, another genius here. The regex you supplied also works perfectly. As far as efficiency goes, I'm not sure it will matter much in this situation. I am interested though in how you would go about testing speed and efficiency for something like this. I'm sure it's not as simple ( and unreliable) as loading up 1000's of strings and timing execution with a watch.

YAPE::Regex is cool man!

#!/your/perl/here

use warnings;
use strict;

while (<DATA>)
{
    chomp;
    my $sort = join '', sort split '';
    ( ( $sort =~ /^[afhmstw]+$/ ) # only these chars
      and
      ( $sort !~ /([afhmstw])\1/ ) ) # no repeats
    ? print "<$_> OK\n"
    : print "<$_> Not OK\n";
}

__DATA__
smsa
smta
stmwhas

BADsmtaEXAMPLE

__END__
<smsa> Not OK
<smta> OK
<stmwhas> Not OK
<> Not OK
<BADsmtaEXAMPLE> Not OK
[download]