Follow me on Twitter for my latest adventures!

perl -lne '(1x$_) =~ /^1?$|^(11+?)\1+$/ || print "$_ is prime"'

Can you figure out how it works? I give an explanation below, but try to figure it out yourself. Here is what happens when you run it:

$ perl -lne '(1x$_) =~ /^1?$|^(11+?)\1+$/ || print "$_ is prime"' 1 2 2 is prime 3 3 is prime 4 5 5 is prime 6 7 7 is prime 8 9 10 11 11 is prime

Here is how it works.

First, the number is converted in its unary representation by `(1x$_)`

. For example, the number `5`

gets converted into `1x5`

, which is `11111`

(`1`

repeated `5`

times.)

Next, the unary string gets tested against the regular expression. If it matches, the number is a composite, otherwise it's a prime.

The regular expression works this way. It consists of two parts `^1?$`

and `^(11+?)\1+$`

.

The first part matches number `1`

and the empty string. Clearly, the empty string and number `1`

are not prime numbers, therefore this regular expression matches, which indicates that they are not prime numbers.

The second part determines if two or more `1`

s repeatedly make up the whole number. If two or more `1`

s repeatedly make up the whole number, the regex matches, which means that the number is composite. Otherwise it's a prime.

Let's look at the second regex part on numbers `5`

and `4`

.

The number `5`

in unary representation is `11111`

. The `(11+?)`

matches the first two ones `11`

. The back-reference `\1`

becomes `11`

and the whole regex now becomes `^11(11)+$`

. It can't match five ones, therefore it fails. But since it used `+?`

, it backtracks and matches the first three ones `111`

. The back-reference becomes `111`

and the whole regex becomes `^111(111)+$`

. It doesn't match again. This repeats for `1111`

and `11111`

, which also don't match, therefore the whole regex doesn't match and the number is a prime.

The number `4`

in unary representation is `1111`

. The `(11+?)`

matches the first two ones `11`

. The back-reference `\1`

becomes `11`

and the regex becomes `^11(11)+$`

. It matches the original string, therefore the number is not a prime.

PS. I didn't invent this regular expression, it was invented in 1998 by Abigail.

Don't take this regular expression too seriously, it's actually neither a regular expression (as defined in automata theory), nor a way to check if a number is a prime. It's just an awesome thing that Perl can do. See this cool article called The Prime That Wasn't by Andrei Zmievski for a discussion about how this regex fails for larger numbers because of backtracking.

Also if you wish to learn more about Perl one-liners, check out my Perl One-Liners Explained article series and download the perl1line.txt file.

## Comments

I believe credit for this is due to Abigail, who posted it (spelled a little differently) over a decade ago.

That is correct!

Source: http://www.catb.org/jargon/html/O/one-liner-wars.html

Good find.

I just wrote a coprimality test with a regular expression tonight, based on the same technique.

https://gist.github.com/1520171

Very cool!

This perl program gives a segmentation fault on x86 Linux (RHEL 5) when served an input of 1234321

Yup, doesn't work for large numbers. There is so much backtracking going on for large numbers that Perl runs out of memory.

This isn't a "regular expression", it's a "regexp" =] - see comments on HN:

http://news.ycombinator.com/item?id=3391547

This script uses backreferences which give regexp's more "computing power" than regular expressions actually have, but remove the guaranteed runtime of an O(n) regular expression. For more, read the excellent article at http://swtch.com/~rsc/regexp/regexp1.html

You can actually prove that "regular expressions" don't have the computing power to enumerate the prime numbers. For more, read the wiki article, http://en.wikipedia.org/wiki/Pumping_lemma_for_regular_languages

On an unrelated note, I've been a longtime fan of your NodeJS articles, and look forward to more of your writing. =]

I have studied computer science intensively and you're right that this regular expression isn't a real regular expression as in automata theory.

I'm publishing the next nodejs post in a few days!

my $string = "-" x 1000;

$string =~ s/(?!(-{2,})\1{1,}$)(?=(-{2,}))/print length($2), "\n"/eg;

Links to other explanations and to a usenet post by Abigail that dates it back to 1997 can be found at my blog.

Abigail's looked like this

perl -wle 'print "Prime" if (1 x shift) !~ /^1?$|^(11+?)\1+$/'

## Leave a new comment