use strict;
use warnings;

my $string = "Understand, this string really contains all of the vowel
+s.";

my $count;
$string =~ /$_/i and $count++ for qw/ a e i o u y /;
print "They're all there!\n" if $count == 6;
[download]

The meat and potatos of this solution is in the $string =~ /$_/i and... line. Start with the "for qw/ a e i o u y /" part. ...That creates a little loop that distributes each vowel, one by one, to $_. Next, the string is pattern matched with the contents of $_ (each vowel, one by one). The logical short circuit operator ("and") ensures that $count is only incremented when a match occurs. So each time through the loop you're testing one vowel to see if it's found in the string, and incrementing $count if the vowel exists. Then you loop back, and check for the existance of the next vowel in the list.

The hardest part is the logical short circuit "and". Just think of it like this... for 'and' to be true, both the left hand side and the right hand side must be true. If the left hand side isn't true (ie, if there's no match), there's no point in even evaluating the right hand side, since the 'and' operator already knows that it's going to fail (return false). That means that $count++ only gets evaluated if the match succeeds, and thus, $count only gets incremented if the match is successful.

Hope this helps...

Indeed, this is the approach I had in mind. My idea was to look for the least frequently occurring vowel first, up to the most frequently occurring vowel last. That way candidates could be excluded as quickly as possible. The following one-liner, when run on /usr/share/dict/words

perl -nle '++$f{lc $_} for split //; END{ print "$_\t$f{$_}" for sort keys %f}'

... allows me to determine that the order is u o a i e. My test, relying on the benefit of lazy evaluation, would be:

   # assuming target word is in $_
   my $all_there = /u/ and /o/ and /a/ and /i/ and /e/;
[download]

Disclaimer about case sensitivity: you might want to $_ = lc $_ beforehand, or add the i modifier to each RE.

I find this code is very elegant: clear and straightforward, and above all, the person coming along behind you will understand immediately what is going in without requiring major regexp-fu.

use strict;
use warnings;

my $word = "alighthousa";
my $found;

if (($found = ( keys %{{map { $_ => 1 } ($word =~ m/([aeiou])/g) }} ))
+ == 5) {
    print "Found all 5 vowels\n";
} else {
    print "Found only $found vowels\n";
}
[download]

($word =~ m/([aeiou])/g)
   # returns a list of all vowels found in $word

map { $_ => 1 } ($word =~ m/([aeiou])/g)
   # builds a list for initializing a hash

{ map { $_ => 1 } ($word =~ m/([aeiou])/g) }
   # a reference to an anonymous hash initialized with the list

keys %{ { map { $_ => 1 } ($word =~ m/([aeiou])/g) } }
   # return keys of the dereferenced anonymous hash
   # the keys in a hash are unique, this effectively
   # eliminates duplicates, and gives a list of unique
   # vowels found in the string

$found = ( keys ... )
   # this assigns the number of unique vowels found into $found
[download]

Very nice approach indeed. Just to touch up on including uppercase vowels:

$_ = 'A Lighthouse';

if (5 == keys %{{map {lc $_ => undef} m/([aeiou])/ig}}) {
  print "Found at least one of each vowel.\n";
}
else {
  print "Not all vowels were found.\n";
}
[download]

That being said, though, this:

/(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)/i
[download]

To do this with a true regular expression (and hence without lookahead assertions), you'd want to do it by essentially creating a list of all 5-factorial permutations of aeiou, and, over these permutations like so (written out kind of long-hand so that the idea should be transparent):

my @regex_pieces = ();
foreach my $permutation (@permutations) {
    my @vowels = split //, $permutation;
    push @regex_pieces, join(".*", @vowels); 
}
my $regex = qr/@{[join("|", @regex_pieces)]}/i;
[download]

------------
:Wq
Not an editor command: Wq
[download]

Without having benchmarked it, I have a feeling that your lookahead regex will fail faster if it's anchored:

/^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)/i
[download]

Yes, the look for a string containing this and that idiom ...


/(?=.*?this)(?=.*?that)/
[download]


Very nice.

/(?{local %_; @_{qw {a e i o u}} = ();})
 (?:(.)(?{delete $_{$1}}))*
 (?(?{keys %_})(?!)|)/x;
[download]

Abigail

If you like obfus, try a.pl:

#!perl -p
!(y&aA&&&&y&eE&&&&y&iI&&&&y&oO&&&&y&uU&&)&&y&&&cd
[download]

and b.pl:

#!perl -p
$_ x=!!eval"1@{[<&&y&{aA,eE,iI,oO,uU}&&>]}"
[download]

When run with, for example:

perl a.pl /usr/share/dict/words
[download]

they both seem to work ok. BTW, can anyone recognize what inspired these solutions?

/-\