#!/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

[download]

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

[download]

ChOas

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

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


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

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
[download]

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.

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

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}
}
[download]

Chris

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;$#_
}
[download]

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

#!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));
[download]

/****************************/
  jason@gost.net, wh@ckz.org
    http://jason.gost.net
/*****************************/
[download]

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

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
[download]

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

Ahhhh, more recursion...

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

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

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