use Quantum::Superpositions;

$max = any(@items) >= all(@items);
$min = any(@items) <= all(@items);
[download]

Cheers,
Paul

xoxo,
Andy
--
<megaphone> Throw down the gun and tiara and come out of the float! </megaphone>

yeah, if only there were a construct in perl that could *test* for conditions, and if only there were some way of giving some piece of information a name, putting that information in a holder of some sort, and to refer to that information by that name, and maybe even manipulating the information. In fact, wouldn't it be great if you could tell perl

For every value you have

1. IF the current value is greater than the biggest one you've seen so
+ far, 
     THEN it's the new biggest one you've seen.
2. IF the current value is lower than the lowest value you've seen, 
     THEN it's the new lowest one you've seen
[download]

?

And if only it were the case that at the end of such a process, "the biggest value you've seen so far" would have to be the biggest value in the collection, and similarly for the lowest value you'd seen. But them's the breaks, as they ... well, nobody I know ... say.

perl -e 'print "How sweet does a rose smell? "; chomp ($n = <STDIN>); 
+$rose = "smells sweet to degree $n"; *other_name = *rose; print "$oth
+er_name\n"'
[download]

#!/usr/bin/perl
*=*j=>*-=*k=>*>=*l=>*<=*m;
while(<>){chomp;$*++;$-+=$_;($_>$>)&&($>=$_);($_<($<||=$>))&&($<=$_)}$
+-/=$*;
print"$> $- $<\n"
[download]

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Package MinMax;

sub new {
 my $proto = shift;
 my $class = ref($proto) || $proto;
 bless [ sort map { sprintf "%09d", $_ } @_ ], $class;
}

sub min {
 @{shift()}[0];
}

sub max {
 @{shift()}[-1];
}

sub total {
 my $self = shift;
 my $total = 0;
 $total += $_ for @$self;
 $total;
}

sub avg {
 my $self = shift;
 $self->total/@$self;
}
[download]

You don't need to step through all the values to get the min and max , you can just sort the list and get the first and last value, since sorting is *much* simpler for the perl interpreter than having to look at each value. chezzz.

($min, $max) = (sort { $a <=> $b } @numset)[0,-1];
[download]

As for the average, what could be faster than just adding all the numbers divided by the number of numbers ? Several divisions on smaller numbers are easier than dividing the big number in the end, so this is FAST!

grep { $avg += $_/@numset } @numset;
[download]

Don't worry about it being hard to read, perl is all about being hard to read and you are likely to be looked upon with admiration from your colleges for code like this!

I sit back and watch the XP's fall...

Why bother doing all that work when someone else has already done it for you? I think you'll find the List::Util module in the Scalar-List-Utils bundle will do all you want.

use List::Util;

# assume data in @data
my $max = max @data;
my $min = min @data;
my $sum = reduce { $a + $b } @data;
my $avg = $sum / @data;
[download]

Blessed Be
The Pixel

for $nums (@numset){
$min = $nums unless ($min);
$max = $nums unless ($max);
$max=$nums if ($nums > $max);
$min=$nums if ($nums < $min);
$total += $nums; ++$count;
}
print"Minimum: $min","\nMaximum: $max\n","Average: ",$total/$count;
[download]

for $nums ($first,$second,$third,$forth)
or
for $nums (123,32,7,-12,-23,17)
[download]

$min = $nums if ($min == undef); 
$max = $nums if ($max == undef);
[download]

Please note that this code is extremely misleading. undef as used here in a numeric context is exactly replaced with 0, with perhaps a warning if you turn on such.

The only operator that sees undef as what it is, rather than the empty string or 0, is the defined operator.

-- Randal L. Schwartz, Perl hacker