Right you are ;)

use warnings;
use strict;
use Benchmark qw(cmpthese);

my $str = "Just Another Perl Hacker";

print join " ", do_substr (), "\n";
print join " ", do_regex (), "\n";
print join " ", do_unpack (), "\n";
print "\n";

cmpthese (-1,
        {
        unpack => \&do_unpack,
        substr => \&do_substr,
        regex => \&do_regex,
        }
    );


sub do_substr {
    my @parts;
   
    push @parts, substr $str, $_, 3 for 0 .. length ($str) - 3;
    return @parts;
}


sub do_regex {
    my @parts = $str =~ /(?=(...))/g;
    return @parts;
}

sub do_unpack {
    my $matches = length ($str) - 2;
    my $temp = "a3XX"  x $matches;
    my @parts = unpack ($temp, $str);
    return @parts;
}
[download]

Prints:

Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 
Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 
Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 

          Rate  regex unpack substr
regex  42045/s     --   -12%   -39%
unpack 47764/s    14%     --   -31%
substr 69161/s    64%    45%     --
[download]

Update: added unpack

I beg to differ...

For this substr based implementation it's important to have the temporary array @parts. For the regex it's unimportant! So if we leave the assignment to the array out, the regex is way faster!

Update: Can this be due to the fact that the functions might be called in a scalar context?

use warnings;
use strict;
use Benchmark qw(cmpthese);

my $str = "Just Another Perl Hacker";

print join " ", do_mapstr (), "\n";
print join " ", do_substr (), "\n";
print join " ", do_regex (), "\n";
print "\n";

cmpthese (-1,
        {
        mapstr => \&do_mapstr,
        substr => \&do_substr,
        regex => \&do_regex,
        }
    );


sub do_mapstr {
    return map substr($str,$_-3,3),(3..length $str);
}


sub do_substr {
    my @parts;
    
    push @parts, substr $str, $_, 3 for 0 .. length ($str) - 3;
    return @parts;
}


sub do_regex {
    return $str =~ /(?=(...))/g;
}
[download]

Result

Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 
Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 
Jus ust st  t A  An Ano not oth the her er  r P  Pe Per erl rl  l H  H
+a Hac ack cke ker 

            Rate substr mapstr  regex
substr   25123/s     --   -48%   -97%
mapstr   48651/s    94%     --   -95%
regex  1003705/s  3895%  1963%     --
[download]

---

s$$([},&%#}/&/]+}%&{})*;#$&&s&&$^X.($'^"%]=\&(|?*{%
+.+=%;.#_}\&"^"-+%*).}%:##%}={~=~:.")&e&&s""`$''`"e

GrandFather,
If you are feeling bored, I would be interested in seeing how my unpack solution I came up with for Challenge: Fast Common Substrings does. In a nutshell, we programmatically generate a template to extract all substrings of a given length.

Cheers - L~R

More interested than bored. Note that removing the template generation from do_update makes no significant difference to the result.

---

DWIM is Perl's answer to Gödel

use strict;
print map { (length($_) - 2) . "\n" } 
  split('\s+', "Just Another Perl Hacker");
__END__
2
5
2
4
[download]

Depending on the application, it might be appropriate to include spaces (and/or punctuation) in the ngram list:

jus
ust
st 
t a
 an
ano
not
...
[download]

<picky_mode>
Only assuming the string does not contain whitespace.
</picky_mode>

Why so? If we're dealing with plain sequences of letter from an alphabet, of which one thing called "whitespace" is part, than the latter should not be special in anyway. If you have some paticular application in mind, then YMMV. To quote from Wikipedia:

For sequences of characters, the 3-grams (sometimes referred to as "trigrams") that can be generated from "good morning" are "goo", "ood", "od ", "d m", " mo", "mor" and so forth. Some practitioners preprocess strings to remove spaces, most simply collapse whitespace to a single space while preserving paragraph marks.

I always thought whitespace was not a letter. I guess I was wrong.