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

my @words = qw(mamy dady bal foo bar ymamaa arabic);
my $regex = join '|', map scalar reverse, @words;
$regex    = qr/$regex/;
print "$_\n" for grep /$regex/, @words;
[download]

A small simplification:

my $regex = reverse join '|', @words;
[download]

Bill

The way I understood the OP was print out the word which when in reverse matches any other word. Your solution does the opposite. For example instead of printing bar since 'rab' matches in arabic, it prints arabic. ymamaa was also printed since 'mamy' in reverse matches it. My point is that arabic in reverse doesn't match anything.

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

my @words = qw(mamy dady bal foo bar xrabbit ymamaa arabic);
my $list = join ' ', @words;
foreach( @words ) {
    my $rev = reverse $_;
    print "$_\n" if $list =~ /$rev/;
}
__END__
mamy
bar
[download]

Your sorting technique sounds clever, but the sorting itself isn't constant, I suppose something like O(n*log(n)).

IMHO the fastest solution should be a trie, if it's worth the overhead depends on the number of words to search.

Another simpler approach is abusing the regex engine, because from 5.10 on it has internal trie optimization and is f*ckingly fast!

 
$str = join "\0",@wordlist,
@reverts = map { "\0" . reverse $_ } @wordlist;
$pattern = '(' . join('|',@reverts) . ')'  ;
@matches = ( $str =~ /$pattern/g );
[download]

thats untested pseudo-code I hope you get the idea! =)

UPDATE

now tested:

  DB<131> @wordlist=qw(mamy dady bara foo bic ymamaa arabic );
 => ("mamy", "dady", "bara", "foo", "bic", "ymamaa", "arabic")

  DB<132> $str = join "\0",@wordlist,
 => "mamy\0dady\0bara\0foo\0bic\0ymamaa\0arabic"

  DB<133> $pattern = join '|',map { "\0" . reverse $_ } @wordlist;
 => "\0ymam|\0ydad|\0arab|\0oof|\0cib|\0aamamy|\0cibara"

  DB<134> @matches = ( $str =~ /($pattern)/g );
 => ("\0ymam", "\0arab")
[download]

If you need to run this often and your word lists are fairly constant, store them in indexed database tables.

sqlite is a simple way to experiment, and databases are designed for that sort of job :)

Then you only have to create the reverse strings once when you populate the DB.

#!/usr/bin/perl -l

BEGIN {
    $|  = 1;
    $^W = 1;
}

use strict;
use warnings;
use List::MoreUtils 'any';

my($string) = q(mamy dady bal foo bar);

my(@allwords) = split(" ", $string, 0);
my($revwords) = join(" ", reverse(@allwords));
my(@strings_list) = scalar reverse $revwords;

my $match = any( 
    sub { /^ymam*/}, @strings_list,
);

print "match" if $match;
print "no match" unless $match;
[download]

my($string) = q(mamy dady bal foo bar);

Your wordlist doesn't contain anything that will match what the OP requested.

my(@strings_list) = scalar reverse $revwords;

This will put all the words into the first element of @strings_list so there is no need to use any(). Would have been much simpler to just reverse the original string and then split it into an array.

my $rev = reverse $string;
my @strings = split ' ', $rev;
print join ',',@strings;
[download]

sub { /^ymam*/}, @strings_list,

^ymam* will match 0 or more 'm's after yma which is not going to work. The * is not needed here.