#!/usr/bin/perl
use strict;
use warnings;
use Test::More qw(no_plan);
my @a = ('a','r','z','x');
my $re = join '', map { "(?=.*?$_)" } @a;

like   'xzarfoobar', qr{$re};
unlike  'zarfoobar', qr{$re};
[download]

(Update: formulated as test script)

Safer with just a few extra chars: map { "(?=.*?\Q$_\E)" }

.. or my favorite formulation:

my $re = join '', map { "(?=.*?$_)" } map { quotemeta } @a;
[download]

The usual technique for testing "foundness" is to use a hash. Consider:

use strict;
use warnings;

my @a = ('a','r','z','x');
my $match = join '|', @a;
my $mystring = 'areqrtyzx';
my %found;

$found{$_}++ for grep /$match/, split '', $mystring;

print "No match" unless @a == keys %found;
[download]

which also notices how many times each searched for item is found, although that may not be important depending on your application.

sub has_all {
  my $text = shift;
  for my $c ('a', 'r', 'z', 'x') {
    return 0 unless $text =~ m/$c/;
  }
  1;
}
[download]

use Test::Simple 'no_plan';
use strict;
use constant DEBUG=> 1;

sub debug;
sub debug { 
   print STDERR (+shift) ."\n" if DEBUG;
}

my $string = 'This is a great string here. Really. It even has an @ ch
+ar.';



# no..
for my $chars( qw(12345 %!$*& ^ 9 x) )
   # interestingly fails for ^
   ok( ! string_has_chars($string => $chars ) , " we dont have '$chars
+'");
}

# yes..
for my $chars( qw(even has an @ char .Really) ){
   ok( string_has_chars($string => $chars ) , " we do have '$chars'");
}







sub string_has_chars {
   my $string = shift;
   my %char;

   ARG: for my $element (@_){
      defined $element or next;
      if ( ref $element and ref $element eq 'ARRAY' ){
         $element="@$element";         
      }

      for my $char ( split('',$element) ){
         $char{$char}=0;
      }
   }

   my @chars = sort keys %char;
   debug("chars are [@chars]");

   for my $c (@chars){
      $string=~/$c/ or return;
   }

   return 1;
}
[download]

leo@dali$ clear; perl /tmp/test.pl 

chars are 1 2 3 4 5
ok 1 -  we dont have '12345'
chars are ! $ % & *
ok 2 -  we dont have '%!$*&'
chars are ^
not ok 3 -  we dont have '^'
#   Failed test ' we dont have '^''
#   at /tmp/test.pl line 22.
chars are 9
ok 4 -  we dont have '9'
chars are x
ok 5 -  we dont have 'x'
chars are e n v
ok 6 -  we do have 'even'
chars are a h s
ok 7 -  we do have 'has'
chars are a n
ok 8 -  we do have 'an'
chars are @
ok 9 -  we do have '@'
chars are a c h r
ok 10 -  we do have 'char'
chars are . R a e l y
ok 11 -  we do have '.Really'
1..11
# Looks like you failed 1 test of 11.

The only non-looping/non-map solution I could come up with is the code-assertion counting technique:

 ...
 #  the array positions of  the chars are viewed as 'bits'
 #  Bits:   1 1 1 1    ==> decimal 15
 my @a = qw'a r z x';
 use re 'eval';
 our $t = 1;     # $t will be modified within the regex

 # build the regex, essentially: /a(?{...})| b(?{...}) | c(?{...}) ...
+ /g
 my  $p = 0;     # position count variable during initialization
 my  $expr = join'|', map quotemeta($_)."(?{\$t|=".(1<<$p++)."})", @a;
                
 
 # initialize before run
 $t = 0; 
 my $mystring = 'areqrtyz';
 # evaluate the regex in list context () and 
 # look after the result in $t (comma operator =>, )
 print 'no match' if () = $mystring =~ /$expr/g, $t != 15;
 ...
[download]

Regards

mwa

print(
 (length(join('',map { $mystring =~ /$_/ ? '' : 'X' } @a)) 
 ?   'not ' 
 :   ''),
 "all letters occur\n");
[download]

index($mystring,$_) < 0 ? 'X' : ''
[download]