It would be cool to reuse this regexp search for the forward/backward test, but I don't know how resp. if this is even possible.

If you drop your "without reverse" requirement, you can use it in the regex!

/(^.*\z)(?(?{ $+ eq reverse $+ })|(?!))/s
[download]

/
    (                            # capture group
        ^                        # match begin of string
        .*                       # match everything
        \z                       # match end of string
    )
    (?                           # if
        (?{ $+ eq reverse $+ })  # $+ (last captured group) is palindr
+ome
                                 # then match nothing (succeed)
    |                            # else
        (?!)                     # fail on matching nothing (fail the 
+regex)
    )
/xs                              # x for readability, s to make . matc
+h \n

# Note: can match empty string
[download]

I think I prefer Perl 6 regexes here :)

rule palindrome {
    $foo := (\w+) ::: { fail if $foo ne reverse $foo }
}

# Note: doesn't match empty string
[download]

Or a simpler version, but this always backtracks:

/(.+)(??{ reverse $+ })/s
[download]

/
    (.+)                          # match one or more characters
    (??{ quotemeta reverse $+ })  # match the reverse of what was matc
+hed
/xs

# Note: doesn't match empty string or single character string
[download]

rule palindrome {
    $foo := (\w+) <{ quotemeta reverse $foo }>
}
[download]

As we aparently both know, the regular expressions (as defined by computer science) can't verify an arbitrary set of parens. You need a grammar for that.

However, Perl regular expressions are more powerfull than the conventional CS definition of RE, and they can match an arbitrary length string of parens.

Take a look at Regexp::Common::balanced . I didn't look at the code, but from the docs it appears to be what you need.

Now all you need to do is change the regexp so that it will work with different kinds of parens (instead of just one opening and one closing), append each candidate word to the pattern word, and see if the match returns true. Piece of cake :-)

Except that you transformed a O(n) search into an O(n^2) search. Which is not a good thing, unless you get a percentage from hardware sales :-)

It is true that the set of palindromes can not be matched with a regexp.

However, with Perl's extended regexps, it is possible. Indeed, this is in the Regexp::Common module.

perl -wne 'use Regexp::Common; /^$RE{lingua}{palindrome}$/ and print "
+palindrome\n";'
[download]

Update: beware, the above snippet only matches lines consisting of only letters.

use strict;

my $string1 = "abcba";
my $string2 = "abc1da";

if (&reverser($string1)){
    print "Matched! Strings are palindromes.\n";
    }
else{
     print "Sorry, the strings are not palindromes.\n";
}

if (&reverser($string2)){
    print "Matched! Strings are palindromes.\n";
    }
else{
     print "Sorry, the strings are not palindromes.\n";
}


sub reverser{
             my $temp = shift;
             my ($reverse, @temp, @temp2);
             @temp = split ('',$temp);

             foreach (@temp){
                      unshift(@temp2, $_);
                     }
             $reverse = join('', @temp2);
             $temp eq $reverse?1:0;
             }
[download]

Should do what you're requiring without using the regex. You're just running the array you've made from your string and reversing it using the unshift.

There is an Iterator that gets regexps as arguments.

Bye
 PetaMem     All Perl:   MT, NLP, NLU

This can be done quite straightforwardly with a recursive regexp:

  our $pal = qr{
    .?
  |
    (.) (??{$pal}) \1
  }x;
  sub is_palindrome {
    shift =~ /^$pal\z/;
  }
[download]

Don't expect it to be particularly efficient. :)

Hugo