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

while (<DATA>) {
    next if ($_ !~ /([A-Za-z])\1/);
    print;
}

__DATA__
balloon
hello
world
foo
bar
perlmonks
merry
christmas
[download]

Which gives:

balloon
hello
foo
merry
[download]

See perlre for more information.

Hope this helps,
Darren :)

Good solution! I couldn't help but golf it a little. :)

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

while (<DATA>) {
    print if (/([a-z])\1/i);
}

__DATA__
balloon
hello
world
foo
bar
perlmonks
merry
christmas
[download]

That helps immensely, thank you very much indeed. Why I didn't think of that, I shall never know.

I like using POSIX character sets when they're applicable because they will "work" nicely with the locale and utf8 pragmas, and Unicode. When you see [a-zA-Z] in code, you're looking at code that probably won't play nice with locales. A good way to accommodate locales is POSIX character classes. So re-written with that in mind, you have this:

print "Match!\n" if $string =~ m/([[:alpha:]])\1/; # Probably good.
[download]

...instead of the possibly problematic:

print "Match!\n" if $string =~ m/([a-zA-Z])\1/; # Maybe bad!
[download]

a little trick. (Still uses regexes, but nothing complicated, not even any captures.)

sub find_runs
{
    local $_ = shift;
    $_ ^= substr $_, 1; # string shifted left one char.
    my @r;
    push @r, [ $-[0], $+[0] - $-[0] + 1 ] while /\x00+/g;
    @r
}

# find the 'oo' and the 'ttt'
my $s = "look for doubled lettters";
for my $r ( find_runs($s) )
{
    print substr $s, $r->[0], $r->[1];
}
[download]

Duck Duck Go pointed me to this quite old thread when searching for "regular expression matching double letters". Although the OP emphasized "and only double letters" in its title all solutions posted so far also match double letters which are part of triple, quadruple, ... letters (e.g. in "Helllo", "cooool") and within 12 years no one seems to have cared about that. For what it's worth I do care about it and found it surprisingly difficult to come up with a regex that matches doubles only. One of my closest approaches is

/(.)((?!\1).)\2(?!\2)/

which uses a negative lookahead to make sure there's something else before the double letter and another negative lookahead to make sure there's something else following the double letter. However, this regex still matches the "something else before" character, too - as I have to use a capturing group for it in order to have a corresponding backreference to use in the lookahead assertion.

Could it be that finding doubles only is not a regular problem in the sense of Theoretical Computer Science? Or is it just me being unable to find a proper solution?

Further to AnonyMonk's Re^2: Using regex to match double letters, and only double letters regex:   Note that the look-ahead is not strictly necessary:
    / (.) \g-1 (?: \g-1+ (*SKIP)(*FAIL))? /x
works | seems to work equally well. Since Perl version 5.10+ regex extensions must be used (for (*SKIP) (*FAIL)) anyway, I've also used \gn relative backreferencing so the regex can be defined in a  qr// more safely; this can be more convenient in an extractive application.

Read more... (4 kB)

---

Give a man a fish:  <%-{-{-{-<

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

for my $s (qw( xxabyycdzz axxbmmmcyyd xxyy exxyy xxyyf xxgyy mmm mmmen
+nn )) {
    say for '---', $s;
    say $2 while $s =~ /(?|^((.))\2(?!\2)
                          |(?<=(.)(?!\1))(.)\2(?!\2))/gx;
}
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Your regex (as a whole) matches the "something else before" character as well - printing the content of a certain capture group is cheating! ;-)

Perl regex engine has support for (*SKIP) since version 5.010; so you could write:

/(.)\1((?!\1)|\1*(*SKIP)(*FAIL))/
[download]

Using the above solution, you can also try the programs to find out the palindromes. For example,
 print $_ if ( $_ =~ /([[:alpha:]])([[:alpha:]])([[:alpha:]])([[:alpha:]])\3\2\1/i );
This above code matches of the palindrome of length 6.

In the same way you can apply your logic to find out the palindromes.

Lots of things you can do with backreferences. Even check for primes:

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

(by Abigail)

My Perl-fu is non-existent but this caught my eye in another web search I was doing. I propose the following, non-golf, trivial method which does not require backreferencing;

Needless to say, yikes.