He also isn't saving as many comparisons as he thinks.

I've added some counts to the following version of his implementation of the algorithm and where using three passes on 100 elements you would expect 200 comparisions, his code does 198--for a saving of just 2--, but he also does 302 dereferences (which admitedly is traded for allocating stack space for the arg list) and a mod operation.

Maybe the algorithm can be implemented more economically, but quite where the saving comes in escapes me.

#! perl -slw
use strict;

my( $comps, $mods, $derefs ) = (0)x3;

sub min_max_avg {
    my $ref = shift;
    my ( $min, $max, $agv, $i );
    my ( $current_min, $current_max );
    $comps++; $derefs++; $mods++;
    if ( @{$ref} % 2 == 0 ) {
        $comps++; $derefs +=4;
        ( $min, $max ) =
          $ref->[0] < $ref->[1]
          ? ( $ref->[0], $ref->[1] )
          : ( $ref->[1], $ref->[0] );
        $derefs += 2;
        $agv = $ref->[0] + $ref->[1];
        $i   = 2;
    }
    else {
        $derefs++;
        $min = $max = $agv = $ref->[0];
        $i = 1;
    }
    while ( $i < @{$ref} and ++$comps ) {
        $comps++; $derefs += 4;
        ( $current_min, $current_max ) =
          $ref->[$i] < $ref->[ $i + 1 ]
          ? ( $ref->[$i], $ref->[ $i + 1 ] )
          : ( $ref->[ $i + 1 ], $ref->[$i] );
        $comps++;
        $min = $current_min if ( $current_min < $min );
        $comps++;
        $max = $current_max if ( $current_max > $max );
        $derefs += 2;
        $agv += $ref->[$i] + $ref->[ $i + 1 ];
        $i   += 2;
    }
    $derefs++;
    return ( $min, $max, $agv / @{$ref} );
}


my( $min, $max, $ave ) = min_max_avg [ 1 .. 100 ];;

print "$min $max $ave";

print "comps:$comps derefs: $derefs mods: $mods";
[download]