m/
    (?=^[^a]*a[^a]*$) ## One a and no other a's
    (?=^[^b]*b[^b]*$) ## One b and no other b's
    (?=^[^c]*c[^c]*$) ## One c and no other c's
    ^.{3}$            ## Exactly three chars
/x and print "$_: matched" for 'aaa'..'ccc';;

abc: matched
acb: matched
bac: matched
bca: matched
cab: matched
cba: matched
[download]

This looks like overkill.

If a string is required to contain all of an "a", a "b" and a "c" and its length is limited to 3, then it can only contain one of each.

So this ought to suffice:

/^(?=.*a)(?=.*b)(?=.*c).{3}\z/
[download]

Of course, yours is the way to go if the length is not limited to 3.

Agreed, for the simple case, but it trivially extends to any number of unqiue characters within strings of a specified length. (Think crossword, hangman etc. :)

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

use Test::More;

my @match_wanted = qw( abc bca cab cba bac acb );
my @match_unwanted = qw( aab abbc acc );
sub match {
    my $s = shift;
    return ( ($s =~ /(?:[abc].*){3}/) && ! ($s =~ /([abc]).*\1/) );
}

plan 'tests' => ( scalar @match_wanted + scalar @match_unwanted );

ok( match( $_ ), "matches '$_'" )          for @match_wanted;
ok( ! match( $_ ), "does not match '$_'" ) for @match_unwanted;
[download]

I was going to create a nasty little test using length, tr///s, m//, and a couple of evals, but I just couldn't bring myself to complete it. Instead, I reached for CPAN and Math::Combinatorics.

use strict;
use warnings;

use Math::Combinatorics qw( permute );
use Test::More;

my @match_wanted = qw( abc bca cab cba bac acb );
my @match_unwanted = qw( aab abbc acc );
my @charset = qw( a b c );

my %valid = map { join( '', @$_ ) => 1 } permute( @charset );

sub match
{
    my $s = shift;
    return( exists $valid{$s} ? 1 : 0 );
}

plan 'tests' => ( scalar @match_wanted + scalar @match_unwanted );

ok(   match( $_ ), "matches '$_'" )        for @match_wanted;
ok( ! match( $_ ), "does not match '$_'" ) for @match_unwanted;
[download]

1..9
ok 1 - matches 'abc'
ok 2 - matches 'bca'
ok 3 - matches 'cab'
ok 4 - matches 'cba'
ok 5 - matches 'bac'
ok 6 - matches 'acb'
ok 7 - does not match 'aab'
ok 8 - does not match 'abbc'
ok 9 - does not match 'acc'
[download]

Thanks and ++ to kyle for the framework.

It fails when you add adbc to @match_wanted. Easily fixed:

use Math::Combinatorics qw( permute );

my @charset = qw( a b c );
my %valid = map { join( '', @$_ ) => 1 } permute( @charset );
my ($others) = map qr/[^$_]/, join '', map quotemeta, @charset;

sub match {
   my $s = shift;
   $s =~ s/$others//g;
   return $valid{$s};
}
[download]

or

use Math::Combinatorics qw( permute );

my @charset = qw( a b c );
my ($valid) = map qr/^(?:$_)\z/, join '|', map quotemeta, map join('',
+ @$_), permute @charset;
my ($others) = map qr/[^$_]/, join '', map quotemeta, @charset;

sub match {
   my $s = shift;
   $s =~ s/$others//g;
   return $s =~ $valid;
}
[download]

or

use Math::Combinatorics qw( permute );
use Regexp::List qw( );

my @charset = qw( a b c );
my ($valid) = map qr/^$_\z/, Regexp::List->new()->list2re(permute(@cha
+rset));
my ($others) = map qr/[^$_]/, join '', map quotemeta, @charset;

sub match {
   my $s = shift;
   $s =~ s/$others//g;
   return $s =~ $valid;
}
[download]

True. The OP's spec wasn't clear as to whether or not the strings could contain other characters (or were limited to only those in the specified character set), or if a, b, and c were really characters and not stand-ins for longer strings. I went with Occam's razor and took the OP literally. (Update: Since the list of invalid strings contained only a, b, and c; I assumed if other characters were possible there would be an example of it in the invalid list. ikegami is right, though - this was probably more of an assumption than I first thought.)

This approach could also be problematic if the character set is large and/or if the wanted strings were significantly longer, since the number of permutations would rapidly increase. In that case, a RE-based approach may be better.

Nonetheless, thanks for providing a more robust solution.

use strict;
use warnings;
my $str="";
for $str('aaa'..'ccc')
{
    
    if($str=~m/^[abc]{3}$/)
    {
        if($str!~m/(.*a.*a)/)
        {
            if($str!~m/(.*b.*b)/)
            {
                if($str!~m/(.*c.*c)/)
                {
                    print "\' $str \' is a Match\n";
                }
                else
                {
                    print "The string $str contains duplicated 'c'\n";
                }
            }
            else
            {
                print "The string $str contains duplicated 'b'\n";
            }
        }
        else
        {
            print "The string $str contains duplicated 'a'\n";
        }
    }
    else
    {
        print "Either the string \'$str\' contains a character not bel
+onging to the class [abc] or is more than 3 characters\n";
    }
}
[download]

