Regex match even number of letters

Question

I need to match an expression in Python with regular expressions that only matches even number of letter occurrences. For example:

AAA        # no match
AA                


        

Answer 1

This searches for a block with an odd number of A's. If you found one, the string is bad for you:

(?<!A)A(AA)*(?!A)

If I understand correctly, the Python code should look like:

if re.search("(?<!A)A(AA)*(?!A)", "AeAAi"):
   print "fail"

Answer 2

Try this regular expression:

^[^A]*((AA)+[^A]*)*$

And if the As don’t need to be consecutive:

^[^A]*(A[^A]*A[^A]*)*$

Answer 3

First of all, note that /A*/ matches the empty string.

Secondly, there are some things that you just can't do with regular expressions. This'll be a lot easier if you just walk through the string and count up all occurences of the letter you're looking for.

Answer 4

'A*' means match any number of A's. Even 0.

Here's how to match a string with an even number of a's, upper or lower:

re.compile(r'''
    ^
    [^a]*
    (
        (
            a[^a]*
        ){2}
    # if there must be at least 2 (not just 0), change the
    # '*' on the following line to '+'
    )* 
    $
    ''',re.IGNORECASE|re.VERBOSE)

You probably are using a as an example. If you want to match a specific character other than a, replace a with %s and then insert

[...]
$
'''%( other_char, other_char, other_char )
[...]

Answer 5

It's impossible to count arbitrarily using regular expressions. For example, making sure that you have matching parenthesis. To count you need 'memory' which requires something at least as strong as a pushdown automaton, although in this case you can use the regular expression that @Gumbo provided.

The suggestion to use finditeris the best workaround for the general case.

Answer 6

'*' means 0 or more occurences 'AA' should do the trick.

The question is if you want the thing to match 'AAA'. In that case you would have to do something like:

r = re.compile('(^|[^A])(AA)+(?!A)',)
r.search(p)

That would work for match even (and only even) number of'A'.

Now if you want to match 'if there is any even number of subsequent letters', this would do the trick:

re.compile(r'(.)\1')

However, this wouldn't exclude the 'odd' occurences. But it is not clear from your question if you really want that.

Update: This works for you test cases:

re.compile('^([^A]*)AA([^A]|AA)*$')