Does it have to be a regex? tr/// provides a simpler solution.

#!/usr/bin/perl -w
use strict;
while (my $str = <DATA>) {
    my $odd = $str =~ tr/1// & 1;
    print $str,"has an ",$odd?"odd":"even"," number of 1's",$/;
}
__DATA__
110101010110111010101
100000000000000000001
101010101010101010101
110000000000000000011
110100000000000000000
11
[download]

Output:

110101010110111010101
has an odd number of 1's
100000000000000000001
has an even number of 1's
101010101010101010101
has an odd number of 1's
110000000000000000011
has an even number of 1's
110100000000000000000
has an odd number of 1's
11
has an even number of 1's
[download]

#!/usr/bin/perl -w
use strict;

sub is_odd { unpack "%1b*", pack "b*", shift }

for(1..10) {
    print is_odd("1" x $_), "\n";
}
__END__
1
0
1
0
1
0
1
0
1
0
[download]

Makeshifts last the longest.

$foo =~ tr/0//d;
length($foo);
[download]

/^(?:0*10*1)*/  # Matches evens
/^0*1(?:0*10*1)*/ # Odds
[download]

I wouldn't have let tr delete anything - just count the number of ones and then test that number for oddness. So I'd say this as $is_odd = $foo =~ tr/1// & 1; $is_even = $foo =~ tr/1// ^ 1;. This only tests bit zero's value and in theory is speedy. I dunno if it actually is.

Out of academic curiosity, does anyone know if scalar construction is likely to be more or less expensive than scalar modification? As a matter of fact, it would be really interesting to see performance analyses of many common perl operations.. Maybe they're already out there.. Any pointers, anyone?

 ^(0*10*10*)*10*$
[download]

^0*(?:10*10*)*$
^0*(?:10*10*)*10*$
[download]

Hopefully this is an idle curiosity question. Regexes are not the best way to do this at all.