#!/usr/bin/perl
use strict;
use warnings;
use Algorithm::Loops 'MapCar';

my @array1 = 'a' .. 'm';
my @array2 = 1 .. 10;
my @array3 = qw(john jacob jingle heimer smitz);

MapCar(\&print_arrays, \@array1, \@array2, \@array3);

sub print_arrays {
    print join "\t" , @_;
    print "\n";
}
[download]

Cheers - L~R

my @left  =   (  1, 2, 3, 4, 5 );
my @mid   = qw/  A  B  C  D  E /;
my @right = qw/ A3 F7 3B 35 EF /;

my $high = 0;
$high = ( $high > $_ ) ? $high : $_ foreach $#left, $#mid, $#right;
foreach my $idx ( 0 .. $high ) {
    local $, = "\t";
    print map { ( exists $_->[$idx] ) ?
                         $_->[$idx]   :
                         ''
               } \@left, \@mid, \@right;
}
[download]

This has the advantage of not adding useless padding to the end of your arrays. Plus it preserves the array, so you don't have to make a copy of it ahead of time.

Once again it's untested: buyer beware.

my @left  =   ( 1, 2, 3, 4, 5  );
my @mid   = qw/ A  B  C  D  E  /;
my @right = qw/ F1 E4 2C 77 1A /;

print "$left[$_]\t$mid[$_]\t$right[$_]\n" for 0..$#left;
[download]

You'll have to be sure that each of your arrays has the same number of elements; pad the ones that don't.

Hi dave, thanks for your solution, but how can I 'pad' out the shorter arrays? AM

That's something you'll have to decide. Do you want them padded at the end, or at the beginning? Do you want them padded with empty strings, or zeros? The one thing you shouldn't do is leave them different lengths.

Here's a subroutine you can use to "end pad" arrays with whatever string you prefer... as many arrays as you want.

sub padarrays {
    my $padchar = shift;
    my @arrays = @_;
    my $max = 0;
    foreach my $aref ( @arrays ) {
        $max = ( @{$aref} > $max ) ? @{$aref} : $max;
    }
    foreach my $aref ( @arrays ) {
        my $padqty = $max - @{$aref};
        next unless $padqty;
        push @{$aref}, $padchar x $padqty;
    }
}
[download]

The sub takes as its first argument a string (it can be empty, a number, or characters) that should be used to pad each array. It takes a list of array refs as the remainder of its parameters. It will then check the length of each array finding the longest, and pad all the rest of the arrays with your pad character so that they're all the same length.

I didn't have time to test it, you may have to tweak a little to get it to work right. caviet emptor.




Dave

Something like:

@foo = (1,2,3);@bar=(4,5,6,7);
while (@foo || @bar)
{
 print "$foo[0]\t$bar[0]\n";
 shift @foo; shift @bar;
}
[download]

Updated: Note that this solution does not require padding or modules. If you need the original arrays preserved, make copies.