in reply to Re: finding number of contiguous letters
in thread finding number of contiguous letters

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

DWIM is Perl's answer to Gödel

Replies are listed 'Best First'.
Re^3: finding number of contiguous letters
by Skeeve (Parson) on May 23, 2007 at 12:31 UTC

    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
[reply]
[d/l]
[select]
Re^3: finding number of contiguous letters
by Limbic~Region (Chancellor) on May 23, 2007 at 12:44 UTC
    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

[reply]

      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
[reply]
        GrandFather,
        Neat and thanks. I am interested myself but am finding myself with no free time. The next question I would want to ask is if the results change as the size of string changes. Oh well, another time perhaps. Thanks again.

        Cheers - L~R

[reply]

In Section Seekers of Perl Wisdom