/^(?=.*a)(?=.*b)(?=.*c).*d/
   or die;
[download]

If you want to know the order in which they came,

my %order;
@order{qw( a b c d )} =
      map length, /^(?=(.*?)a)(?=(.*?)b)(?=(.*?)c)(.*?)d/
   or die;

my @ordered = sort { $order{$a} <=> $order{$b} } keys %order;
[download]

This is probably slow for long strings.

Update: Actually, no need for a hash.

my @order = map length, /^(?=(.*?)a)(?=(.*?)b)(?=(.*?)c)(.*?)d/
   or die;

my @ordered = ( qw( a b c d ) )[
   sort { $order[$a] <=> $order[$b] } 0..$#order
];
[download]

Update: Back to the practical, using multiple regexp and saving @- should be much faster. Especially if scanning for constants.

my @unordered = qw( a b c d );

my @order;
for my $s (@unordered) {
   push @order, /\Q$s/ ? $-[0] : die;
}

my @ordered = @unordered[
   sort { $order[$a] <=> $order[$b] } 0..$#order
];
[download]

Another way to do it:

my %order;
/(?=.*(a))(?=.*(b))(?=.*(c))/ and @order{ qw/a b c/ } = @-[ 1 .. $#- ]
+;
[download]

This code does not work:

/^(?=.*a)(?=.*b)(?=.*c).*d/
[download]

For example, when used in the code below nothing s returned.

echo bacd| perl -ne '/^(?=.*a)(?=.*b)(?=.*c).*d/; print "$1 $2 $3\n";'
[download]

That is because there are no capturing parentheses in your regular expression and so $1, $2 and $3 are not affected and thus contain nothing.

>echo 1b22a3d3ccccccccccccccc | 
perl -nle"/a/&&/b/&&/c/&&/d/ and print 'Matched: ', pack '(a1)4', m[([
+abcd])]g"
Matched: badc
[download]

This is what I came up with.

my $rx = qr/
    ([abcd])           # a, b, c, or d -- stored in \1
    .*                 # well, whatever
    (?!\1)             # the next character can't be \1
    ([abcd])           # a, b, c, or d -- stored in \2
    .*                 # y'know, stuff
    (?!\1|\2)          # next thing not \1 or \2
    ([abcd])           # a, b, c, or d -- stored in \3
    .*
    (?!\1|\2|\3)       # next thing not \1, \2, or \3
    [abcd]             # you get the idea
    /x;
[download]

I have a feeling there's still an easier way, but that's not too bad. Here is some testing.

Update: See below, ikegami has the better way.

my $test_string="1b22a3d3c";

my @ordered;
push(@ordered, $1) while $test_string =~ /([abcd])/cg;

pos($test_string) = 0; # reset m//cg offset
[download]

my %seen;
my @order = grep { !$seen{$_}++ } $test_string =~ /([abcd])/g;
[download]

$& imposes a needless slowdown on all regexp in your process that aren't already slowed down by captures. Use a capture instead.

Your solution assumes none of the four patterns will match twice.

TMTOW to find the order:

my $test = "1b22a3d3cccccccba866.afgg";

(my $ordered = $test) =~ tr/abcd//cd;

print $ordered, "\n";   # badcccccccbaa
[download]

Indeed, getting rid of the clutter first, and then remove all but the first instance of each letter:

  sub reduc {
    my ($s) = @_ ;

    $s =~ tr/abcd//cd ;
    1 while $s =~ s/(.).*?\K\1+//g ;

    return $s ;
  } ;

  print reduc('1b22a7b3d3ccaacccbcccacccddcceqcc11oabepd'), "\n" ;
                     # badc
  print reduc('1b22w7b3d3ccsqcccbccc2cccddcceqcc11o9bepd'), "\n" ;
                     # bdc
[download]

I imagine a more cunning monk can improve the reduction step -- though the amount of work it does obviously depends on how many repeated letters need to be removed.

The match global will just go through the input string once. The while() loop iterates over a list that the match global expression produced. I'm not sure how "smart" regex is with /o option (compile regex once). Having a join may be slower than I think, but my testing so far with Perl 5.10 says that regex is way smarter (and faster) than it used to be! You can do the join other ways or declare other variables. One main point about regex is that picking from a set [xyz] is a lot faster than /x/|/y/|/z|.

Map and sort are pretty "heavy weight" critters. A hash table especially with a small number of keys is very efficient. A Perl hash gets created by default with 8 hash "buckets". Don't be afraid to use a hash. This code is verbose, but is straightforward and will run quickly.

#!/usr/bin/perl -w
use strict;

my $str = "1b22a3d3cab";
my @letters = qw (a b 2 c d);
my @order_found =();
my %seen =();

#UPDATE: don't need the $found variable, oops!
#while (my $found = $str =~ m/([join("",@letters)])/go)
#should have been:
while ($str =~ m/([join("",@letters)])/go)
{
   push (@order_found, $1) unless $seen{$1};
   $seen{$1}++;
}
if (keys %seen != @letters)
{
   print "not all letters found\n";
}
else
{
   print @order_found, "\n"; # prints b2adc
}
[download]

echo 1b22a3d3 | egrep -o 'a|b|c|d'
b
a
d
[download]

egrep finds all the cases because it has greedy alternation(the subject of this Seekers...). -o simply has egrep print out the matches it does find. A complete non-perl solution could be something like

echo 1b22cc333a | egrep -o 'a|b|c' | sort -u | wc -l
[download]

This will simply return 3. If I want 3 chars in any order and this command returns 3 than I had a successful match of all 3 in any order!