use List::Util qw(min max);
$min = min @list;
$max = max @list;
[download]

A moderate annoyance of List::Util::m(in|ax) is that they dont operate on tied values or situations where there is some form of indirection involved (like finding the key whose value in a hash is the lowest). Then List::Util::reduce() is your friend:

$min = reduce { ($a,$b)[$a < $b] } @list;
$min_key = reduce { ($a,$b)[$x{$a} < $x{$b}] } keys %x;
[download]

Working out max is left as an exercise :-)

---
demerphq

sub max {
    my $max=shift;
    $max < $_ and $max = $_ 
       for @vars;
    return $max;
}
[download]

Is marginally shorted and probably faster, but commits what some would call the crime of logic based control flow.

Update:

Per elusion's update, he has already fixed both solutions.

============

Your solution one does not compile.

Your solution two does not work, and it does not print anything:

use strict;
use warnings;

print max(1.23,2.6,55.1,4,5);

sub max {
    my ($max, $next, @vars) = @_;
    return if not $next;
    return max( $max > $next ? $max : $next, @vars );
}
[download]

sub max {
    my ($x, @xs) = @_;
    @xs ? ($x, max(@xs))[$x < max(@xs)] : $x
}
[download]

Your solution is calling max(@xs) twice each step. This leads to O(2^n) growth for what should be an O(n) problem. Modifying it slightly to call max once and save the value in a temp variable should save considerable time on long lists.

sub max {
    my ($x, @xs) = @_;
    @xs ? do { my $m = maxdo(@xs); ($x, $m)[$x < $m] } : $x;
}
[download]

Here's another recursive form:

sub max {
    my( $i, @l ) = @_;
    my $j = @l ? max( @l ) : $i;
    return $i > $j ? $i : $j;
}
[download]

And for that matter, an iterative form:

sub max {
    $_[ 0 ] < $_[ -1 ] ? shift : pop while @_ > 1;
    return @_;
}
[download]

It's normally best to end recursive solutions with the recursive call. That allows the compiler to use tail-recursion to speed up the solution.

Of course, in Perl you need to jump through a few hoops to do use tail-recursion, so I mentioned but didn't include it in my original node. But with a bit if tinkering you can use it, and here it is now:

sub max {
    my $max  = shift;
    my $next = shift;
    return $max if not $next;
    unshift @_, $max > $next ? $max : $next;
    goto &max;
}
[download]

Which I estimate to be about 10x faster on a random 5000 element list. (Exact benchmarks are left to the reader as an exercise :-).

I wonder if Ponie (Perl 5 On New Internals Engine) will be able to detect and use tail-recursion.

elusion : http://matt.diephouse.com

There's a bug in that code, try finding the max of this list...

@a = (1,0,3,2);
[download]

---

-- All code is 100% tested and functional unless otherwise noted.

That's all well and nice, but my goal was to use an approach which directly generalizes from the specific case of a two element list. As you'll also notice I used the value returned from the recursive call twice, it's both kind of difficult and beside the point to work on tail recursion here. Noone in their right mind writes a recursive max() outside a functional language anyway, and in a pure functional language I'd just write max( @l ) twice and let the compiler/VM figure out that the result need only be calculated once.

In any case, your new approach is just a variation on what was already posted in the parent node — no need for repetition…

Makeshifts last the longest.