use warnings;
use strict;

my @array1=(1,2,3,4,8);
my @array2=(1,4,2,4,5);
my @array3=(1,6,1,7,5);
foreach my $element (@array1, @array2, @array3){
    if ($element == 1){
        ##do something;
    }
}
[download]

• grep
• map
• List::Util

Update: my solution was posted before the OP's UPDATE.

thanks for your help

Problem: Iterate over each array in parallel (in other words, treat each array as a column, and each index as a row). For each row, find the max value among the columns, and report that max along with which column or columns have that value.

One possible solution: I created a subroutine named get_max_and_column_list_per_row(), which is a really awkward name, but it does pretty much exactly what you're asking for:

Pass it a list of array references (a LOL: perllol). The function evaluates each row (each outer index) to find the max value in that row's columns. It also keeps track of which columns that max was found in. It constructs an array in original row order. That array consists of an anonymous hash. The key is that max value found for the given row. The value is an anonymous array of the column numbers that contained that max value. Clear as mud. :)

use Modern::Perl;
use List::Util qw( max );

# Build a sample dataset of ten rows of ten columns each,
# with random numbers between zero and nine.

my @lists = map { 
    [ map { int( rand( 10 ) ) } 1 .. 10 ]
} 1 .. 10;


# Invoke our dirty little function to get the list
# of maxes per row, and columns that hit that max.

my @max_indices = get_max_and_column_list_per_row( @lists );


# Print our list out nicely.

{
    local $" = ", ";
    foreach my $row_index ( 0 .. $#max_indices ) {
        my ( $max, $columns ) = each %{ $max_indices [ $row_index ] };
        say "Row  $row_index  has a max of  $max  in column(s)  @{$col
+umns}";
    }
}


# The ugly function.  Accepts a LoL, returns a LoHoL.

sub get_max_and_column_list_per_row {
    my( @arrays ) = @_;

    # First, find out how many columns we have.
    my $top_index = max( map $#{$_}, @arrays );

    # The rest is a big map{}.
    return map {
        my $outer_index = $_;
        my $current_max = max( @{ $lists[$outer_index] } );
        +{  # Anonymous hash constructor.
            $current_max => 
            [ grep { $lists[$outer_index][$_] == $current_max } 
              0 .. $top_index ] 
        } # End of anonymous hash constructor.
    } 0 .. $#lists;
}
[download]

Sample output:

Row  0  has a max of  9  in column(s)  2, 5
Row  1  has a max of  7  in column(s)  7, 9
Row  2  has a max of  7  in column(s)  6
Row  3  has a max of  9  in column(s)  1
Row  4  has a max of  9  in column(s)  3
Row  5  has a max of  9  in column(s)  8
Row  6  has a max of  6  in column(s)  5, 6, 7, 8
Row  7  has a max of  9  in column(s)  7
Row  8  has a max of  8  in column(s)  0
Row  9  has a max of  9  in column(s)  0
[download]

Your output will vary because the dataset is built up with random numbers.

thanks for your help!

My only advice is to just do it. You can compile the arrays into a list of arrays, or you could add them to a hash where you give each a name. Either way, just iterate on each array and use List::Util->reduce to determine the position of the max element.

use List::Util qw(reduce);

use strict;
use warnings;

my @array1 = (1,2,3,4,8);
my @array2 = (1,4,2,4,5);
my @array3 = (1,6,1,7,5);

for my $array (\@array1, \@array2, \@array3) {
    my $max_pos = reduce {$array->[$b] > $array->[$a] ? $b : $a} keys 
+@$array;
    print "Max is $array->[$max_pos] at position $max_pos\n";
}

=prints
Max is 8 at position 4
Max is 5 at position 4
Max is 7 at position 3
=cut
[download]

thanks for your help much appreciated!

Update: updated code to do what I think op is asking for..used wind's row code with List::Util::reduce() for a transposed "column".

#!/usr/bin/perl -w
use strict;
use List::Util qw(reduce max);

my @array1=(1,2,3,4,8);
my @array2=(1,4,2,4,5);
my @array3=(1,6,1,7,5);

my @AoA = (\@array1,\@array2,\@array3);
my @transposed;

print "Original array:\n";
printAoA(\@AoA);

## tranpose array to make it easy to do column operations
##   i.e. columns become rows

foreach my $rowref (@AoA)
{
   my $i=0;
   foreach my $num (@$rowref)
   {
      push @{$transposed[$i++]}, $num;
   }
}

##  Now @transposed is an array of references to what used to be
##    columns.

print "\nMaximum of each column...\n".
         "coordinates based on row 0..n, col 0..n\n";
my $col=0;
foreach my $colref (@transposed) 
{
    ## you could have a loop: foreach my $num (@$colref) {} here
    ## below is wind's use of reduce to get the column position of
    ## the first maximum, perhaps you have something different in
    ## mind?
    
    my $max_pos = reduce {$colref->[$b] > $colref->[$a] ? $b : $a} (0.
+.@$colref-1);
    print "Max of column index $col is $colref->[$max_pos] at array in
+dex $max_pos\n";
    $col++;
}

print "\nTransposed array:\n";
printAoA(\@transposed);


sub printAoA
{
   my $refAoA = shift;
   foreach my $rowref (@$refAoA)
   {
     print join(",",@$rowref),"\n";  
   }
}
__END__
Original array:
1,2,3,4,8
1,4,2,4,5
1,6,1,7,5

Maximum of each column...
coordinates based on row 0..n, col 0..n
Max of column index 0 is 1 at array index 0
Max of column index 1 is 6 at array index 2
Max of column index 2 is 3 at array index 0
Max of column index 3 is 7 at array index 2
Max of column index 4 is 8 at array index 0

Transposed array:
1,1,1
2,4,6
3,2,1
4,4,7
8,5,5
[download]

This is incredible, thanks so much!

See also Re: can we pass two variable to foreach loop.

Thanks ambrus for the link, the comparing 2 arrays is very useful code and I will be making use of it soon