Here's a pair I like, similar to your delightfully symmeteric third example,

# max
my $max = ($x, $y)[$x < $y];

# min
my $min = ($x, $y)[$x > $y];
[download]

Update: As subroutines,

sub max ($$) { $_[$_[0] < $_[1]] }
sub min ($$) { $_[$_[0] > $_[1]] }
[download]

($x + $y + abs($x - $y)) / 2
[download]

------------
:Wq
Not an editor command: Wq
[download]

Very cool. <nitpick>...but there's still a comparison; it's just hidden in the abs() function: (roughly:) abs(x) := x >= 0 ? x : -x.</nitpick>

[OT] Reminds me of a programming assignment where we were supposed to put the square roots of the integers from 1-100 inclusive into two groups with roughly equal sums. I used the fact that sqrt(x) + sqrt(x+3) is very close to sqrt(x+1) + sqrt(x+2) and managed to outperform all the other submissions by several orders of magnitude in both speed and "difference in sum". (Yea math!)

The nitpick is perfectly valid... I almost made a note of it. Of course, it would be possible (though silly) to implement an abs function without a comparison, such as sub abs { sqrt($_[0]**2) }.

There's probably some mathematical identity for the abs of the difference of two numbers... but I didn't get enough sleep last night to think about what it might be :-)

------------
:Wq
Not an editor command: Wq
[download]

abs(x) can be implemented mathematically as sqrt(x**2). Or it can be implemented at the memory management level by just dropping the bit that carries the negative sign. So it's not necessarily a hidden comparison.

Iterative:

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

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

Update: Fixed my mistake. Thanks, pg. (I always want to use postmodifier if and for in the same statement.) Update: Okay, so I should test my code before I post. Or find where I left my brain. Snippet 2 is fixed.

Perhaps this will count as "cheating" for the purpose of this thread, but I just do this to find the min/max of a list

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.

---
demerphq

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]

Your recursive version of max is broken for lists like (-1,0,1,2) and (-1,undef,1,2). i.e. the code assumes it is at the end of the list whenever $next==0 or $next==undef (which isn't true in general). Here's a snazzy (if not the most efficient) recursive version with a hat tip to Zaxo...

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

---

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

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]

Makeshifts last the longest.

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

As I offered in Re: getting the highest value in a simpler way, we can encapsulate our logic inside of a closure-based factory function that makes "maximum finders":

    sub make_max_finder {
        my $max;
        sub {
            for (@_) { $max = $_ if !defined $max || $_ > $max }
            $max;
        }
    }
[download]

    make_max_finder->(1..10); # 10
[download]

    my $max_finder = make_max_finder();
    $max_finder->($_) while <>;
    $max_finder->();  # retrieve maximum
[download]

Cheers,
Tom

A recursive solution for a list of numbers: (the idea to get max for a list is originally gotten from elusion's post)

use strict;
use warnings;

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

sub max {
    splice(@_, ($_[0] > $_[1]) ? 1 : 0, 1);
    return ($#_ == 0) ? $_[0] : max(@_);
}

sub min {
    splice(@_, ($_[0] > $_[1]) ? 0 : 1, 1);
    return ($#_ == 0) ? $_[0] : min(@_);
}
[download]

Apparently, itub does!

Is List::Util now part of the core? It wasn't in 5.6, which made me not use it.

Being right, does not endow the right to be rude; politeness costs nothing.
Being unknowing, is not the same as being stupid.
Expressing a contrary opinion, whether to the individual or the group, is more often a sign of deeper thought than of cantankerous belligerence.
Do not mistake your goals as the only goals; your opinion as the only opinion; your confidence as correctness. Saying you know better is not the same as explaining you know better.

It is now; that's why I use it. I would be reluctant to use a non-core module for such trivial functions.

Whether or not you can get away with expecting that your users will have either perl-5.8+ or install List::Util on an older version depends on your particular circumstances.

max(3,4);

sub max {
($x,$y)=@_;@xd=split//,$x;
if(length($x) != length($y))
{
 return $x if(length($x)>length($y));
 return $y if(length($y)>length($x));
}
@yd=split//,$y;
for($i;$i<length($x);$i++)
{
 if (ord($xd[$i])!= ord($yd[$i]))
 {
  return $y if( ord($y)>ord($x) );
  return $y if(ord ($y) >ord($x ));
 }
}
}

# *** UNTESTED *** 
# It could be used to compare binary values, 
# but i suppose that is outside the scope of 
# this post.
[download]

There's also the Quantum::Superpositions approach:

sub min { eigenstates( any(@_) <= all(@_) ) }

sub max { eigenstates( any(@_) >= all(@_) ) }
[download]

In the real world, I'd use List::Util::max; if I wrote my own, it'd be this small variation on solutions above:

sub max {
  my $max = shift;
  $max = $max > $_ ? $max : $_ for @_;
  return $max
}
[download]

$max = $x%$y-$x ? $x : $y
[download]

update: d'oh. caveat - "for $x and $y both +ve integers lol...

$x=1;   $y=0;

$x=-1;  $y=2;

$x=1.2; $y=2;
[download]

---

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

Ahh, good point ;-)

Serves me right for trying to be creative on a Windows box sans Perl :)

cLive ;-)