sort { length($a) <=> length($b) or $a cmp $b } @data;
[download]

  minima { length($a) <=> length($b) or $a cmp $b } @data;
[download]

sub minima(&@)
{
    my $comp = shift;

    @_ <= 1 and return(@_);

    my @cur = ( $_[0] );
    for my $i ( 1 .. $#_ )
    {
        local( $a, $b ) = ( $cur[0], $_[$i] );
        my $r = &$comp;
        if ( $r > 0 )
        {
            @cur = ($_[$i]);
        }
        elsif ( $r == 0 )
        {
            push @cur, $_[$i];
        }
        # else keep current best.
    }

    @cur
}
[download]

• Identify a random value from the resulting list

I like that way of slicing it as well, but I think the name 'minima' fits it less well than it fits my way of slicing it. It is nice that yours only requires a single routine rather than 4 flavors. (I also like that mine uses a simpler key-generating function.)

I'd call it "firsts" but I was already told that would be confusing since there is already List::Util::first. Perhaps "leaders"?

- tye        

Yeah, I was originally inclined to call it "first". "firsts" is even better. But how about "optima"?

tye suggested that minima be added to List::Util. It looks something like this. Of course, his minima was probably terser/cleaner :)

sub minima(&@) {
   my $value = shift(@_);

   my @matches;
   my $min_val;

   {
      local $_ = shift(@_);
      $min_val = &$value();
      @matches = $_;
   }

   foreach (@_) {
      my $val = &$value();
      if    ($val == $min_val) { push(@matches, $_); }
      elsif ($val <  $min_val) { $min_val = $val; @matches = $_; }
   }

   return @matches;
}
[download]

If so, the original question can be solved with:

use List::Util qw( minima maxstr );

my $val = maxstr
          minima { length }
          @list;
[download]

and the bonus question can be solved with:

use List::Util qw( minima );

sub pick { $_[rand(@_)] }

my $val = pick
          minima { length }
          @list;
[download]

This is what I threw on my scratchpad, plus two bug fixes:

sub maxima(&@)
{
    my $measure = shift @_;
    return   if  ! @_;
    my @maxima = shift @_;
    my $max;
    $max = $measure->( $_ )   for  @maxima;
    for( @_ ) {
        my $key = $measure->( $_ );
        if(  $max < $key  ) {
            @maxima = $_;
            $max = $key;
        } elsif(  $max == $key  ) {
            push @maxima, $_;
        }
    }
    return @maxima;
}

sub minima(&@)
{
    my $measure = shift @_;
    return   if  ! @_;
    my @minima = shift @_;
    my $min;
    $min = $measure->( $_ )   for  @minima;
    for( @_ ) {
        my $key = $measure->( $_ );
        if(  $key < $min  ) {
            $min = $key;
            @minima = $_;
        } elsif(  $key == $min  ) {
            push @minima, $_;
        }
    }
    return @minima;
}

sub strmaxima(&@)
{
    my $measure = shift @_;
    return   if  ! @_;
    my @maxima = shift @_;
    my $max;
    $max = $measure->( $_ )   for  @maxima;
    for( @_ ) {
        my $key = $measure->( $_ );
        if(  $max lt $key  ) {
            @maxima = $_;
            $max = $key;
        } elsif(  $max eq $key  ) {
            push @maxima, $_;
        }
    }
    return @maxima;
}

sub strminima(&@)
{
    my $measure = shift @_;
    return   if  ! @_;
    my @minima = shift @_;
    my $min;
    $min = $measure->( $_ )   for  @minima;
    for( @_ ) {
        my $key = $measure->( $_ );
        if(  $key lt $min  ) {
            @minima = $_;
            $min = $key;
        } elsif(  $key eq $min  ) {
            push @minima, $_;
        }
    }
    return @minima;
}
[download]

Which I think would be fine additions to List::Util.

However, (Update: I added return   if  ! @_; to each because ) these should return an empty list not (undef) when given an empty list.

- tye        

I've always known these (at least in their single-valued incarnations) as argmin & argmax, and I've even seen them used with those names in mathematical literature. I would prefer a naming scheme where the "arg-" prefix indicates that we return the index/indices which induced the extremal value(s) (and not the extremal value(s) itself/themselves), and the "-ima" suffix indicates that we return multiple values when there is a tie.

It never occurred to me that a plural version of them might be useful, but I don't see why not. Perhaps the two optimized cases could even be combined efficiently by checking wantarray.

Whatever you want to call it, I'm with you in that I've always wanted functions like these included in List::Util.

blokhead