(exists $query{$item}) ? ($query{$item}=$query{$item}+1) : ($query
+{$item}=1);
[download]

    $query{$item}++;
[download]

but its taking some time to finish this task.

It won't make any discernible difference on such a small dataset as your sample, but avoiding the sort for much larger datasets should be a win:

#! perl -slw
use strict;

my %hash;
++$hash{ <> } until eof();

my @top5;
for( keys %hash ) {
    for my $i ( 0 .. 4 ) {
        if( !defined( $top5[ $i ] ) or $hash{ $_ } > $hash{ $top5[ $i 
+] } ) {
            splice @top5, $i, 0, $_;
            pop  @top5 if @top5 > 5;;
            last;
        }
    }
}
print @top5;
__END__
many hardships
a million dollars
love life
apple pie
you attempt things
[download]

Note: the difference between my output and your expected is due to there being no clear winner for 5th place.

Much shorter :)

$ perl -ne'$x{$_}++}END{print"$x{$_}\t$_"for(sort{$x{$b}<=>$x{$a}}keys
+%x)[0..4]' test.txt
5       many hardships
2       a million dollars
2       love life
2       apple pie
1       you attempt things
[download]


Enjoy, Have FUN! H.Merijn

Update: Ignore this. The optimisation broke it.

<Reveal this spoiler or all in this thread>

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

The start of some sanity?

I assume your input file is much biggger in reality otherwise I can't imagine this script taking a lot of time. In that case sorting the whole %query hash to only get the 5 highest might be slow

Instead you could use this:

my @result=([0,''],[0,''],[0,''],[0,''],[0,'']);
foreach (keys %query) {
  my $sw;
  my $n= [$query{$_},$_];
  if ($n->[0]>$result[4]) {
    if ($n->[0]>$result[3]) {
      if ($n->[0]>$result[2]) {      
        if ($n->[0]>$result[1]) {
          if ($n->[0]>$result[0]) {
            $sw=$result[0]; $result[0]=$n; $n=$sw;
          }
          $sw=$result[1]; $result[1]=$n; $n=$sw;
        }
        $sw=$result[2]; $result[2]=$n; $n=$sw;
      } 
      $sw=$result[3]; $result[3]=$n; $n=$sw;
    }
    $sw=$result[4]; $result[4]=$n; $n=$sw;
  }
}
print join("\n",map{$_->[1]},@result);
[download]

The speedup of this somewhat ugly contraption lies in the expectation that the first 'if' will be true very very seldom for a big hash

In your data there a lots of lines that only appear once, so why is 'this year' the correct choice to fill out your top five?

That's not important, means the last one. Since all the other items occuring only once

It seems to me that a simple hash would do nicely.   Perl has many shortcuts to simplify this sort of thing, for example:

my $foo = "bar";
my $counts = {};
$$counts{$foo}++;    // or $counts->{$foo}++;
// yields: "$$counts{"bar"} == 1
[download]

There are many ways to get the final tallies out of the structure, depending on your needs.

This straight-ahead strategy works excellently for any data volume that can be reasonably expected to fit entirely in memory without incurring page-faults.   (Which, given the beefy size of computers these days, is a pretty safe bet.)

The original choice of Perl was that the word was an acronym for P(ractical | ragmatic) Extraction and Reporting Language, otherwise known as The Swiss Army® Knife.   And this is one of the reasons why.   Text-handling tasks, that lots of folks have to do lots of ... those bread-and-butter tasks ... are easy to code and ruggedly implemented.

Way I heard it, the original choice of Perl by Larry was because he wanted to name his creation Pearl, but there was already a 'pearl' application on the system on which he was developing. The individual letters meant nothing. Perl was then backronymed as, among others, P(ractical | ragmatic) Extraction and Reporting Language.