Assuming the same number of fields on every row of the data file,

my @data;
while (<>) {
   my @fields = split ' ';
   for my $row (0..$#fields) {
      push @{$data[$row]}, $fields[$row];
   }
}
[download]

Tested.

Eh; too much pushing! ;-)

sub transpose
{
    local *_'_;
    map { $_'_ = $_; [ map $_->[$_'_], @_ ] } 0 .. $#{$_[0]}
}
[download]

That doesn't do what my code does at all, which is to avoid the need to fix the array by transposing it by creating it right in the first place. From the point of view, your code is a step backwards. If you wanted to change my code to avoid pushing, then you'd do

my @data;
while (<>) {
   my @fields = split ' ';
   my $col = $. - 1;
   for my $row (0..$#fields) {
      $data[$row][$col] = $fields[$row];
   }
}
[download]

Tested.

Good code, but with that very high sigil-to-text ratio, I was scrambling Google to find out what "*_'_" meant. (FWIW, I did not find the answer in Google, or the docs, but figured it out experimentally). (Side note - the single-quote also threw off my editor's perl-highlighter).

Eventually, I decided I would not write code like that, fascinating as it is - it turns out to be just a way to avoid declaring a local variable. It works just as well replacing all instances of that and "$_'_" with "$Column_Index", and becomes a lot more readable ("local *_'_" being replaced by "my $Column_Index" helps by functioning without resorting to "no strict 'refs'").

I'm hoping this node helps other monks who may not have unraveled "_'_".

I'm also curious as to how this would be written in idiomatic perl6.

     "As you get older three things happen. The first is your memory goes, and I can't remember the other two... " - Sir Norman Wisdom

use Algorithm::Loops "MapCarU";

my @data = MapCarU { [@_] } ['1','2','3'],['a','b','c'],['x','y','z'];

use Data::Dumper;
$Data::Dumper::Terse=1; $Data::Dumper::Indent=0;
print Dumper \@data;
__END__
[['1','a','x'],['2','b','y'],['3','c','z']]
[download]

use List::MoreUtils qw( each_array );

my $iterator = each_array( @a, @b, @c );
while ( my @col = $iterator->() ) {
    print "@col\n";
}
[download]

my $inp='
1 2 3
4 5 6
a b c
x y z
';
my @data;

 my @elem = grep length, split /\s+/, $inp;
 my $rows = () = $inp =~/(?<=^)\w/msg;
 my $cols = @elem / $rows;
 for my $col (0..$cols-1) {
    push @data, [ map $elem[$col + $cols*$_], 0..$rows-1 ]   
 }

 # print the matrix
 print "@$_\n" for @data;
[download]

For a beginner, do you really think that

my $rows = () = $inp =~/(?<=^)\w/msg;
[download]

is non-obfuscated?

I'd rate that as beginner-obfuscated because you use...

• =()=
• (?<=^) in your regexp
• /msg as a regexp modifier
I think these are a bit "in at the deep end" for someone new to Perl.

use strict;
use warnings;

use Data::Dumper;
use List::Util q{max};

my @arr = (
   [ qw{ ein zwei drei } ],
   [ qw{ one two three four five } ],
   [ qw{ un deux trois quatre } ],
   [ qw{ uno due tre quattro cinque sei} ],
   );

print Data::Dumper->Dumpxs([\@arr], [q{*arr}]);

my @transposed =
   map {
           my $col = $_;
           [
               map {
                       exists $arr[$_]->[$col]
                       ? $arr[$_]->[$col]
                       : undef
                   } 0 .. $#arr
           ]
       }
   0 .. max(map { $#{ $_ } } @arr);

print Data::Dumper->Dumpxs([\@transposed], [q{*transposed}]);
[download]

Here's the output.

I imagine some of the modules mentioned could cope with this but haven't checked.

Cheers,

JohnGG

Nice variation of the problem.

@arr = (
   [ qw{ ein zwei drei } ],
   [ qw{ one two three four five } ],
   [ qw{ un deux trois quatre } ],
   [ qw{ uno due tre quattro cinque sei} ],
);;

push @xformed, [ map{ shift @$_  } @arr ] while @{ $arr[-1 ] };;

print pp @xformed;;
(
  ["ein", "one", "un", "uno"],
  ["zwei", "two", "deux", "due"],
  ["drei", "three", "trois", "tre"],
  [undef, "four", "quatre", "quattro"],
  [undef, "five", undef, "cinque"],
  [undef, undef, undef, "sei"],
)
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

Now that's very neat! BrowserUk++

Cheers,

JohnGG

Really! How hard is it to transpose the indexes of a pair of foreach loops?

Isn't this so much easier to understand?

#!/usr/bin/perl
use warnings;
use strict;

my @in = ([1,2,3,4,'a','b','c'],
          ['z','y','x','w',9,8,7],
          ['e','f','g','h',5,4,6],
          );
my @out;

for my $y (0..(@in-1)) {
    for my $x (0..(@{$in[$y]}-1)) {
        $out[$x][$y] = $in[$y][$x];
    }
}
[download]

No need to be a Perl geek to do this right! And think of the ease of maintenance!

for my $y (0..(@in-1)) {
    for my $x (0..(@{$in[$y]}-1)) {
[download]

I'm puzzled as to why you do the subtractions to find the upper bound of the arrays rather than use the $#array that Perl provides.

for my $y ( 0 .. $#in ) {
    for my $x ( 0 .. $#{$in[$y]} ) {
[download]

Cheers,

JohnGG