#!/usr/bin/perl
use warnings;
use strict;
use feature 'say';

my $sample = "A-E-H-L";

my @options = ( "A-B-F-G-H-K-M",
                "A-E-G-H-L",
                "A-C-E-G-H-J-L",
                "B-F-H-K",
                "A-B-F-G-H-K-L",
                "C-H"
              );

my @search_for = split /-/, $sample;
my $re = '(?:^|-)'
         . join('(?:-|-.*-)', @search_for)
         . '(?:-|$)';

say for grep /$re/, @options;
[download]

use warnings;
use strict;
use Data::Dumper;

my $sample = "AEHL";
my $mc = join '.*', split //, $sample;
my @options = (
             "ABFGHKM",    # idx = 0
             "AEGHL",      # idx = 1
             "ACEGHJL",    # idx = 2
             "BFHK",       # idx = 3
             "ABFGHKL",    # idx = 4
             "CH"          # idx = 5
);

my @matches;
for my $i (0 .. $#options) {
    push @matches, $i if $options[$i] =~ /$mc/;
}
print Dumper(\@matches);

__END__

$VAR1 = [
          1,
          2
        ];
[download]

use 5.010;
use strict;

my $sample = "A-E-H-L";
my @sample_arr = split '-', $sample;

my @options = ( "A-B-F-G-H-K-M",    # idx = 0
                "A-E-G-H-L",        # idx = 1
                "A-C-E-G-H-J-L",    # idx = 2
                "B-F-H-K",          # idx = 3
                "A-B-F-G-H-K-L",    # idx = 4  
                "C-H"               # idx = 5
               );

my @matches = 
    map  { join '-', @$_ }
    grep {
        my $ok = 1;
        for my $s (@sample_arr) { next if $s ~~ @$_; $ok = 0; last };
        $ok;
    }
    map  { [split '-' ] }
    @options;

say for @matches;
[download]

I don't like how you keep calling many things elements :)

#!/usr/bin/perl --
use strict; use warnings;
use List::AllUtils qw' indexes ';
use Data::Dump     qw' dd ';

my @options = (
"A-B-F-G-H-K-M",
"A-E-G-H-L",
"A-C-E-G-H-J-L",
"B-F-H-K",
"A-B-F-G-H-K-L",
"C-H"
);


#~ my @idx  = findem( "A-E-H-L", \@options );
my @idx  = findem( "A-E-H-L", @options );

dd \@options;
dd \@idx;
dd [ @options[@idx] ];

exit 0;
sub findem {
#~     my( $query, $options ) = @_;
    my  $query = shift;
    $query = join '.+', map { "\Q$_\E" } split '-', $query;
#~     return indexes { /$query/ } @$options;
    return indexes { /$query/ } @_;
}
__END__
[
  "A-B-F-G-H-K-M",
  "A-E-G-H-L",
  "A-C-E-G-H-J-L",
  "B-F-H-K",
  "A-B-F-G-H-K-L",
  "C-H",
]
[1, 2]
["A-E-G-H-L", "A-C-E-G-H-J-L"]
[download]

#!/usr/bin/perl -w
use strict;
use List::MoreUtils qw{uniq};

my $sample = "A-E-H-L";

my @options = ( "A-B-F-G-H-K-M",    # idx = 0
                "A-E-G-H-L",        # idx = 1
                "A-C-E-G-H-J-L",    # idx = 2
                "B-F-H-K",          # idx = 3
                "A-B-F-G-H-K-L",    # idx = 4  
                "C-H" ,             # idx = 5
                "A-E-H-L",          # idx = 6
                "H-E-A-L"           # idx = 7
              );
              
my @indicies = find_indexes (\@options, $sample);
print "sample $sample occurs in indicies: @indicies\n";
            
sub find_indexes 
{
   my ($aref, $template) = @_;
   my @indicies; 
   
   my @patterns = $template =~ /\w+/g;
   my $regex = join ("|", @patterns); # "OR"  is easy with regex
                                      # "AND" is hard
   
   my $index;
   foreach my $line (@$aref)
   {
      my (@matches) = $line =~ /$regex/g;
      push @indicies, $index if (uniq (@matches) >= @patterns);
      $index++; 
   }
   return @indicies;   
}

__END__
Prints: sample A-E-H-L occurs in indicies: 1 2 6 7
[download]

And yet another option:

use Modern::Perl;

my $sample = "A-E-H-L";

my @options = (
    "A-B-C-E-H-J-L",    # idx = 0
    "A-B-F-G-H-K-M",    # idx = 1
    "A-E-G-H-L",        # idx = 2
    "A-C-E-G-H-J-L",    # idx = 3
    "B-F-H-K",          # idx = 4
    "A-B-F-G-H-K-L",    # idx = 5
    "C-H"               # idx = 6
);

$sample =~ s/-/.*/g;

my @matches = grep $options[$_] =~ /$sample/, 0 .. $#options;

say for @matches;
[download]

Output:

0
2
3
[download]

Another approach, with a 'figure of merit':

>perl -wMstrict -le
"use Text::LevenshteinXS qw(distance);
 ;;;;
 my $sample = 'A-E-H-L';
 ;;
 my @options = qw(
   A-B-F-G-H-K-M  A-E-G-H-L  A-C-E-G-H-J-L
   B-F-H-K  A-B-F-G-H-K-L  C-H   A-F-H  H-A-F
   L-H-E-A  A  A-E  X-A-X  X-A-E-X  L  A-L  X-A-L-X
   W-X-Y-Z  Z  Y-Z
   );
 ;;;;
 my @interesting = $sample =~ m{ \w }xmsg;
 my $mask = join '', @interesting;
 my ($dull)    = map qr{[^$_]}xms, join '',   @interesting;
 my ($ordered) = map qr{$_?}xms,   join '? ', @interesting;
 ;;;;
 for my $option (@options) {
   (my $primary = $option) =~ s{ $dull }{}xmsg;
   my ($sequence) = $primary =~ m{ ($ordered)? }xms;
   my $dist = distance $mask, $sequence;
   my $percent = 100 * (1 - ($dist / length $mask));
   printf qq{%-16s -> %-6s -> %3.0f%% \n},
          qq{'$option'}, qq{'$sequence'}, $percent;
   }
"
'A-B-F-G-H-K-M'  -> 'AH'   ->  50%
'A-E-G-H-L'      -> 'AEHL' -> 100%
'A-C-E-G-H-J-L'  -> 'AEHL' -> 100%
'B-F-H-K'        -> 'H'    ->  25%
'A-B-F-G-H-K-L'  -> 'AHL'  ->  75%
'C-H'            -> 'H'    ->  25%
'A-F-H'          -> 'AH'   ->  50%
'H-A-F'          -> 'H'    ->  25%
'L-H-E-A'        -> 'L'    ->  25%
'A'              -> 'A'    ->  25%
'A-E'            -> 'AE'   ->  50%
'X-A-X'          -> 'A'    ->  25%
'X-A-E-X'        -> 'AE'   ->  50%
'L'              -> 'L'    ->  25%
'A-L'            -> 'AL'   ->  50%
'X-A-L-X'        -> 'AL'   ->  50%
'W-X-Y-Z'        -> ''     ->   0%
'Z'              -> ''     ->   0%
'Y-Z'            -> ''     ->   0%
[download]

Many thanks for all the options, folks.. I'll study them and will post the final usage..

I still have to get my head around regex.. after 15+ years of 'perling', I still have to get my head around regex.. *mutter*

Fanx! again for all your help....