How does one implement a recursive palindrome checker using regular expressions?

Question

So far I've been using ^[a-zA-Z]+( [a-zA-z]+)*$ to make sure user input Has no space in the beginning and the end and not to accept numbers or special characters and only to accept alphabetical characters.

I looked at the regex list online and in my texts I can't seem to formulate one under these conditions for a recursive palindrome program:

Accepts strings containing upper case or lower case characters.
Accepts punctuation, and single spaced blanks.

I don't think I'll need a regex for the following after validation, but if there is I'd like to know what it is.

After validation upper case letters must be converted to lower case.
The punctuation and spaces are to be ignored.

*"Not sure what regex to use"* Yes, it's hard to be sure before you try something. [What have you tried?](http://www.whathaveyoutried.com/) — Andrew Thompson, Nov 01 '12 at 00:59
Well I tried incorporating `\p{Punct}` but I could never seem to get it to work, I don't know the exact format it should be written in. — SelfDeceit, Nov 01 '12 at 01:10
FWIW, it's a great help in learning regex to have a sandbox to try things in quickly. A great plugin for Eclipse is [QuickREx](http://sourceforge.net/projects/quickrex/) — Ed Staub, Nov 01 '12 at 01:26
you can use `trim()` to take away spaces at the beginning and the end of a String — Valentino Ru, Nov 01 '12 at 01:38

score 0 · Accepted Answer · answered Nov 01 '12 at 03:59

If I understand you correctly, you want to create a recursive palindrome checker that employs regular expressions, in Java. I'm interested in learning Java, so I gave it a shot as my own sort of "homework problem," although it is probably yours too.

import java.lang.*;
import java.util.*;
import java.util.regex.*;

class Main
{
    public static boolean recursivePalindrome(String str)
    {
        // We need two patterns: one that checks the degenerate solution (a
        // string with zero or one [a-z]) and one that checks that the first and
        // last [a-z] characters are the same. To avoid compiling these two
        // patterns at every level of recursion, we compile them once here and
        // pass them down thereafter.
        Pattern degeneratePalindrome = Pattern.compile("^[^a-z]*[a-z]?[^a-z]*$", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Pattern potentialPalindrome  = Pattern.compile("^[^a-z]*([a-z])(.*)\\1[^a-z]*$", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        return recursivePalindrome(str, degeneratePalindrome, potentialPalindrome);
    }

    public static boolean recursivePalindrome(String str, Pattern d, Pattern p)
    {
        // Check for a degenerate palindrome.
        if (d.matcher(str).find()) return true;

        Matcher m = p.matcher(str);

        // Check whether the first and last [a-z] characters match.
        if (!m.find()) return false;

        // If they do, recurse using the characters captured between.
        return recursivePalindrome(m.group(2), d, p);
    }

    public static void main (String[] args) throws java.lang.Exception
    {
        String str1 = "A man, a plan, a canal... Panama!";
        String str2 = "A man, a pan, a canal... Panama!";

        System.out.println(str1 + " : " + Boolean.toString(recursivePalindrome(str1)));
        System.out.println(str2 + " : " + Boolean.toString(recursivePalindrome(str2)));
    }
}

The output is:

A man, a plan, a canal... Panama! : true
A man, a pan, a canal... Panama! : false

How does one implement a recursive palindrome checker using regular expressions?

1 Answers1