Shortest -return index of element in array- sub

[leons]

Hi monks,

My friend and colleague ChOas and I were having a little contest
here. We dared each other to write the shortest sub, returning the
index-number of the supplied element in an array
We came up with the following ...

#!/usr/bin/perl -w

sub indexArray($@)
{
 my $s=shift;
 $_ eq $s && return @_ while $_=pop;
 -1;
}

my @array=('john','paul','ringo','george');

print indexArray('john',@array) ."\n";      # Returns 0
print indexArray('ringo',@array) ."\n";     # Returns 2
print indexArray('mick',@array) ."\n";      # Returns -1

Is anyone bored enough to participate in this silly contest?
Anything, shorter, funnier, more obfuscated ... will do and
is welcome ;-)

If you do not want to participate because you think this is too
silly and a waste of your time, then please don't, cause you're
right ! ;-)

Bye, Leon

[ChOas]

I think I forgot to show Leon this one ;))
works with strict, and -w


sub indexArray
{
 1 while $_[0] ne pop;
 @_-1;
}


Side node to Arhuman (see below): Respect goes out to you man! ;))

GreetZ!,

ChOas

print "profeth still\n" if /bird|devil/;

[arhuman]

sub indexArray(@)
{        
         1 while $_[0] ne pop;
          $#_;
}

Saves One char...
Could be applied to some of the other solutions (jmcnamara) too...


"Trying to be a SMART lamer" (thanx to Merlyn ;-)

[jmcnamara]

Not really shorter just an alternative. This is in golf mode, therefore no -w or strict:

    #!/usr/bin/perl

    sub indexArray {
        $i = -1;
        undef %h;  
        map {$h{$_} = $i++} @_;
        $h{$_[0]}
    }


    my @array=('john','paul','ringo','george');

    print indexArray('john', @array) ."\n"; # Returns 0
    print indexArray('ringo',@array) ."\n"; # Returns 2
    print indexArray('mick', @array) ."\n"; # Returns -1


John.
--

[Tyke]

How about

sub indexArray{for(1..@_){$_[0]eq$_[$_]&&return$_-1}-1}
my @array=('john','paul','ringo','george');

print indexArray('john',@array) ."\n";      # Returns 0
print indexArray('ringo',@array) ."\n";     # Returns 2
print indexArray('mick',@array) ."\n";      # Returns -1

retaining jmcnamara comments about golf

[tilly]

If the contest is for an index and not the reverse index, then the above solution is correct. But the offerings that use pop will find the last match in the array rather than the first.

[MeowChow]

sub i
{        
  pop ne $_[0] ? &i : $#_
}

Ahhh, recursion...

[jmcnamara]

Or maybe this:

    sub indexArray{
        while (@_) { return @_-1  if $_[0] eq pop }
    }


John.
--

Update: Just saw ChOas' post.

[mr_mischief]

Darn. This is the route I went, too.
Just a slight bit of difference.
I really need to read all the posts before taking a challenge mentioned in the first one. ;-)

sub indexArray2 {
 while(@_){$_[0] eq pop && return @_-1}
}

Chris

[mr_mischief]

Now that I've taken a closer look, this is the shortest iterative version I could find (and also the shortest I could make it and have it run under strictures and warnings, although those aren't really prerequisites in golf):

sub indexArray3{
 1while$_[0]ne pop;$#_
}

I'd say that's pretty obfuscated, too. It can be done in a couple fewer characters recursively, if you use a one-character subroutine name and eliminate any unnecessary whitespace. I'd like to know hoe to do it in fewer iteratively, but I just can't figure anything out. Please point it out to me if there's a way.

Chris Stith

[lindex]

this works:

#!perl 

use strict;
sub iA{join('',map{$_ if($_[0]eq$_[$_])}(1..$#_))-1}

my(@array) = qw(foo bar crap stuff);
print "$_: ".iA($_,@array),"\n" for(qw(foo dolsman crap));

just my two cents :)



lindex

/****************************/
  [e-mail], [e-mail]
    http://jason.gost.net
/*****************************/

[jmcnamara]

This takes my original map idea to its natural(?) conclusion. 23 chars:

    sub array_index {
        @_{@_}=-1..@_;
        $_{$_[0]}
    }



John.
--

[duelafn]

What if we want to find all of the values? The best I could do was this,

sub find {
    1 while $_[0]ne pop;
    $#_+1?(&a(@_),$#_):();
}

my @array=('john','paul','ringo','george', 'ringo');

print &find('john',@array),"\n";      # Returns 0
print &find('ringo',@array),"\n";     # Returns 24
print &find('mick',@array),"\n";      # Returns undef

Good Day,
    Dean

[MeowChow]

sub i {
  pop eq $_[0] ? @_-1 : (), $#_ ? &i : ()
}

Ahhhh, more recursion...

ps. This is why I used @_-1 instead of $#_

[MrNobo1024]

sub aindex {
    grep$_[$_+1]eq$_[0],0..@_-2
}