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

my %data;
while (<DATA>) {
    chomp;
    my ($team, @field) = split;
    push @{ $data{$team} }, \@field;
}
[download]

This creates a single hash entry for each team. The value is a reference to an array of all entries for that team. Each entry is an array reference to the specific stats for that entry.

Alternatively, you could do the HoHoA. Added implementation below.

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

use constant TEAM    => 0;
use constant POINTS  => 1;
use constant TALLIES => 2;
use constant SCORES  => 3;
use constant METRICS => 4;

my %data;
while (<DATA>) {
    chomp;
    my @col = split;
    push @{ $data{$col[TEAM]}{POINTS} },  $col[POINTS];
    push @{ $data{$col[TEAM]}{TALLIES} }, $col[TALLIES];
    push @{ $data{$col[TEAM]}{SCORES} },  $col[SCORES];
    push @{ $data{$col[TEAM]}{METRICS} }, $col[METRICS];
}
[download]

Thank you. I got pulled in quite a few directions, but I have saved youyr code and will study it. It sure looks nice and succinct!

Tony

Hi,

I just want to say that perhaps the biggest thing I learned was the need to surround the array with braces. I never noticed that before! And I saw it in all three replies to my post.

I am wondering if you know any reference that discusses this syntax.

Thanks again,

Tony

o2bwise,
Anytime you are looking for more information on something, remember that perl ships with all documentation. Additionally, you can look here at tutorials and you would find intro to references and References quick reference. I know that merlyn recently wrote an article on the topic but I don't believe it is available yet.

Additionally, you may be interested in Recommended Reading and Re: Refactoring a large script which I wrote. They are not specific to your question but they do provide a lot of good links.

Cheers - L~R

A hash slice solves the problem (see perldata - slice):

use strict;
use warnings;

my %teamStats;
my @paramNames = ('points', 'tallies', 'scores', 'metrics');

while (<DATA>) {
    chomp;
    my ($team, @params) = split /\s+/;
    
    next if @params < 4;
    
    # Populate new hash using a hash slice
    my %newParams;
    @newParams{@paramNames} = @params;
    push @{$teamStats{$team}}, \%newParams;
}

foreach my $team (keys %teamStats) {
    print "\n\nTeam:\t$team\n";
    print "\t", join ("\t", @paramNames), "\n";
    
    for my $game (@{$teamStats{$team}}) {
        # Hash slice to the rescue again
        print "\t", join ("\t", @$game{@paramNames}), "\n";
    }
}


__DATA__
packers    4    40    400    4000
patriots    6    62    436    3987
colts    8    74    892    7666
bears    9    88    912    9550
packers    3    44    410    4200
patriots    7    66    510    3800
colts    10    77    910    7000
bears    11    88    1010    9410
[download]

Prints:

Team:    colts
    points    tallies    scores    metrics
    8    74    892    7666
    10    77    910    7000


Team:    patriots
    points    tallies    scores    metrics
    6    62    436    3987
    7    66    510    3800


Team:    packers
    points    tallies    scores    metrics
    4    40    400    4000
    3    44    410    4200


Team:    bears
    points    tallies    scores    metrics
    9    88    912    9550
    11    88    1010    9410
[download]

Update: cleaned up a little "legacy" code

Thanks, Grandfather,

I got pulled in a few directions, but will have a look tomorrow. I have it saved on my box.

Tony

Hi,

I just want to say that perhaps the biggest thing I learned was the need to surround the array with braces. I never noticed that before! And I saw it in all three replies to my post.

I am wondering if you know any reference that discusses this syntax.

Thanks again,

Tony

"complicated" data structures are really simple data structures that refer to other data structures. That is, generally you are dealing with scalars, arrays (that can only store scalars) or hashes (that can only store scalars). The trick is that a scalar can store a reference to other things. HoHoA and all the other variants work by storing references so the good oil you are looking for is References quick reference from the Tutorials section.

---

DWIM is Perl's answer to Gödel

use strict;
use warnings;

use Data::Dumper;

my %teams = ();

while ( <DATA> )
{
    chomp;
    my ($team, $points, $tallies, $scores, $metrics) = split;
    push @{ $teams{$team}->{points} }, $points;
    push @{ $teams{$team}->{tallies} }, $tallies;
    push @{ $teams{$team}->{scores} }, $scores;
    push @{ $teams{$team}->{metrics} }, $metrics;
}

my $dd = Data::Dumper->new([\%teams], [qw{*teams}]);
print $dd->Dumpxs();

__END__
packers    4    40    400    4000
patriots    6    62    436    3987
colts    8    74    892    7666
bears    9    88    912    9550
packers    3    44    410    4200
patriots    7    66    510    3800
colts    10    77    910    7000
bears    11    88    1010    9410
packers    2    36    385    4105
patriots    4    58    500    3700
colts    9    75    900    7500
bears    8    95    1017    10200
packers    4    37    388    4378
patriots    6    55    440    4987
colts    8    80    843    8210
bears    9    101    890    9998
packers    7    40    400    4000
patriots    11    62    436    3987
colts    7    74    892    7666
bears    12    88    912    9550
packers    2    48    422    4320
patriots    3    54    510    3765
colts    6    72    812    7500
bears    7    86    899    9430
[download]

and here's the output

The top-level hash is keyed by team and there is for each team a sub-hash for each of points, tallies, scores and metrics, the values in each case being an array of said points etc. Thus, for points, we want $teams{$team}->{points} to be an array so enclosing it in the @{ ... } de-references the value in that sub-hash to get at the array so that the push can add another element to the end. Note also that the anonymous array will be created (autovivified) if it didn't exist already.

I probably haven't explained this very well. Reply with more questions if it isn't clear.

Cheers,

JohnGG

Man, that's great, JohnGG.

I got pulled away in, but saved your code and will have a look tomorrow.

I sure appreciate the output too.

Tony