Hello jimmy88, and welcome to the Monastery!

Aside from the problem with $mingrade, which atcroft has already addressed, there is a subtle logic error in your script which is masked by the fact that in the data file “grades.txt” the final line’s “exam” happens to be the value of the total number of exams. Change the order of this file to this:

...
222223 5 96
244668 5 95
355779 5 94
122334 1 98
[download]

and the averages will all be wrong. The reason for this is the way Perl aliases the variable in a foreach loop: after the foreach $exam (1..$lastexam) { loop has completed, $exam reverts to the value it had before the loop was entered. In this case, you can fix the problem by changing the line:

printf "%8d",$total / $exam;
[download]

to:

printf "%8d",$total / $lastexam;
[download]

Note also that this script would be greatly improved by the addition of the lines:

use strict;
use warnings;
[download]

at its head. Converting global variables to lexicals will require some thought (to determine the correct placement of each my declaration), but the effort expended now will be more than repaid by the debugging time you will save down the track. (To silence the warnings, you will also need to initialise some of the variables.)

Hope that helps,

Initialize $mingrade before your loop to either something larger than the largest expected value, or the first value you encountered.

Hope that helps.

In addition to what was said above, $grade{$id,$exam} does not do what you expect. Try $grade{$id}{$exam} to create a two-dimensional data structure.

See also Multi dimensional array emulation in Perldata

Cheers Rolf

_{(addicted to the Perl Programming Language and ☆☆☆☆ :)}

update

IMHO that's a misnomer, cause its a multidim HASH emulation.

May be a case where originally a "associative array" was meant, but the terminology should be consistent.

It might work. See $; in perlvar.
لսႽ† ᥲᥒ⚪⟊Ⴙᘓᖇ Ꮅᘓᖇ⎱ Ⴙᥲ𝇋ƙᘓᖇ

#!/usr/bin/perl -w

use strict;
use Data::Dumper;

my %student;

open STUDENT, "<student.txt" or die "Cannot open student.txt: $!\n";
while (<STUDENT>) {
    my @student = split(':');
    $student{$student[0]} = { name => $student[1] };
}
close STUDENT;

open GRADES, "<grades.txt" or die "Cannot open grades.txt: $!\n";
while (<GRADES>) {
    my @grades = split(' ');
    $student{$grades[0]}->{grade}->{$grades[1]} = $grades[2];
}
close GRADES;

print Dumper(\%student);
print "\n------------------------------\n";

foreach my $id (sort keys %student) {
    print "Id: $id - $student{$id}->{name}\n";

    my $graderef = $student{$id}->{grade};
    foreach my $exam (sort keys %$graderef) {
        print "  Exam: $exam grade: $graderef->{$exam}\n";
    }
}
[download]

For example:

use Modern::Perl '2014';
use DBI;

my $dbfile = 'c:/data/school.sqlite';
my $dbh =
  DBI->connect( "dbi:SQLite:dbname=$dbfile", "", "", { RaiseError => 1
+ } );

my $sth = $dbh->prepare('INSERT INTO students (id, name) VALUES (?, ?)
+');
while (<DATA>) {
    chomp;
    last if /grades.txt/;
    next unless $_;
    next if /^\*\*\*/;
    say $_;
    my ( $id, $name ) = split /:/;
    $sth->execute( $id, $name );
}

$sth =
  $dbh->prepare('INSERT INTO results (id, course, score) VALUES (?, ?,
+ ?)');
while (<DATA>) {
    chomp;
    next unless $_;
    next if /^\*\*\*/;
    my ( $id, $course, $score ) = split /\s+/;
    $sth->execute( $id, $course, $score );
}

my $ary_ref = $dbh->selectall_arrayref(
'SELECT name, sum(score), avg(score), min(score), max(score) FROM resu
+lts JOIN students WHERE students.id = results.id GROUP BY results.id 
+ORDER BY name'
);

printf "%20s %10s %8s %8s %8s\n", qw/Name Total Average Min Max/;
for my $line (@$ary_ref) {
    printf "%20s %10d %8d %8d %8d\n", @$line;
}

$ary_ref = $dbh->selectall_arrayref(
    'SELECT course, avg(score) FROM results GROUP BY course ORDER BY c
+ourse');

printf "\n%10s %8s\n", qw/Course Average/;
for my $line (@$ary_ref) {
    printf "%10d %8d\n", @$line;
}

__DATA__

***students.txt***
122334:James,Lebron:
222223:Duncan,Tim:
244668:Bryant,Kobe:
355779:Durant,Kevin:
******************

***grades.txt***
122334 1 98
222223 1 86
...(snip)...
244668 5 95
355779 5 94
****************
[download]

                Name      Total  Average      Min      Max
         Bryant,Kobe        466       93       89       95
          Duncan,Tim        462       92       86       96
        Durant,Kevin        468       93       90       96
        James,Lebron        485       97       96       98

    Course  Average
         1       90
         2       93
         3       95
         4       95
         5       95
[download]

Retrieving data is just one line of Perl-code and since the data is saved in the database you can use it again and again without running the cost of parsing the input file(s).

When working with data and manipulating the data in various ways, always think "database"!

I am sorry but I have to object very strongly to this. Especially with the word "always".

Databases are very good for two things: data persistence and ability to manage data volumes too big for the computer memory. And also the fact that, if your database is SQL, that the SQL language is a very high level and practical language that will hide many implementation details.

But databases also have a lot of limitations. First, they are horribly slow (compared to hashes in memory). And the languages to manipulate them, such as PL-SQL, are often also horribly slow. Of course, this probably does not matter if you have just tens of thousands of records. But when you get to millions or tens of millions of records, the difference is huge.

So, if you don't need to store data in a persistent fashion, just probably don't use a database, or, at least, think twice before you do it.

About a year and a half ago, I was asked to try to improve performance of a very complicated extraction process on a database. Initial duration test led to a prospective execution time of 160 days. After some profiling and benchmarking work, I was able to reduce it to about 60 days, 59.5 of which in a very complicated trans-codification process. Not too bad, but still obviously a nogo. I moved to an extract of raw data files and a reprocessing of the flat files in pure Perl. The overall extraction time fell to about 12 or 13 hours, but the trans-codification part, using half a dozen Perl hashes, fell from 59.5 days to just about an hour, i.e. an improvement of a factor of about 1,400.

No, it is a bit more complicated. Databases are very useful, there is no doubt about it, but they are certainly not the solution to everything, far from that. Especially when performance is important.

I said "think database", not that you always have to use one or that it is always the best option.

However in actual practical real world cases, there is usually a need to persist the data, there is more data than you can keep in the __DATA__ section of your script or the data changes from time to time. So it pays to "think database" in many, if not most, of the day-to-day jobs.

I am not surprised that Perl outruns any database in doing a complicated trans-codification process. That is one of Perl's main strengths!

CountZero

A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James

My blog: Imperial Deltronics