use strict;
use warnings;
my $str="";
for $str('aaa'..'ccc')
{
    if($str=~m/^[abc]{3}$/ && $str!~m/(.*a.*a)/ && $str !~ m/(.*b.*b)/
+ && $str!~ m/(.*c.*c)/)
    {
        print "\' $str \' is a Match\n";
    }
    
}
[download]

Update: Nicely re-worked. Previously it didn't work but now it does. Nice job. I'm leaving my initial response here anyway, but it's no longer pertinent.

That doesn't work because it incorrectly matches invalid strings.

If you change

my $str="abc";
[download]

to

my $str="aaa";
[download]

You'll still get a match even though that's not supposed to be a valid string. You'll have to go a bit more complicated in the regex to exclude the false hits.
Update: I was missing my 2nd code snip.
--
I used to drive a Heisenbergmobile, but every time I looked at the speedometer, I got lost.

Note: Please ignore the code listed here as it is buggy inside the while loop. Sorry for the noise.

First thing I thought of after reading OP was Algorithm::Permute module. (That led me to search for other permutations related modules. Now, I am more in favor of Math::Combinatorics and Algorithm::Combinatorics.)

I did not spend much time on thinking of a regex as that would have been hairy, though I liked BrowserUk's regex (which could get unwieldy if needs to be modified).

Below is the version which checks for overlapping strings ("abcXa" is ok, "abca" not). As it is, the program below uses &A::C::permutations. Feel free to exercise any of the other two modules. Basically, the big idea is ...

sub find_once
{
  my ( $str , ... ) = @_ ;
  ...
  my ( $pos , $once ) = ( 0 ) x2;
  while ( my $p = get_permutation_string() )
  {
    last if $once > 1;
    ( $pos = index $str , $p , $pos ) >= 0 and $once++ ;
  }
  return $once == 1;
}
[download]

Update: I just noticed that "once" specification is in the title, but missing from the body.

The assignment of $pos has a bug in ...

    ( $pos = index $str , $p , $pos ) >= 0 and $once++ ;
[download]

... which caused index() to some times start from -1, not ot mention $pos was not being reset to 0. Please ignore my previous reply.

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

my @testdata = qw (abc cba cab bac bba cbc bbc abcdefg 0a2c3bc);

foreach (@testdata) {
    my $test = join '', sort split //, lc $_;
    $test =~ /[^a]*abc(?!c)[^c]*/ ? print "Matched $_\n" : print "Didn
+'t match $_\n";
}
[download]

Interesting approach for which ++.

.oO, however, that this allows cases such as when @testdata contains aabc. IMO that's NOT quite¹ (strictly) prohibited by the (very loose) specs from OP:

Can anybody help to have a regular expression that checks that a,b and c occur in a string in any order.
SO, the valid strings are abc, bca, cab, cba, bac, acb...
Invalid strings are aab, abbc, acc etc.

BUT the presence of abbc in the list of invalid strings suggests that isha may want to requires that each permitted letter occur only once. (Others may well infer differently. As noted, I consider the spec to be imprecise... as is, ISTM, the general case when specs are written by example.)

^1. because, in this case, while the initial "a" is doubled the $test does include an instance of each acceptable character; in other words, ISTM that aabc is NOT - strictly - prohibited in the sample of invalid strings, aab because aab can be read as prohibiting only an incomplete set of the chars a, b and c, while the invalid string abbc does not strictly prohibit having the lead character doubled. Am I being pedantic or fuzzy-brained?

I do find my own observations to fall short of precision+clarity. Maybe it's too early in the AM... :-)

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

my @testdata = qw (abc aabc cba cab bac bba cbc bbc abcdefg 0a2c3bc);

foreach (@testdata) {
    my $test = join '', sort split //, lc $_;
    $test =~ /[^a]*abc(?!c)[^c]*/ ? print "Matched $_\n" : print "Didn
+'t match $_\n";
[download]

Output:
Matched abc
Matched aabc     <=
Matched cba
....

Update: added the missing close-paren at the end of para 3

my $chars = "abc";

foreach (qw/abc bca cab cba bac acb aab abbc acc/) {

  my %seen;
  my $pat = $_;

  $pat =~ s/([\Q$chars\E])/++$seen{$1}/gex;

  if ((grep {$_ == 1} values %seen) == length($chars)) {
    print "$_ matches\n";
  }
  else{
    print "$_ doesn't match\n";
  }
}
[download]

print "ok!\n" unless /([abc]).*\1/;
[download]

if you want to declare "abcz" wrong too, just:

print "ok!\n" unless /(([abc]).*\2|[^abc])/;
[download]

Oha

my @letters = qw(abc cba cab bab blab);
for (@letters) {
    if(join('', sort split //, $_) eq "abc") {print "$_ matched\n"}
    else {print "$_ didn't match\n"}
}
[download]

That is simple!

A problem might arise if the desired letters could be part of a bigger string. Lacking any comments by isha on the specification :( so far, your solution is just as good.

Any chance of homework here? Probably not, looking at rest of OP history, but a good HW question.

Does you need to use a regex?

#!/usr/bin/perl
use warnings;
use strict;

my @maybe = qw( abc bca cab cba bac acb aab abbc acc );

print "$_ ", ok($_) ? 'good' : 'no good', "\n" for @maybe;

sub ok{ 
    return y/a// > 1 ? 0 : y/b// > 1 ? 0 : y/c// > 1 ? 0 : 1;
}
[download]