use strict;
use warnings;

my %h;

while (<DATA>)
{
    $h{$_}++ for map { lc } grep { /^[a-zA-Z]+$/ } split /\W+/;
}

for (sort keys %h)
{
    printf "%10s %05d\n", $_, $h{$_};
}
__DATA__
This line contains garbag3, and words!
This line does not.
[download]

       and 00001
  contains 00001
      does 00001
      line 00002
       not 00001
      this 00002
     words 00001
[download]

It took about 1.1 sec. on my command line redirection version (using your adapted code) and reminded me of Common Lisp. Now I'm a happier programmer, thanks for reminding the powerful map! ;-)

Right now you're pulling the entire file into a scalar while removing the junk and then lowercasing the words, and then counting them. Do this instead, just pseudo code since I can't really read your regexs:

while(<STDIN>) { 
    s/remove junk strings//og; 
    my @words = split(/\s+/, $_); # split into words 
    foreach my $w (@words) { 
        $MyWordCount{lc($w)}++;
    }
}
[download]

I would imagine that is faster than what you are currently doing. I say this because this way you aren't having to accumulate everything into one big scalar.

Much better now! I was thinking along the similar line, about that putting everything into a huge scalar at once issue and trying your solution gave about 2 sec. runtime. The C# code does one thing more, seperating each word into syllable but that's another story. Thanks for the hint.

Well several things could be improved.

There is no need to remove the words that you don't want from the string, just include the words that you do want.

If you are going to use precompiled regexes, I think you will get better performance by moving the regex outside of the loop.

As was previously mentioned, accumulating the file into a scalar and then acting on the scalar is going to give you a large performance hit.

If I was going to do something like this, (and I have in the past,) I would probably write it like this:

###########################################################

#! /usr/bin/perl
use warnings;
use strict;

my $word = qr/\b[a-zA-Z\x{131}ü\x{11F}\x{15F}çö\x{130}\x{15E}Ö\x{11E}Ü
+]+\b/;
my %mywordcount;

while (<STDIN>) {
    my $line = $_;
    while ($line =~ /($word)/g){
        $mywordcount{(lc $1)}++;
    }
}

print "Word\t\t\tFrequency\n";
print "======\t\t\t===========\n";

#sorting alphabetically

print "$_\t\t", (length($_) > 7) ? '' : "\t", $mywordcount{$_}, "\n" f
+or sort keys %mywordcount;
[download]

Update: Changed to STDIN fh, I tested with default and forgot to change before posting.

FWIW, on my system, this takes about 2 seconds to process a 1.6 MB file.

Also, it isn't specified in the original post, but if you want to allow for words with an internal apostrophe, (don't, you'll, you're, etc.,) change the line

while ($line =~ /($word)/g){
[download]

to

while ($line =~ /($word('$word)?)/g){
[download]

Update 2: Sigh. I realized that my regex wouldn't work correctly with words containing non-ASCII character too. (\b doesn't work for multi-byte characters.)

Should be:

my $word = qr/(?<!\p{Alpha})[a-zA-Z\x{131}ü\x{11F}\x{15F}çö\x{130}\x{1
+5E}Ö\x{11E}Ü]+(?!\p{Alpha})/;
[download]

while (<STDIN>) {
    $MyString = $MyString . $_ unless ( /\d/ );
}
[download]